PCA、人脸识别

来源：互联网发布：java的冒泡排序算法编辑：程序博客网时间：2024/06/02 09:21

转：

PCA是主成分分析，主要用于数据降维，对于一系列sample的feature组成的多维向量，多维向量里的某些元素本身没有区分性，比如某个元素在所有的sample中都为1，或者与1差距不大，那么这个元素本身就没有区分性，用它做特征来区分，贡献会非常小。所以我们的目的是找那些变化大的元素，即方差大的那些维，而去除掉那些变化不大的维，从而使feature留下的都是“精品”，而且计算量也变小了。

对于一个k维的feature来说，相当于它的每一维feature与其他维都是正交的（相当于在多维坐标系中，坐标轴都是垂直的），那么我们可以变化这些维的坐标系，从而使这个feature在某些维上方差大，而在某些维上方差很小。例如，一个45度倾斜的椭圆，在第一坐标系，如果按照x,y坐标来投影，这些点的x和y的属性很难用于区分他们，因为他们在x,y轴上坐标变化的方差都差不多，我们无法根据这个点的某个x属性来判断这个点是哪个，而如果将坐标轴旋转，以椭圆长轴为x轴，则椭圆在长轴上的分布比较长，方差大，而在短轴上的分布短，方差小，所以可以考虑只保留这些点的长轴属性，来区分椭圆上的点，这样，区分性比x,y轴的方法要好！

所以我们的做法就是求得一个k维特征的投影矩阵，这个投影矩阵可以将feature从高维降到低维。投影矩阵也可以叫做变换矩阵。新的低维特征必须每个维都正交，特征向量都是正交的。通过求样本矩阵的协方差矩阵，然后求出协方差矩阵的特征向量，这些特征向量就可以构成这个投影矩阵了。特征向量的选择取决于协方差矩阵的特征值的大小。

举一个例子：

对于一个训练集，100个sample，特征是10维，那么它可以建立一个100*10的矩阵，作为样本。求这个样本的协方差矩阵，得到一个10*10的协方差矩阵，然后求出这个协方差矩阵的特征值和特征向量，应该有10个特征值和特征向量，我们根据特征值的大小，取前四个特征值所对应的特征向量，构成一个10*4的矩阵，这个矩阵就是我们要求的特征矩阵，100*10的样本矩阵乘以这个10*4的特征矩阵，就得到了一个100*4的新的降维之后的样本矩阵，每个sample的维数下降了。

当给定一个测试的特征集之后，比如1*10维的特征，乘以上面得到的10*4的特征矩阵，便可以得到一个1*4的特征，用这个特征去分类。

所以做PCA实际上是求得这个投影矩阵，用高维的特征乘以这个投影矩阵，便可以将高维特征的维数下降到指定的维数。

在opencv里面有专门的函数，可以得到这个这个投影矩阵（特征矩阵）。

[cpp] view plaincopy
void cvCalcPCA( const CvArr* data, CvArr* avg, CvArr* eigenvalues, CvArr* eigenvectors, int flags );  

在OPENCV中使用PCA非常简单，只要几条语句就可以了。
1、初始化数据
//每一行表示一个样本
CvMat* pData = cvCreateMat( 总的样本数, 每个样本的维数, CV_32FC1 );
CvMat* pMean = cvCreateMat(1, 样本的维数, CV_32FC1);
//pEigVals中的每个数表示一个特征值
CvMat* pEigVals = cvCreateMat(1, min(总的样本数,样本的维数), CV_32FC1);
//每一行表示一个特征向量
CvMat* pEigVecs = cvCreateMat( min(总的样本数,样本的维数), 样本的维数, CV_32FC1);
2、PCA处理,计算出平均向量pMean,特征值pEigVals和特征向量pEigVecs
cvCalcPCA( pData, pMean, pEigVals, pEigVecs, CV_PCA_DATA_AS_ROW );
3、选出前P个特征向量(主成份),然后投影,结果保存在pResult中，pResult中包含了P个系数
CvMat* pResult = cvCreateMat( 总的样本数, PCA变换后的样本维数(即主成份的数目), CV_32FC1 );
cvProjectPCA( pData, pMean, pEigVecs, pResult );
4、重构,结果保存在pRecon中
CvMat* pRecon = cvCreateMat( 总的样本数, 每个样本的维数, CV_32FC1 );
cvBackProjectPCA( pResult, pMean, pEigVecs, pRecon );
5、重构误差的计算
计算pRecon和pData的"差"就可以了.
使用时如果是想用PCA判断“是非”问题，则可以先用正样本计算主成分，判断时，对需要判断得数据进行投影，然后重构，计算重构出的数据与原数据的差异，如果差异在给定范围内，可以认为“是”。
如果相用PCA进行分类，例如对数字进行分类，则先用所有数据（0-9的所有样本）计算主成分，然后对每一类数据进行投影，计算投影的系数，可简单得求平均。即对每一类求出平均系数。分类时，将需要分类得数据进行投影，得到系数，与先前计算出得每一类得平均系数进行比较，可判为最接近得一类。当然这只是最简单得使用方法。

