opencv 人脸识别（一）训练样本的处理

最新推荐文章于 2023-06-30 19:53:37 发布

荪荪

最新推荐文章于 2023-06-30 19:53:37 发布

阅读量2.9k

点赞数

分类专栏：人脸检测

人脸检测专栏收录该内容

50 篇文章 0 订阅

订阅专栏

本文实现基于eigenface的人脸检测与识别。给定一个图像数据库，进行以下步骤：

进行人脸检测，将检测出的人脸存入数据库2
对数据库2进行人脸建模
在测试集上进行recognition

本篇实现第一步：

进行人脸检测，将检测出的人脸存入数据库2

环境：vs2010+opencv 2.4.6.0

特征：eigenface

Input：一个人脸数据库，15个人，每人20个样本（左右）。

Output：人脸检测，并识别出每张检测到的人脸。

===============================

本文完成第一步，数据预处理：自动检测所有文件夹中每个sample中的人脸，作为训练数据。

Input：一个color文件夹，每个文件夹中有1~N这N个子文件夹，每个子文件夹内有n张包括第n类人的照片，如图。

最终结果：

核心：face detection（detectAndDraw）

辅助：截图并保存部分图片(CutImg)，文件夹内图片遍历(read_img)，图片转换成相同大小（normalizeone）

括号内分别是函数名，下面分别给出代码及说明。

1. 遍历文件夹：CBrowseDir类和CStatDir类（具体见这篇），三个文件如下：

1.1 BrowseDir.h

[cpp]view plaincopy 
   
 #pragma once  
 #include "direct.h"  
 #include "string.h"  
 #include "io.h"  
 #include "stdio.h"   
 #include <vector>  
 #include <iostream>  
 using namespace std;  
 class CBrowseDir  
 {  
 protected:  
     char m_szInitDir[_MAX_PATH];  
   
 public:  
     CBrowseDir();  
     bool SetInitDir(const char *dir);  
     bool BeginBrowse(const char *filespec);  
     vector<char*> BeginBrowseFilenames(const char *filespec);  
   
 protected:  
     bool BrowseDir(const char *dir,const char *filespec);  
     vector<char*> GetDirFilenames(const char *dir,const char *filespec);  
     virtual bool ProcessFile(const char *filename);  
     virtual void ProcessDir(const char *currentdir,const char *parentdir);  
 };  

1.2 BrowseDir.cpp

