OpenCV人脸识别的原理 完整版代码

http://blog.csdn.net/yanming901012/article/details/8606183

 本程序首先利用从摄像头检测到的人脸图片，先进行直方图均衡化
 并缩放到92*112的图片大小，然后根据train.txt的采集到的人脸模版
 进行匹配识别（最好是在统一光照下，采集不同角度的人脸图片各一张）
 注意：影响的极大因素在于光照，模版若与采集的图像光照不一样，识别率很低。
 经测试，模板若与检测的图像在同一光照下的话，侧脸，仰脸，正脸均可识别，且识别率较高

 //
 #include
 #include
 #include "cv.h"
 #include "cvaux.h"
 #include "highgui.h"
 #include
 #include
 #include
 #include
 #include
 #include
 #include

 ////定义几个重要的全局变量
 IplImage ** faceImgArr        = 0; // 指向训练人脸和测试人脸的指针（在学习和识别阶段指向不同）
 CvMat    *  personNumTruthMat = 0; // 人脸图像的ID号
 int nTrainFaces               = 0; // 训练图像的数目
 int nEigens                   = 0; // 自己取的主要特征值数目
 IplImage * pAvgTrainImg       = 0; // 训练人脸数据的平均值
 IplImage ** eigenVectArr      = 0; // 投影矩阵，也即主特征向量
 CvMat * eigenValMat           = 0; // 特征值
 CvMat * projectedTrainFaceMat = 0; // 训练图像的投影
 char *filename[5]={"face1.jpg","face2.jpg","face3.jpg","face4.jpg","face5.jpg"};

 static CvMemStorage* storage = 0;
 static CvHaarClassifierCascade* cascade = 0;
 int j=0;//统计记录的人脸数
 char a[512]={0};
 int a1,a2,a3,a4;
 time_t timeBegin, timeEnd;
   int timeuse;
 //// 函数原型
 void learn();
 void doPCA();
 void storeTrainingData();
 int  loadTrainingData(CvMat ** pTrainPersonNumMat);
 int  findNearestNeighbor(float * projectedTestFace);
 int  loadFaceImgArray(char * filename);
 void printUsage();
 int detect_and_draw( IplImage* image );
 int recognize(IplImage *faceimg);

 //主函数，主要包括学习和识别两个阶段，需要运行两次，通过命令行传入的参数区分
 int main( int argc, char** argv )
 {
     CvCapture* capture = 0;
     IplImage *frame, *frame_copy = 0;
     int optlen = strlen("--cascade=");
     char *cascade_name = "H://opencv-2.4.3//opencv//data//haarcascades//haarcascade_frontalface_alt2.xml";
         //opencv装好后haarcascade_frontalface_alt2.xml的路径,
        //也可以把这个文件拷到你的工程文件夹下然后不用写路径名cascade_name= "haarcascade_frontalface_alt2.xml";
        //或者cascade_name ="C:\\Program Files\\OpenCV\\data\\haarcascades\\haarcascade_frontalface_alt2.xml"
     cascade = (CvHaarClassifierCascade*)cvLoad( cascade_name, 0, 0, 0 );

     if( !cascade )
     {
         fprintf( stderr, "ERROR: Could not load classifier cascade\n" );
         fprintf( stderr,
         "Usage: facedetect --cascade=\"\" [filename|camera_index]\n" );
         return -1;
     }
     storage = cvCreateMemStorage(0);
      capture = cvCreateCameraCapture(-1);
     cvNamedWindow( "result", 1 );

     if( capture )
     {     timeBegin = time(NULL);
           learn();
         for(;;)
         {   timeEnd = time(NULL);
     timeuse=timeEnd - timeBegin;//计算经过的时间,统计人数
             if( !cvGrabFrame( capture ))
                 break;
             frame = cvRetrieveFrame( capture );
             if( !frame )
                 break;
             if( !frame_copy )
                 frame_copy = cvCreateImage( cvSize(frame->width,frame->height),
                                             IPL_DEPTH_8U, frame->nChannels );
             if( frame->origin == IPL_ORIGIN_TL )//如果图像的起点在左上角
                 cvCopy( frame, frame_copy, 0 );
             else
                 cvFlip( frame, frame_copy, 0 );//如果图像的起点不在左上角，而在左下角时，进行X轴对称

             detect_and_draw( frame_copy );  //检测并且识别

             if( cvWaitKey( 10 ) >= 0 )
                 break;
         }

         cvReleaseImage( &frame_copy );
         cvReleaseCapture( &capture );
     }
     else
     {
         printf("Cannot read from CAM");
         return -1;
     }

     cvDestroyWindow("result");

     return 0;
 }

 //学习阶段代码
 void learn()
 {
     int i, offset;

     //加载训练图像集
     nTrainFaces = loadFaceImgArray("train.txt");
     if( nTrainFaces < 2 )
     {
         fprintf(stderr,
             "Need 2 or more training faces\n"
             "Input file contains only %d\n", nTrainFaces);

         return;
     }

     // 进行主成分分析
     doPCA();

     //将训练图集投影到子空间中
     projectedTrainFaceMat = cvCreateMat( nTrainFaces, nEigens, CV_32FC1 );
     offset = projectedTrainFaceMat->step / sizeof(float);
     for(i=0; i
     {
         //int offset = i * nEigens;
         cvEigenDecomposite(
             faceImgArr[i],
             nEigens,
             eigenVectArr,
             0, 0,
             pAvgTrainImg,
             //projectedTrainFaceMat->data.fl + i*nEigens);
             projectedTrainFaceMat->data.fl + i*offset);
     }

     //将训练阶段得到的特征值，投影矩阵等数据存为.xml文件，以备测试时使用
     storeTrainingData();
 }


 //加载保存过的训练结果
 int loadTrainingData(CvMat ** pTrainPersonNumMat)
 {
     CvFileStorage * fileStorage;
     int i;


     fileStorage = cvOpenFileStorage( "facedata.xml", 0, CV_STORAGE_READ );
     if( !fileStorage )
     {
         fprintf(stderr, "Can't open facedata.xml\n");
         return 0;
     }

     nEigens = cvReadIntByName(fileStorage, 0, "nEigens", 0);
     nTrainFaces = cvReadIntByName(fileStorage, 0, "nTrainFaces", 0);
     *pTrainPersonNumMat = (CvMat *)cvReadByName(fileStorage, 0, "trainPersonNumMat", 0);
     eigenValMat  = (CvMat *)cvReadByName(fileStorage, 0, "eigenValMat", 0);
     projectedTrainFaceMat = (CvMat *)cvReadByName(fileStorage, 0, "projectedTrainFaceMat", 0);
     pAvgTrainImg = (IplImage *)cvReadByName(fileStorage, 0, "avgTrainImg", 0);
     eigenVectArr = (IplImage **)cvAlloc(nTrainFaces*sizeof(IplImage *));
     for(i=0; i
     {
         char varname[200];
         sprintf( varname, "eigenVect_%d", i );
         eigenVectArr[i] = (IplImage *)cvReadByName(fileStorage, 0, varname, 0);
     }


     cvReleaseFileStorage( &fileStorage );

     return 1;
 }

 //存储训练结果
 void storeTrainingData()
 {
     CvFileStorage * fileStorage;
     int i;
     fileStorage = cvOpenFileStorage( "facedata.xml", 0, CV_STORAGE_WRITE );

     //存储特征值，投影矩阵，平均矩阵等训练结果
     cvWriteInt( fileStorage, "nEigens", nEigens );
     cvWriteInt( fileStorage, "nTrainFaces", nTrainFaces );
     cvWrite(fileStorage, "trainPersonNumMat", personNumTruthMat, cvAttrList(0,0));
     cvWrite(fileStorage, "eigenValMat", eigenValMat, cvAttrList(0,0));
     cvWrite(fileStorage, "projectedTrainFaceMat", projectedTrainFaceMat, cvAttrList(0,0));
     cvWrite(fileStorage, "avgTrainImg", pAvgTrainImg, cvAttrList(0,0));
     for(i=0; i
     {
         char varname[200];
         sprintf( varname, "eigenVect_%d", i );
         cvWrite(fileStorage, varname, eigenVectArr[i], cvAttrList(0,0));
     }
     cvReleaseFileStorage( &fileStorage );
 }

 //寻找最接近的图像
 int findNearestNeighbor(float * projectedTestFace)
 {

     double leastDistSq = DBL_MAX;       //定义最小距离，并初始化为无穷大
     int i, iTrain, iNearest = 0;

     for(iTrain=0; iTrain
     {
         double distSq=0;

         for(i=0; i
         {
             float d_i =
                 projectedTestFace[i] -
                 projectedTrainFaceMat->data.fl[iTrain*nEigens + i];
         distSq += d_i*d_i / eigenValMat->data.fl[i];  // Mahalanobis算法计算的距离，差的距离的平方除以平均脸的特征值
         //  distSq += d_i*d_i; // Euclidean算法计算的距离
         }

         if(distSq < leastDistSq)
         {
             leastDistSq = distSq;
             iNearest = iTrain;
         }
     }
     //printf("leastdistsq==%f",leastDistSq);
     return iNearest;
 }



 //主成分分析
 void doPCA()
 {
     int i;
     CvTermCriteria calcLimit;
     CvSize faceImgSize;

     // 自己设置主特征值个数
     nEigens = nTrainFaces-1;

     //分配特征向量存储空间
     faceImgSize.width  = faceImgArr[0]->width;
     faceImgSize.height = faceImgArr[0]->height;
     eigenVectArr = (IplImage**)cvAlloc(sizeof(IplImage*) * nEigens);    //分配个数为住特征值个数
     for(i=0; i
         eigenVectArr[i] = cvCreateImage(faceImgSize, IPL_DEPTH_32F, 1);

     //分配主特征值存储空间
     eigenValMat = cvCreateMat( 1, nEigens, CV_32FC1 );

     // 分配平均图像存储空间
     pAvgTrainImg = cvCreateImage(faceImgSize, IPL_DEPTH_32F, 1);

     // 设定PCA分析结束条件
     calcLimit = cvTermCriteria( CV_TERMCRIT_ITER, nEigens, 1);//最大迭代次数为nEigens

     // 计算平均图像，特征值，特征向量
     cvCalcEigenObjects(
         nTrainFaces,
         (void*)faceImgArr,
         (void*)eigenVectArr,
         CV_EIGOBJ_NO_CALLBACK,
         0,
         0,
         &calcLimit,
         pAvgTrainImg,
         eigenValMat->data.fl//存储求得的eigenvalue
         );

     cvNormalize(eigenValMat, eigenValMat, 1, 0, CV_L1, 0);
 }



 //加载txt文件的列举的图像
 int loadFaceImgArray(char * filename)
 {
     FILE * imgListFile = 0;
     char imgFilename[512];
     int iFace, nFaces=0;


     if( !(imgListFile = fopen(filename, "r")) )
     {
         fprintf(stderr, "Can\'t open file %s\n", filename);
         return 0;
     }

     // 统计人脸数
     while( fgets(imgFilename, 512, imgListFile) ) ++nFaces;//char *fgets(char *buf, int bufsize, FILE *stream);从文件结构体指针stream中读取数据，每次读取一行。读取的数据保存在buf指向的字符数组中，每次最多读取bufsize-1个字符（第bufsize个字符赋'\0'），如果文件中的该行，不足bufsize个字符，则读完该行就结束。如果函数读取成功，则返回指针buf，失败则返回NULL。
     rewind(imgListFile);//将文件内部的位置指针重新指向一个流（数据流/文件）的开头

     // 分配人脸图像存储空间和人脸ID号存储空间
     faceImgArr        = (IplImage **)cvAlloc( nFaces*sizeof(IplImage *) );
     personNumTruthMat = cvCreateMat( 1, nFaces, CV_32SC1 );//CvMat* cvCreateMat( int rows, int cols, int type );

     for(iFace=0; iFace
     {
         // 从文件中读取序号和人脸名称
         fscanf(imgListFile,
             "%d %s", personNumTruthMat->data.i+iFace, imgFilename);// fscanf(FILE *stream, char *format,[argument...])功 能: 从一个流中执行格式化输入,fscanf遇到空格和换行时结束

         // 加载人脸图像
         faceImgArr[iFace] = cvLoadImage(imgFilename, CV_LOAD_IMAGE_GRAYSCALE);

         if( !faceImgArr[iFace] )
         {
             fprintf(stderr, "Can\'t load image from %s\n", imgFilename);
             return 0;
         }
     }

     fclose(imgListFile);

     return nFaces;
 }



 //
 void printUsage()
 {
     printf("Usage: eigenface \n",
         "  Valid commands are\n"
         "    train\n"
         "    test\n");
 }

 int detect_and_draw( IplImage* img )
 {
  CvFont font;
  cvInitFont( &font, CV_FONT_VECTOR0,1, 1, 0, 1, 8);
     static CvScalar colors[] =
     {
         {{0,0,255}},
         {{0,128,255}},
         {{0,255,255}},
         {{0,255,0}},
         {{255,128,0}},
         {{255,255,0}},
         {{255,0,0}},
         {{255,0,255}}
     };

     double scale = 1.3;
     IplImage* gray = cvCreateImage( cvSize(img->width,img->height), 8, 1 );
     IplImage* small_img = cvCreateImage( cvSize( cvRound (img->width/scale),
                          cvRound (img->height/scale)),
                      8, 1 );
     int i,personnum=0;

     cvCvtColor( img, gray, CV_BGR2GRAY );
     cvResize( gray, small_img, CV_INTER_LINEAR );
     cvEqualizeHist( small_img, small_img );
     cvClearMemStorage( storage );

     if( cascade )
     {
         double t = (double)cvGetTickCount();
         CvSeq* faces = cvHaarDetectObjects( small_img, cascade, storage,
                                             1.1, 2, 0/*CV_HAAR_DO_CANNY_PRUNING*/,
                                             cvSize(30, 30) );
         t = (double)cvGetTickCount() - t;
       //  printf( "detection time = %gms\n", t/((double)cvGetTickFrequency()*1000.) );
          IplImage* temp_img=cvCreateImage(cvSize(92,112),8,1);
         for( i = 0; i < (faces ? faces->total : 0); i++ )
         {
             CvRect* r = (CvRect*)cvGetSeqElem( faces, i );

             IplImage *dst=cvCreateImage(cvSize(r->width,r->height),8,1);//cvsize只能选取r->width,r->height不能再后面*scale或+100
           CvPoint p1;
           p1.x=cvRound((r->x)*scale);
           p1.y=cvRound((r->y)*scale);
           CvPoint p2;
           p2.x=cvRound((r->x+r->width)*scale);
           p2.y=cvRound((r->y+r->height)*scale);
             cvRectangle(img,p1,p2,colors[i%8],3,8,0);
             cvSetImageROI(small_img,*r);
             cvCopy(small_img,dst);
             cvResize(dst,temp_img);
         cvEqualizeHist( temp_img, temp_img );
              cvResetImageROI(small_img);
             cvSaveImage(filename[i],temp_img);
               cvReleaseImage(&dst);
               //开始识别temp_img

               personnum=recognize(temp_img);
               if(personnum==1)
                cvPutText(img, "Yanming" , cvPoint(20, 20), &font, CV_RGB(255,255,255));//将正确识别的人的姓名显示在屏幕上

         }
     }

     cvShowImage( "result", img );
     cvReleaseImage( &gray );
     cvReleaseImage( &small_img );
  return -1;
 }

 int recognize(IplImage *faceimg)
 {
     int i, nTestFaces  = 0;         // 测试人脸数
     CvMat * trainPersonNumMat = 0;  // 训练阶段的人脸数
     float * projectedTestFace = 0;
     // 加载保存在.xml文件中的训练结果
     if( !loadTrainingData( &trainPersonNumMat ) ) return -3;

     projectedTestFace = (float *)cvAlloc( nEigens*sizeof(float) );

     int iNearest, nearest;

         //将测试图像投影到子空间中
         cvEigenDecomposite(
             faceimg,
             nEigens,
             eigenVectArr,
             0, 0,
             pAvgTrainImg,
             projectedTestFace);
         //cvNormalize(projectedTestFace, projectedTestFace, 1, 0, CV_L1, 0);
         iNearest = findNearestNeighbor(projectedTestFace);
         nearest  = trainPersonNumMat->data.i[iNearest];
         printf("nearest = %d", nearest);
         if(timeuse<=10)
         {

         if((nearest==1)|(nearest==11)|(nearest==111))//可以更改train.txt中训练图片的编号,这里将侧脸，仰脸，正脸都归为一起
             a1++;
         if(nearest==2)
             a2++;
         if(nearest==3)
             a3++;
         if(nearest==4)
             a4++;


         if(a1>7)//如果10s中识别的次数为6则认定为a1
         {
         printf("yanming\n");
         return 1;
         }
         if(a2>6)
         {printf("others\n");}
         if(a3>6)
         {printf("ma\n");}
         if(a4>6)
         {printf("ba\n");}
         }
         else
             {
                 timeBegin=time(NULL);
                 a1=0;
                 a2=0;
                 a3=0;
                 a4=0;
                 return 0;
             }
     return -1;
 }