Opencv摄像头实时人脸识别

• Introduction

网上存在很多人脸识别的文章，这篇文章是我的一个作业，重在通过摄像头实时采集人脸信息，进行人脸检测和人脸识别，并将识别结果显示在左上角。

利用 OpenCV 实现一个实时的人脸识别系统，人脸库采用 ORL FaceDatabase (网上下载) ，另外在数据库中增加了作业中自带的20张照片和自己利用摄像头采集到的10张照片，系统利用摄像头实时的采集到场景图像，从中检测出人脸用方框标出，并利用提供的数据库进行人脸识别，并在图像左上角显示相匹配的数据库图片。

• Method

算法流程分两步，分别是人脸检测和人脸识别。人脸检测使用的是 ViolaJones 人脸检测方法，利用样本的 Haar-like 特征进行分类器训练，得到级联boosted 分类器，加载训练好的人脸分类器，利用分类器在视频帧中查找人脸区域；人脸识别利用了局部二进制模式直方图。

• Haar-like 特征

Haar-like 特征如下图所示

图1 Haar-like 特征

• LBPH

人脸识别常用的方法有三种，Eigenfaces、Fisherfaces 和 LBPH；对于高维的图像空间，我们首先应该进行降维操作。LBP 不把图像看做高维的矢量，而是通过物体的局部特征来描述。将每个像素和其相邻像素对比形成局部的结构，把该像素看做中心，并以该值对邻接像素做阈值处理，如果临界像素的亮度大于该像素则为 1 否则为 0，这样每个像素点都可以用一个二进制数来表示，比如一个使用 3*3 临界点的 LBP 操作如下图所示：

图2 LBP

• Implementation
• 识别训练

利用准备好的数据库进行识别训练：首先我们利用Opencv安装文件中的python脚本create_csv.py建立CSV文件，文件中每条记录如：orl/s13/2.pgm;12，分号之前是图片所存路径，而分号之后是图片的标签号，每一组图片对应着唯一的标签号；之后利用代码中的train_data和read_csv函数对数据集进行训练。使用到的 OpenCV 类和函数有：FaceRecognizer，createLBPHFaceRecognizer

• 人脸检测

运用Opencv安装文件中的haarcascade_frontalface_alt.xml文件，使用分类器在视频帧中查找人脸区域，并用绿色方框标出。用到的 OpenCV 类和函数有：CascadeClassifier,detectMultiScale。

• 人脸识别

读取训练好的 yaml文件，对每个监测到的区域的图像分类，并在视频帧人脸区域上方显示分类结果（分类结果显示为标签和可信度），在左上角显示缩略图。用到的 OpenCV 函数主要有:predict.

• Code

看到评论，大家需要config.h，抱歉事情多添加有些晚，我放在下面了，有什么问题欢迎交流~

#include "opencv2/core/core.hpp"
#include "opencv2/contrib/contrib.hpp"
#include "opencv2/highgui/highgui.hpp"
#include "opencv2/imgproc/imgproc.hpp"
#include "opencv2/objdetect/objdetect.hpp"

#include <iostream>
#include <fstream>
#include <sstream>
#include <string.h>

char *FACES_TXT_PATH = "face.txt";
char *HARR_XML_PATH = "haarcascade_frontalface_alt.xml";
char *FACES_MODEL = "face.yaml";
char *POTRAITS ="potraits.jpg";
int DEVICE_ID = ;