[cpp]view plaincopy 
   
 #include "BrowseDir.h"  
 #include "direct.h"  
 #include "string.h"  
 #include "io.h"  
 #include "stdio.h"   
 #include <vector>  
 #include <iostream>  
 using namespace std;  
   
 CBrowseDir::CBrowseDir()  
 {  
     getcwd(m_szInitDir,_MAX_PATH);  
     int len=strlen(m_szInitDir);  
     if (m_szInitDir[len-1] != '\\')  
         strcat(m_szInitDir,"\\");  
 }  
   
 bool CBrowseDir::SetInitDir(const char *dir)  
 {  
     if (_fullpath(m_szInitDir,dir,_MAX_PATH) == NULL)  
         return false;  
   
     if (_chdir(m_szInitDir) != 0)  
         return false;  
     int len=strlen(m_szInitDir);  
     if (m_szInitDir[len-1] != '\\')  
         strcat(m_szInitDir,"\\");  
   
     return true;  
 }  
   
 vector<char*>CBrowseDir:: BeginBrowseFilenames(const char *filespec)  
 {  
     ProcessDir(m_szInitDir,NULL);  
     return GetDirFilenames(m_szInitDir,filespec);  
 }  
   
 bool CBrowseDir::BeginBrowse(const char *filespec)  
 {  
     ProcessDir(m_szInitDir,NULL);  
     return BrowseDir(m_szInitDir,filespec);  
 }  
   
 bool CBrowseDir::BrowseDir(const char *dir,const char *filespec)  
 {  
     _chdir(dir);  
     long hFile;  
     _finddata_t fileinfo;  
     if ((hFile=_findfirst(filespec,&fileinfo)) != -1)  
     {  
         do  
         {  
             if (!(fileinfo.attrib & _A_SUBDIR))  
             {  
                 char filename[_MAX_PATH];  
                 strcpy(filename,dir);  
                 strcat(filename,fileinfo.name);  
                 cout << filename << endl;  
                 if (!ProcessFile(filename))  
                     return false;  
             }  
         } while (_findnext(hFile,&fileinfo) == 0);  
         _findclose(hFile);  
     }  
     _chdir(dir);  
     if ((hFile=_findfirst("*.*",&fileinfo)) != -1)  
     {  
         do  
         {  
             if ((fileinfo.attrib & _A_SUBDIR))  
             {  
                 if (strcmp(fileinfo.name,".") != 0 && strcmp  
                     (fileinfo.name,"..") != 0)  
                 {  
                     char subdir[_MAX_PATH];  
                     strcpy(subdir,dir);  
                     strcat(subdir,fileinfo.name);  
                     strcat(subdir,"\\");  
                     ProcessDir(subdir,dir);  
                     if (!BrowseDir(subdir,filespec))  
                         return false;  
                 }  
             }  
         } while (_findnext(hFile,&fileinfo) == 0);  
         _findclose(hFile);  
     }  
     return true;  
 }  
   
 vector<char*> CBrowseDir::GetDirFilenames(const char *dir,const char *filespec)  
 {  
     _chdir(dir);  
     vector<char*>filename_vec;  
     filename_vec.clear();  
   
     long hFile;  
     _finddata_t fileinfo;  
     if ((hFile=_findfirst(filespec,&fileinfo)) != -1)  
     {  
         do  
         {  
             if (!(fileinfo.attrib & _A_SUBDIR))  
             {  
                 char *filename = new char[_MAX_PATH];  
                 strcpy(filename,dir);  
                 //int st = 0;   while (dir[st++]!='\0');  
                 strcat(filename,fileinfo.name); //filename[st]='\0';  
                 filename_vec.push_back(filename);  
             }  
         } while (_findnext(hFile,&fileinfo) == 0);  
         _findclose(hFile);  
     }  
     _chdir(dir);  
     if ((hFile=_findfirst("*.*",&fileinfo)) != -1)  
     {  
         do  
         {  
             if ((fileinfo.attrib & _A_SUBDIR))  
             {  
                 if (strcmp(fileinfo.name,".") != 0 && strcmp  
                     (fileinfo.name,"..") != 0)  
                 {  
                     char subdir[_MAX_PATH];  
                     strcpy(subdir,dir);  
                     strcat(subdir,fileinfo.name);  
                     strcat(subdir,"\\");  
                     ProcessDir(subdir,dir);  
                     return GetDirFilenames(subdir,filespec);  
                 }  
             }  
         } while (_findnext(hFile,&fileinfo) == 0);  
         _findclose(hFile);  
     }  
     return filename_vec;  
 }  
   
 bool CBrowseDir::ProcessFile(const char *filename)  
 {  
     return true;  
 }  
   
 void CBrowseDir::ProcessDir(const char   
     *currentdir,const char *parentdir)  
 {  
 }  

1.3 StatDir.h

[cpp]view plaincopy 
   
 #pragma once  
 #include "browsedir.h"  
 class CStatDir:public CBrowseDir  
 {  
 protected:  
     int m_nFileCount;   //保存文件个数  
     int m_nSubdirCount; //保存子目录个数  
   
 public:  
     CStatDir()  
     {  
         m_nFileCount=m_nSubdirCount=0;  
     }  
   
     int GetFileCount()  
     {  
         return m_nFileCount;  
     }  
   
     int GetSubdirCount()  
     {  
         return m_nSubdirCount-1;  
     }  
   
 protected:  
     virtual bool ProcessFile(const char *filename)  
     {  
         m_nFileCount++;  
         return CBrowseDir::ProcessFile(filename);  
     }  
   
     virtual void ProcessDir  
         (const char *currentdir,const char *parentdir)  
     {  
         m_nSubdirCount++;  
         CBrowseDir::ProcessDir(currentdir,parentdir);  
     }  
 };  

2. 辅助函数Prehelper.h, Prehelper.cpp：负责返回文件夹内所有图片（read_img），检测人脸（detectAndDraw并可以在原图中画出），截图（CutImg），提取(DetectandExtract)

2.1 Prehelper.h