参考：
http://www.cnblogs.com/cvlabs/archive/2010/05/14/1735230.html

学习基于opencv的人脸检测，首先要理清大概需要做哪些事情。这里总共分两步，第一步就是训练分类器，第二步就是利用训练好的分类器进行人脸检测。
1、训练分类器
训练分类器我没有学习，因为opencv的源代码中（opencv安装目录\data\haarcascades）中已经有了很多训练好的分类器供我们使用。但是有必要对分类器的训练原理和过程做一些介绍，以便后面进一步的学习中能够对这部分有一定了解。
目前人脸检测分类器大都是基于haar特征利用Adaboost学习算法训练的。

目标检测方法最初由Paul Viola [Viola01]提出，并由Rainer Lienhart [Lienhart02]对这一方法进行了改善. 首先，利用样本（大约几百幅样本图片）的 harr 特征进行分类器训练，得到一个级联的boosted分类器。训练样本分为正例样本和反例样本，其中正例样本是指待检目标样本(例如人脸或汽车等)，反例样本指其它任意图片，所有的样本图片都被归一化为同样的尺寸大小(例如，20x20)。

分类器训练完以后，就可以应用于输入图像中的感兴趣区域(与训练样本相同的尺寸)的检测。检测到目标区域(汽车或人脸)分类器输出为1，否则输出为0。为了检测整副图像，可以在图像中移动搜索窗口，检测每一个位置来确定可能的目标。为了搜索不同大小的目标物体，分类器被设计为可以进行尺寸改变，这样比改变待检图像的尺寸大小更为有效。所以，为了在图像中检测未知大小的目标物体，扫描程序通常需要用不同比例大小的搜索窗口对图片进行几次扫描。

分类器中的“级联”是指最终的分类器是由几个简单分类器级联组成。在图像检测中，被检窗口依次通过每一级分类器，这样在前面几层的检测中大部分的候选区域就被排除了，全部通过每一级分类器检测的区域即为目标区域。目前支持这种分类器的boosting技术有四种： Discrete Adaboost, Real Adaboost, Gentle Adaboost and Logitboost。"boosted" 即指级联分类器的每一层都可以从中选取一个boosting算法(权重投票)，并利用基础分类器的自我训练得到。基础分类器是至少有两个叶结点的决策树分类器。 Haar特征是基础分类器的输入，主要描述如下。目前的算法主要利用下面的Harr特征。

Image:Haarfeatures.png

每个特定分类器所使用的特征用形状、感兴趣区域中的位置以及比例系数（这里的比例系数跟检测时候采用的比例系数是不一样的，尽管最后会取两个系数的乘积值）来定义。例如在第二行特征(2c)的情况下，响应计算为复盖全部特征整个矩形框(包括两个白色矩形框和一个黑色矩形框)象素的和减去黑色矩形框内象素和的三倍。每个矩形框内的象素和都可以通过积分图象很快的计算出来。

通过上述陈述，应该对整个训练过程有个大概的了解，但是对于训练的具体过程还是不太明晰，那么可以继续参考下面的文章：
http://apps.hi.baidu.com/share/detail/44451430
相信看过上面这篇文章以及前面的陈述后大家应该对分类器的训练原理有了一个整体的了解，至于一些细节如果还不清晰应该不影响使用，毕竟那些细节可能需要数字图像处理的专业知识。

2、利用分类器进行检测
前面也已经说过，opencv的源代码中已经给我们提供了一些训练好的分类器，例如人脸检测分类器，人体检测分类器等。那么如果没有什么特定的需要，我们完全可以利用这些分类器直接进行人脸及人体检测。