主文件内容：

 /*头文件：*/
 #include "opencv2/core/core.hpp"
 #include "opencv2/contrib/contrib.hpp"
 #include "opencv2/highgui/highgui.hpp"
 #include "opencv2/imgproc/imgproc.hpp"
 #include "opencv2/objdetect/objdetect.hpp"

 #include <iostream>
 #include <fstream>
 #include <sstream>
 #include <string.h>

 char *FACES_TXT_PATH = "face.txt";
 char *HARR_XML_PATH = "haarcascade_frontalface_alt.xml";
 char *FACES_MODEL = "face.yaml";
 char *POTRAITS ="potraits.jpg";
 int DEVICE_ID = ;

 /*主文件*/
 #include "config.h"

 using namespace cv;
 using namespace std;
 int FACE_WIDHT=;
 int FACE_HEIGHT=;
 int POTRITE_WIDTH = ;
 int POTRITE_HEIGHT = ;

 static void read_csv(const string& filename, vector<Mat>& images, vector<int>& labels, char separator = ';') {
     std::ifstream file(filename.c_str(), ifstream::in);
     if (!file) {
         string error_message = "找不到文件，请核对路径";
         CV_Error(CV_StsBadArg, error_message);
     }
     string line, path, classlabel;
     while (getline(file, line)) {
         stringstream liness(line);
         getline(liness, path, separator);
         getline(liness, classlabel);
         if(!path.empty() && !classlabel.empty()) {
             images.push_back(imread(path, ));
             labels.push_back(atoi(classlabel.c_str()));
         }
     }

 }

 /*利用csv文件读取数据集并训练对应模型*/
 void train_data(String fn_csv)
 {
     vector<Mat> images;
     vector<int> labels;
     //获取数据集，如果出错抛出异常
     try {
         read_csv(fn_csv, images, labels);
     }
     catch (cv::Exception& e) {
         cerr << "打开文件失败 \"" << fn_csv << "\". 原因： " << e.msg << endl;
         exit();
     }

     // 如果训练集数量不够退出
     if(images.size() <= ) {
         string error_message = "训练集图片少于2";
         CV_Error(CV_StsError, error_message);
     }

     //训练模型
     Ptr<FaceRecognizer> model = createLBPHFaceRecognizer();
     model->train(images, labels);
     model->save(FACES_MODEL);
 }

 void show_portrait(Mat &potrait, Mat &frame) {
     int channels = potrait.channels();
     int nRows = potrait.rows;
     int nCols = potrait.cols*channels;

     uchar *p_p, *p_f;
     for(auto i=; i<nRows; i++) {
         p_p = potrait.ptr<uchar>(i);
         p_f = frame.ptr<uchar>(i);
         for(auto j=; j<nCols; j++) {
             p_f[j*] = p_p[j];
             p_f[j*+] = p_p[j+];
             p_f[j*+] = p_p[j+];
         }
     }

 }

 void makePotraitImages(vector<Mat> potraits) {
     int rows = potraits.size()/;
     if(potraits.size()-rows *>)rows++;
     rows *= POTRITE_HEIGHT;
     int cols = *POTRITE_HEIGHT;
     Mat potrait_s = Mat(rows,cols,CV_8UC3);
     rows = POTRITE_HEIGHT;
     cols = POTRITE_WIDTH;
     uchar *p_ps, *p_p;
     for(auto i=; i<potraits.size(); i++) {
         for(auto j=; j<rows; j++) {
             p_ps = potrait_s.ptr<uchar>(i/*POTRITE_HEIGHT+j)+*(i%)*POTRITE_WIDTH;
             p_p = potraits[i].ptr<uchar>(j);
             for(auto k=; k<cols; k++) {
                 p_ps[k*] = p_p[k];
                 p_ps[k*+] = p_p[k+];
                 p_ps[k*+] = p_p[k+];
             }
         }
     }
     imwrite(POTRAITS, potrait_s);
 }

 void loadPortraits(const string& filename, vector<Mat>& images, char separator = ';') {
     string fn_csv = string(FACES_TXT_PATH);
     std::ifstream file(fn_csv.c_str(), ifstream::in);
     if (!file) {
         string error_message = "找不到文件，请核对路径.";
         CV_Error(CV_StsBadArg, error_message);
     }
     string line, path, classlabel;
     int label();
     while (getline(file, line)) {
         stringstream liness(line);
         getline(liness, path, separator);
         getline(liness, classlabel);
         if(!path.empty() && !classlabel.empty()) {
             if(atoi(classlabel.c_str()) != label) {
                 Mat potrait = imread(path, );
                 resize(potrait, potrait,Size(POTRITE_WIDTH, POTRITE_HEIGHT));
                 images.push_back(potrait);
                 label = atoi(classlabel.c_str());
             }
         }
     }
 }

 int main(int argc, const char *argv[]) {
     // 保存图像和对应标签的向量，要求同一个人的图像必须对应相同的标签
     string fn_csv = string(FACES_TXT_PATH);
     string fn_haar = string(HARR_XML_PATH);

     Ptr<FaceRecognizer> model = createLBPHFaceRecognizer();
     FileStorage model_file(FACES_MODEL, FileStorage::READ);
     if(!model_file.isOpened()){
         cout<<"无法找到模型，训练中..."<<endl;
         train_data(fn_csv);//训练数据集，1表示EigenFace 2表示FisherFace 3表示LBPHFace
     }
     model->load(model_file);
     model_file.release();
     vector<Mat> potraits;
     loadPortraits(FACES_MODEL,potraits);
     makePotraitImages(potraits);
     CascadeClassifier haar_cascade;
     haar_cascade.load(fn_haar);

     VideoCapture cap(DEVICE_ID);
     if(!cap.isOpened()) {
         cerr << "设备 " << DEVICE_ID << "无法打开" << endl;
         return -;
     }

     Mat frame;
     for(;;) {
         cap >> frame;
         if(!frame.data)continue;
         // 拷贝现有frame
         Mat original = frame.clone();
         // 灰度化
         Mat gray;
         cvtColor(original, gray, CV_BGR2GRAY);
         // 识别frame中的人脸
         vector< Rect_<int> > faces;
         haar_cascade.detectMultiScale(gray, faces);

         if(faces.size() != )
         {
             int max_area_rect=;
             for(int i = ; i < ; i++) {
                 if(faces[i].area() > faces[max_area_rect].area()){
                     max_area_rect = i;
                 }

             }

             // 顺序处理
             Rect face_i = faces[max_area_rect];

             Mat face = gray(face_i);
             rectangle(original, face_i, CV_RGB(, ,), );
             int pridicted_label = -;
             double predicted_confidence = 0.0;
             model->predict(face, pridicted_label, predicted_confidence);
             string result_text = format("Prediction = %d confidence=%f", pridicted_label, predicted_confidence);
             int text_x = std::max(face_i.tl().x - , );
             int text_y = std::max(face_i.tl().y - , );
             putText(original,result_text,  Point(text_x, text_y),FONT_HERSHEY_PLAIN, 1.0, CV_RGB(,,), 2.0);
             if(pridicted_label >)
                 show_portrait(potraits[pridicted_label], original);
         }
         // 显示结果:
         imshow("face_recognizer", original);

         char key = (char) waitKey();
         if(key == )
             exit();;
     }
     return ;
 }

• Experiment

图3 结果展示

图4 人脸库拼图