[cpp]view plaincopy 
   
 //preprocessing helper  
 //@ Author : Rachel-Zhang  
   
 #include "opencv2/core/core.hpp"  
 #include "opencv2/highgui/highgui.hpp"  
 #include "opencv2/contrib/contrib.hpp"  
 #include <cv.h>  
 #include <vector>  
 #include <utility>  
 using namespace cv;  
 using namespace std;  
   
 void normalizeone(const char* dir,IplImage* standard);  
   
 void CutImg(IplImage* src, CvRect rect,IplImage* res);  
   
 vector<Rect> detectAndDraw( Mat& img, CascadeClassifier& cascade,  
     CascadeClassifier& nestedCascade,  
     double scale, bool tryflip,bool draw );  
   
 IplImage* DetectandExtract(Mat& img, CascadeClassifier& cascade,  
     CascadeClassifier& nestedCascade,  
     double scale, bool tryflip);  
   
 int read_img(const string& dir, vector<Mat> &images);  
   
 vector<pair<char*,Mat>>  read_img(const string& dir);  

2.2 Prehelper.cpp

[cpp]view plaincopy 
   
 #include "Prehelper.h"  
 #include "BrowseDir.h"  
 #include "StatDir.h"  
   
 #include <opencv2/core/core.hpp>  
 #include <opencv2/highgui/highgui.hpp>  
 #include <cv.h>  
 using namespace cv;  
   
 void normalizeone(const char* dir,IplImage* standard)  
 {  
     CStatDir statdir;  
     if (!statdir.SetInitDir(dir))  
     {  
         puts("Dir not exist");  
         return;  
     }  
     vector<char*>file_vec = statdir.BeginBrowseFilenames("*.*");  
     int i;  
     for (i=0;i<file_vec.size();i++)  
     {  
         IplImage* cur_img = cvLoadImage(file_vec[i],CV_LOAD_IMAGE_GRAYSCALE);  
         //IplImage*cur_gray = cvCreateImage(cvGetSize(cur_img),cur_img->depth,1);  
         cvResize(cur_img,standard,CV_INTER_AREA);  
         //cvCvtColor(standard,cur_gray,CV_RGB2GRAY);  
         //      cvNamedWindow("cur_img",CV_WINDOW_AUTOSIZE);  
         //      cvNamedWindow("standard",CV_WINDOW_AUTOSIZE);  
         //      cvShowImage("cur_img",cur_img);  
         //      cvShowImage("standard",standard);  
         //      cvWaitKey();  
         cvSaveImage(file_vec[i],cur_img);  
     }  
 }  
   
 void CutImg(IplImage* src, CvRect rect,IplImage* res)  
 {  
     CvSize imgsize;  
     imgsize.height = rect.height;  
     imgsize.width = rect.width;  
     cvSetImageROI(src,rect);  
     cvCopy(src,res);  
     cvResetImageROI(res);  
 }  
   
 int read_img(const string& dir, vector<Mat> &images)  
 {  
     CStatDir statdir;  
     if (!statdir.SetInitDir(dir.c_str()))  
     {  
         cout<<"Direct "<<dir<<"  not exist!"<<endl;  
         return 0;  
     }  
     int cls_id = dir[dir.length()-1]-'0';  
     vector<char*>file_vec = statdir.BeginBrowseFilenames("*.*");  
     int i,s = file_vec.size();  
     for (i=0;i<s;i++)  
     {  
         Mat graymat = imread(file_vec[i],0);  
         //graymat.reshape(1,1);//flatten to one row  
         images.push_back(graymat);  
     }  
     return s;  
 }  
   
 vector<pair<char*,Mat>>  read_img(const string& dir)  
 {  
     CStatDir statdir;  
     pair<char*,Mat> pfi;  
     vector<pair<char*,Mat>> Vp;  
     if (!statdir.SetInitDir(dir.c_str()))  
     {  
         cout<<"Direct "<<dir<<"  not exist!"<<endl;  
         return Vp;  
     }  
     int cls_id = dir[dir.length()-1]-'0';  
     vector<char*>file_vec = statdir.BeginBrowseFilenames("*.*");  
     int i,s = file_vec.size();  
     for (i=0;i<s;i++)  
     {  
         pfi.first = file_vec[i];  
         pfi.second = imread(file_vec[i]);  
         Vp.push_back(pfi);  
     }  
     return Vp;  
 }  
   
 vector<Rect> detectAndDraw( Mat& img, CascadeClassifier& cascade,  
     CascadeClassifier& nestedCascade,  
     double scale, bool tryflip, bool draw )  
 {  
     int i = 0;  
     double t = 0;  
     vector<Rect> faces, faces2;  
     const static Scalar colors[] =  { CV_RGB(0,0,255),  
         CV_RGB(0,128,255),  
         CV_RGB(0,255,255),  
         CV_RGB(0,255,0),  
         CV_RGB(255,128,0),  
         CV_RGB(255,255,0),  
         CV_RGB(255,0,0),  
         CV_RGB(255,0,255)} ;  
     Mat gray, smallImg( cvRound (img.rows/scale), cvRound(img.cols/scale), CV_8UC1 );  
   
     cvtColor( img, gray, CV_BGR2GRAY );  
     resize( gray, smallImg, smallImg.size(), 0, 0, INTER_LINEAR );  
     equalizeHist( smallImg, smallImg );  
   
     t = (double)cvGetTickCount();  
     cascade.detectMultiScale( smallImg, faces,  
         1.1, 2, 0  
         |CV_HAAR_FIND_BIGGEST_OBJECT  
         //|CV_HAAR_DO_ROUGH_SEARCH  
         //|CV_HAAR_SCALE_IMAGE  
         ,  
         Size(30, 30) );  
     if( tryflip )  
     {  
         flip(smallImg, smallImg, 1);  
         cascade.detectMultiScale( smallImg, faces2,  
             1.1, 2, 0  
             |CV_HAAR_FIND_BIGGEST_OBJECT  
             //|CV_HAAR_DO_ROUGH_SEARCH  
             //|CV_HAAR_SCALE_IMAGE  
             ,  
             Size(30, 30) );  
         for( vector<Rect>::const_iterator r = faces2.begin(); r != faces2.end(); r++ )  
         {  
             faces.push_back(Rect(smallImg.cols - r->x - r->width, r->y, r->width, r->height));  
         }  
     }  
     t = (double)cvGetTickCount() - t;  
     printf( "detection time = %g ms\n", t/((double)cvGetTickFrequency()*1000.) );  
     if(draw)  
     {  
         for( vector<Rect>::const_iterator r = faces.begin(); r != faces.end(); r++, i++ )  
         {  
             Mat smallImgROI;  
             vector<Rect> nestedObjects;  
             Point center;  
             Scalar color = colors[i%8];  
             int radius;  
   
             double aspect_ratio = (double)r->width/r->height;  
             rectangle( img, cvPoint(cvRound(r->x*scale), cvRound(r->y*scale)),  
                 cvPoint(cvRound((r->x + r->width-1)*scale), cvRound((r->y + r->height-1)*scale)),  
                 color, 3, 8, 0);  
             if( nestedCascade.empty() )  
                 continue;  
             smallImgROI = smallImg(*r);  
             nestedCascade.detectMultiScale( smallImgROI, nestedObjects,  
                 1.1, 2, 0  
                 |CV_HAAR_FIND_BIGGEST_OBJECT  
                 //|CV_HAAR_DO_ROUGH_SEARCH  
                 //|CV_HAAR_DO_CANNY_PRUNING  
                 //|CV_HAAR_SCALE_IMAGE  
                 ,  
                 Size(30, 30) );  
             //draw eyes  
             //         for( vector<Rect>::const_iterator nr = nestedObjects.begin(); nr != nestedObjects.end(); nr++ )  
             //         {  
             //             center.x = cvRound((r->x + nr->x + nr->width*0.5)*scale);  
             //             center.y = cvRound((r->y + nr->y + nr->height*0.5)*scale);  
             //             radius = cvRound((nr->width + nr->height)*0.25*scale);  
             //             circle( img, center, radius, color, 3, 8, 0 );  
             //         }  
         }  
         cv::imshow( "result", img );  
     }  
     return faces;  
 }  
   
 IplImage* DetectandExtract(Mat& img, CascadeClassifier& cascade,  
     CascadeClassifier& nestedCascade,  
     double scale, bool tryflip)  
 {  
     vector<Rect> Rvec = detectAndDraw(img,cascade,nestedCascade,scale,tryflip,0);  
     int i,maxxsize=0,id=-1,area;  
     for (i=0;i<Rvec.size();i++)  
     {  
         area = Rvec[i].width*Rvec[i].height;  
         if(maxxsize<area)  
         {  
             maxxsize = area;  
             id = i;  
         }  
     }  
     IplImage* transimg = cvCloneImage(&(IplImage)img);  
     if(id!=-1)  
     {  
         CvSize imgsize;  
         imgsize.height = Rvec[id].height;  
         imgsize.width = Rvec[id].width;  
         IplImage* res = cvCreateImage(imgsize,transimg->depth,transimg->nChannels);  
         CutImg(transimg,Rvec[id],res);  
   
         return res;  
     }  
     return NULL;  
 }  