对于分类器的使用大致要经过三个阶段，从文件中加载分类器、利用分类器进行检测、检测完成后释放分类器。这三个阶段对应三个函数，cvLoadHaarClassifierCascade、cvHaarDetectObjects、cvReleaseHaarClassifierCascade。这三个函数包含在库文件opencv_objdetect231d.lib中，为了使用，需要在（以vs2008为例）项目-属性-配置属性-链接器-输入，附加依赖项中添加相应的库文件，即opencv_objdetect231d.lib。三个函数原型及参数意义如下：
a、CvHaarClassifierCascade* cvLoadHaarClassifierCascade(const char* directory,cvSize orig_window_size);
directory
训练好的分类器路径
orig_window_size
级联分类器训练中采用的检测目标的尺寸。这个信息在分类器中没有存储，因此要单独指出。
函数 cvLoadHaarClassifierCascade 用于从文件中装载训练好的利用哈尔特征的级联分类器，或者从OpenCV中嵌入的分类器数据库中导入。分类器的训练可以应用函数haartraining(详细察看opencv/apps/haartraining) 这个数值是在训练分类器时就确定好的，修改它并不能改变检测的范围或精度。
需要注意的是，这个函数已经过时了。现在的目标检测分类器通常存储在 XML 或 YAML 文件中,而不是通过路径导入。从文件中导入分类器，可以使用函数 cvLoad 。
b、CvSeq* cvHaarDetectObjects(const CvArr* image, CvHaarClassifierCascade* cascade,CvMemStorage* storage,double scale_factor=1.1,int min_neighbors=3,int flags=0,CvSize min_size=cvSize(0,0));

image: 被检图像
cascade: harr 分类器级联的内部标识形式
storage
用来存储检测到的一序列候选目标矩形框的内存区域。
scale_factor: 在前后两次相继的扫描中，搜索窗口的比例系数。例如1.1指将搜索窗口依次扩大10%。
min_neighbors: 构成检测目标的相邻矩形的最小个数(缺省－1)。如果组成检测目标的小矩形的个数和小于min_neighbors-1 都会被排除。如果min_neighbors 为 0, 则函数不做任何操作就返回所有的被检候选矩形框，这种设定值一般用在用户自定义对检测结果的组合程序上。
flags: 操作方式。当前唯一可以定义的操作方式是 CV_HAAR_DO_CANNY_PRUNING。如果被设定，函数利用Canny边缘检测器来排除一些边缘很少或者很多的图像区域，因为这样的区域一般不含被检目标。人脸检测中通过设定阈值使用了这种方法，并因此提高了检测速度。
min_size: 检测窗口的最小尺寸。缺省的情况下被设为分类器训练时采用的样本尺寸(人脸检测中缺省大小是~20×20)。

函数 cvHaarDetectObjects 使用针对某目标物体训练的级联分类器在图像中找到包含目标物体的矩形区域，并且将这些区域作为一序列的矩形框返回。函数以不同比例大小的扫描窗口对图像进行几次搜索(察看cvSetImagesForHaarClassifierCascade)。每次都要对图像中的这些重叠区域利用cvRunHaarClassifierCascade进行检测。有时候也会利用某些继承（heuristics）技术以减少分析的候选区域，例如利用 Canny 裁减（prunning）方法。函数在处理和收集到候选的方框(全部通过级联分类器各层的区域)之后，接着对这些区域进行组合并且返回一系列各个足够大的组合中的平均矩形。调节程序中的缺省参数(scale_factor=1.1, min_neighbors=3, flags=0)用于对目标进行更精确同时也是耗时较长的进一步检测。为了能对视频图像进行更快的实时检测，参数设置通常是：scale_factor=1.2, min_neighbors=2, flags=CV_HAAR_DO_CANNY_PRUNING, min_size=<minimum possible face size> (例如, 对于视频会议的图像区域)。
c、void cvReleaseHaarClassifierCascade(CvHaarClassifierCascade** cascade);
cascade
双指针类型指针指向要释放的cascade. 指针由函数声明。
函数 cvReleaseHaarClassifierCascade 释放cascade的动态内存，其中cascade的动态内存或者是手工创建，或者通过函数 cvLoadHaarClassifierCascade 或 cvLoad分配。
三个主要函数介绍完之后，就可以看程序了，毕竟通过程序学函数和用法是最快的（个人觉得）。

[cpp] view plaincopy
#include "cv.h"  
#include "highgui.h"  
#include <stdio.h>  
  
void displaydetection(IplImage* pInpImg,CvSeq* pFaceRectSeq,char* FileName);  
  
int main(int argc,char** argv)  
{  
    IplImage* pInpImg=0;  
    CvHaarClassifierCascade* pCascade=0;        //指向后面从文件中获取的分类器  
    CvMemStorage* pStorage=0;                   //存储检测到的人脸数据  
    CvSeq* pFaceRectSeq;                        //用来接收检测函数返回的一系列的包含人脸的矩形区域  
      
    if (argc<2)  
    {  
        printf("missing name of image file!\n");  
        return -1;  
    }  
  
    //初始化  
    pInpImg=cvLoadImage(argv[1],1);   
    pStorage=cvCreateMemStorage(0);             //创建默认大先64k的动态内存区域  
    pCascade=(CvHaarClassifierCascade*)cvLoad("haarcascade_frontalface_alt.xml");       //加载分类器  
  
    if (!pInpImg||!pStorage||!pCascade)  
    {  
        printf("initialization failed:%s\n",(!pInpImg)?"can't load image file":(!pCascade)?"can't load haar-cascade---make sure path is correct":"unable to allocate memory for data storage",argv[1]);  
        return -1;  
    }  
    //人脸检测  
    pFaceRectSeq=cvHaarDetectObjects(pInpImg,pCascade,pStorage,  
        1.2,2,CV_HAAR_DO_CANNY_PRUNING,cvSize(40,40));  
    //将检测到的人脸以矩形框标出。  
    displaydetection(pInpImg,pFaceRectSeq,argv[1]);  
  
    cvReleaseImage(&pInpImg);  
    cvReleaseHaarClassifierCascade(&pCascade);  
    cvReleaseMemStorage(&pStorage);  
    return 0;  
}  
  
void displaydetection(IplImage* pInpImg,CvSeq* pFaceRectSeq,char* FileName)  
{  
    int i;  
    cvNamedWindow("haar window",1);  
    printf("the number of face is %d",pFaceRectSeq->total);  
    for (i=0;i<(pFaceRectSeq?pFaceRectSeq->total:0);i++)  
    {  
        CvRect* r=(CvRect*)cvGetSeqElem(pFaceRectSeq,i);  
        CvPoint pt1={r->x,r->y};  
        CvPoint pt2={r->x+r->width,r->y+r->height};  
  
//      cvSetImageROI(pInpImg,*r);  
//      IplImage* dst=cvCreateImage(cvSize(92,112),pInpImg->depth,pInpImg->nChannels);  
//      cvResize(pInpImg,dst,CV_INTER_LINEAR);  
//      cvSaveImage("lian.jpg",dst);  
        cvRectangle(pInpImg,pt1,pt2,CV_RGB(0,255,0),3,4,0);  
    }  
    cvShowImage("haar window",pInpImg);  
//  cvResetImageROI(pInpImg);  
    cvWaitKey(0);  
    cvDestroyWindow("haar window");  
}  

通过上面的程序可以实现在一张图片中检测出人脸，并用矩形框标出。到此就完成了人脸检测。下一篇文章将对人脸识别进行介绍。
参考：
http://www.opencv.org.cn/index.php/Cv%E6%A8%A1%E5%BC%8F%E8%AF%86%E5%88%AB