3. 主函数

[cpp]view plaincopy 
   
 //Detect.cpp  
 //Preprocessing - Detect, Cut and Save  
 //@Author : Rachel-Zhang  
   
 #include "opencv2/objdetect/objdetect.hpp"  
 #include "opencv2/highgui/highgui.hpp"  
 #include "opencv2/imgproc/imgproc.hpp"  
   
 #include <cctype>  
 #include <iostream>  
 #include <iterator>  
 #include <stdio.h>  
 #include "BrowseDir.h"  
 #include "StatDir.h"  
 #include "Prehelper.h"  
   
 using namespace std;  
 using namespace cv;  
 #define CAM 2  
 #define PHO 1  
 #define K 5  
   
 string cascadeName = "E:/software/opencv2.4.6.0/data/haarcascades/haarcascade_frontalface_alt.xml";  
 string nestedCascadeName = "E:/software/opencv2.4.6.0/data/haarcascades/haarcascade_eye_tree_eyeglasses.xml";  
   
 int main( )  
 {  
     CvCapture* capture = 0;  
     Mat frame, frameCopy, image;  
     string inputName;  
     bool tryflip = false;  
     int mode;  
     CascadeClassifier cascade, nestedCascade;   
     double scale = 1.0;  
     if( !cascade.load( cascadeName ) ||!nestedCascade.load( nestedCascadeName))  
     {  
         cerr << "ERROR: Could not load classifier cascade or nestedCascade" << endl;//若出现该问题请去检查cascadeName，可能是opencv版本路径问题  
         return -1;  
     }  
   
 //  printf("select the mode of detection: \n1: from picture\t 2: from camera\n");  
 //  scanf("%d",&mode);  
     char** pics = (char**) malloc(sizeof*pics);  
   
     /************************************************************************/  
     /*                                  detect face and save                                    */  
     /************************************************************************/  
     int i,j;  
     cout<<"detect and save..."<<endl;  
     const char dir[256] = "D:\\Face_recognition\\pic\\";   
         string cur_dir;  
         char id[5];  
     for(i=1; i<=K; i++)  
     {  
         cur_dir = dir;  
         _itoa(i,id,10);  
         cur_dir.append("color\\");  
         cur_dir.append(id);  
         vector<pair<char*,Mat>> imgs=read_img(cur_dir);  
         for(j=0;j<imgs.size();j++)  
         {  
             IplImage* res = DetectandExtract(imgs[j].second,cascade,nestedCascade,scale,tryflip);  
             if(res)  
                 cvSaveImage(imgs[j].first,res);  
         }  
     }  
     return 0;  
 }  

正确的输出就是一系列人脸检测时间，且原文件夹内的图片变成了检测出的人脸（如上面结果图所示）。

文章所用代码打包链接：http://download.csdn.net/detail/abcjennifer/7047853

关于Computer Vision更多的学习资料将继续更新，敬请关注本博客和新浪微博Rachel Zhang。

荪荪

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
opencv 人脸识别（一）训练样本的处理

本文实现基于eigenface的人脸检测与识别。给定一个图像数据库，进行以下步骤：进行人脸检测，将检测出的人脸存入数据库2对数据库2进行人脸建模在测试集上进行recognition本篇实现第一步：进行人脸检测，将检测出的人脸存入数据库2环境：vs2010+opencv 2.4.6.0特征：eigenfaceInpu
复制链接

扫一扫