人脸识别要牵涉到一些数学计算和一些算法的理解，虽然这些算法和计算opencv已经帮我们完成，但我们还是要对其有一定的了解，才能进行人脸识别的实践，毕竟基础不牢，上层建筑也不稳。
要理解如何进行人脸识别，首先一定要理解主成分分析算法，即PCA，使用这种算法的原因是因为，一般图像数据量太大，而且其中的大部分数据点对我们进行人脸识别没有太大的帮助，因此为了减少数据量，采用了主成分分析法将数据进行压缩（算法中称为投影），然后用压缩后的图像进行图像识别的进一步应用。PCA的原理在前面的一篇文章中已经讲到过，大家可以参考：PCA原理。肯能看完这个文章，大家开始对PCA有一定的理解，但总还是感觉有点模糊，因为那篇文章我只是转载，并没有进行太多自己的想法的标注，因此有些混乱，那么大家可以再继续读下面这篇文章：
PCA原理详解。
在前面的PCA原理介绍中曾提到了两个函数，cvCalcPCA，cvProjectPCA。我在实际使用中参考了另外一篇文章，用的是另外两个函数，这个后面会讲到。这个不用太纠结，前面的文章可以只当学习原理的参考，等原理懂了之后看后面将要介绍的两个函数也会很简单。其中，有一点要说明，cvCalcPCA是新的PCA处理函数，而后面将要讲到的cvCalcEigenObjects是老的PCA处理函数。
经过上面的的两片文章相信大家应该对PCA的原理有所了解，下面开始讲怎样实现用PCA算法进行人脸识别。这个可以参考这篇文章：
http://www.cognotics.com/opencv/servo_2007_series/part_5/index.html
这篇是英文文章，希望大家多读英文文章，因为我们在学习过程中如果遇到国内教材较少的情况，一般都是要参考国外的文章的，并且擅长阅读英文文章也为我们打开了通往另外一个更为博大的知识库的大门。读完这篇文章一定可以自己做出人脸识别程序的，因为这篇文章介绍的已经十分详细。
但是，在这里我还是将上面那篇文章的原理介绍一下。我下面的叙述主要是针对在一个图像库中找出我们给定的图像最接近的图像，以人脸图像为例也就是说数据库中肯定是包含我所给出的这个人的人脸，虽然数据库中的图片跟我给出的图片不是同一张图片，但必须是同一个人。
首先假如我有代号为1,2,3三个训练人的人脸图像，人脸大小调整为一致，例如文章中为92*112，在我们的分析中是以一个像素点作为一维，因此每个图像可以认为是一个1*10304的行向量，这样三个训练人的人脸图像就组成了一个3*10304的矩阵。（注意，实际中每个图像还是存在92*112的iplimage结构中，这里只是为了讲解方便而进行的假象）。根据这个矩阵，就可以计算出相应的协方差矩阵，大小为10304*10304（这个大小我并没有考究，我觉得应该是这个大小，因为可以解释通上面那篇英文文章），接着再求出这个10304*10304的矩阵的特征值和特征向量，并取前nEigens个（这个个数由我们自己确定，文章中是取nEigens为训练人个数-1）特征值（注意由于前面特征值已经是由大到小排好顺序的，因此这几个就是最大的几个）对应的特征向量组成10304*nEigens大小投影矩阵（注意这里发生了转置，有opencv函数内部完成），即所谓的特征脸（因为每一列的规模就是一张人脸图像的规模），也即子空间。然后再将每个大小为1*10304的训练人脸图像矩阵乘以这个投影矩阵，就可以得到每个图像在主成分子空间的投影，大小为1*nEigens，并用这个投影矩阵进行后续的分析。可见，经过投影后图像数据量大大减小。上面的计算投影矩阵的过程由cvCalcEigenObjects完成，而投影则由cvEigenDecomposite函数完成，具体实现见英文文章。为了方便理解这两个函数可以参见：PCA的两个主要函数，这个空间内有两篇介绍这两个函数的文章。
同样，当给出测试图像时，先将测试人脸缩放为与训练人脸相同的大小，即92*112，然后用前面的特征矩阵将其投影到子空间中，即投影为大小为1*nEigens的矩阵。接着就可以用这个子空间投影跟前面的训练图像在子空间的投影进行比较，最接近的就是目标图像。比较方法文章中也有提到，有欧式算法 Euclidean 和较新的 Mahalanobis算法。
至此，整个人脸识别原理已经讲完，虽然有点复杂，但花点时间也不难理解。
下面贴出文章中给出的程序，我进行了一些注释，使用方法程序头部也有介绍。
[cpp] view plaincopy
// eigenface.c, by Robin Hewitt, 2007  
//  
// Example program showing how to implement eigenface with OpenCV  
  
// Usage:  
//  
// First, you need some face images. I used the ORL face database.  
// You can download it for free at  
//    www.cl.cam.ac.uk/research/dtg/attarchive/facedatabase.html  
//  
// List the training and test face images you want to use in the  
// input files train.txt and test.txt. (Example input files are provided  
// in the download.) To use these input files exactly as provided, unzip  
// the ORL face database, and place train.txt, test.txt, and eigenface.exe  
// at the root of the unzipped database.  
//  
// To run the learning phase of eigenface, enter  
//    eigenface train  
// at the command prompt. To run the recognition phase, enter  
//    eigenface test  
  
#include <stdio.h>  
#include <string.h>  
#include "cv.h"  
#include "cvaux.h"  
#include "highgui.h"  
  
  
////定义几个重要的全局变量  
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; // 训练图像的投影  
  
  
//// 函数原型  
void learn();  
void recognize();  
void doPCA();  
void storeTrainingData();  
int  loadTrainingData(CvMat ** pTrainPersonNumMat);  
int  findNearestNeighbor(float * projectedTestFace);  
int  loadFaceImgArray(char * filename);  
void printUsage();  
  
  
  
//主函数，主要包括学习和识别两个阶段，需要运行两次，通过命令行传入的参数区分  
void main( int argc, char** argv )  
{  
    // validate that an input was specified  
    if( argc != 2 )  
    {  
        printUsage();  
        return;  
    }  
    //通过判断命令行参数分别执行学习和识别代码  
    if( !strcmp(argv[1], "train") ) learn();  
    else if( !strcmp(argv[1], "test") ) recognize();  
    else  
    {  
        printf("Unknown command: %s\n", argv[1]);  
        printUsage();  
    }  
}  
  
  
//学习阶段代码  
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<nTrainFaces; 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();  
}  
  
  
//识别阶段代码  
void recognize()  
{  
    int i, nTestFaces  = 0;         // 测试人脸数  
    CvMat * trainPersonNumMat = 0;  // 训练阶段的人脸数  
    float * projectedTestFace = 0;  
  
    // 加载测试图像，并返回测试人脸数  
    nTestFaces = loadFaceImgArray("test.txt");  
    printf("%d test faces loaded\n", nTestFaces);  
  
    // 加载保存在.xml文件中的训练结果  
    if( !loadTrainingData( &trainPersonNumMat ) ) return;  
  
    //   
    projectedTestFace = (float *)cvAlloc( nEigens*sizeof(float) );  
    for(i=0; i<nTestFaces; i++)  
    {  
        int iNearest, nearest, truth;  
  
        //将测试图像投影到子空间中  
        cvEigenDecomposite(  
            faceImgArr[i],  
            nEigens,  
            eigenVectArr,  
            0, 0,  
            pAvgTrainImg,  
            projectedTestFace);  
  
        iNearest = findNearestNeighbor(projectedTestFace);  
        truth    = personNumTruthMat->data.i[i];  
        nearest  = trainPersonNumMat->data.i[iNearest];  
  
        printf("nearest = %d, Truth = %d\n", nearest, truth);  
    }  
}  
  
  
//加载保存过的训练结果  
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<nEigens; 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<nEigens; 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<nTrainFaces; iTrain++)  
    {  
        double distSq=0;  
  
        for(i=0; i<nEigens; 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;  
        }  
    }  
  
    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<nEigens; 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);  
  
    // 计算平均图像，特征值，特征向量  
    cvCalcEigenObjects(  
        nTrainFaces,  
        (void*)faceImgArr,  
        (void*)eigenVectArr,  
        CV_EIGOBJ_NO_CALLBACK,  
        0,  
        0,  
        &calcLimit,  
        pAvgTrainImg,  
        eigenValMat->data.fl);  
  
    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;  
    rewind(imgListFile);  
  
    // 分配人脸图像存储空间和人脸ID号存储空间  
    faceImgArr        = (IplImage **)cvAlloc( nFaces*sizeof(IplImage *) );  
    personNumTruthMat = cvCreateMat( 1, nFaces, CV_32SC1 );  
  
    for(iFace=0; iFace<nFaces; iFace++)  
    {  
        // 从文件中读取序号和人脸名称  
        fscanf(imgListFile,  
            "%d %s", personNumTruthMat->data.i+iFace, imgFilename);  
  
        // 加载人脸图像  
        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 <command>\n",  
        "  Valid commands are\n"  
        "    train\n"  
        "    test\n");  
}  
由于两个主要的函数cvCalcEigenObjects，cvEigenDecomposite的原型说明包含在cvaux.h，因此不要忘记添加该头文件。
通过上面的介绍，大家应该对人脸识别的方法有所了解，并针对自己的问题编写人脸识别程序了