基于Opencv的人脸检测及识别

一、实验目的：我这里完成的是，将8张人脸图片(4组，每组两张）存入库中，选取1张图片，程序识别出与其匹配的另一张。

这里介绍分三个步骤完成该工作，①程序读取摄像头、拍照

　　　　　　　　　　　　　　 ②程序从电脑文档中读取图片

　　　　　　　　　　　　　　   ③检测人脸，并用红框框出人脸

④使用感知哈希算法匹配最相似的图片

二、实验环境： Win 7(x64)、visual studio 2010、openCV-2.4.3

使用语言:C++

三、实验准备：①安装好vs2010,本文不予介绍。

　　　　　  ②配置opencv :

　　1'进入官网下载http://opencv.org/  (OpenCv 2.4x是支持Vs2010的，建议根据自己的Vs版本安装相应的OpenCv的版本)解压后，目录如下：

　　2'打开vs2010,创建项目，这里以我的工程名test为例。右击项目->属性->vc++目录->包含目录， 添加三个路径：（在解压后opencv下的build目录）

E:\新建文件夹\opencv\build\include

E:\新建文件夹\opencv\build\include\opencv

E:\新建文件夹\opencv\build\include\opencv2

然后点击库目录，添加路径：E:\新建文件夹\opencv\build\x86\vc10\lib

aaarticlea/png;base64,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" alt="" />

配置好了后，第二步，点击链接器->输入->附加依赖项,编辑添加，把E:\新建文件夹\opencv\build\x86\vc10\bin里面左右的文件名称全导入进去,导入带d的文件，比如有opencv_calib3d243.dll与opencv_calib3d243d.dll文件，只需添加后者带d的即可。

至此，openCV配置已经全部完成。接下来编写代码。

四、编写代码

①为了收集图片库，我编写了直接拍照的功能，按下p进行拍照，并自动命名排序存到文件中。

#include <iostream>
#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
using namespace cv;
int main( int argc, char** argv )
{

    int i=;//照片名从1开始命名
    while()
    {
    CvCapture *pCapture=cvCreateCameraCapture(-);//打开摄像头
    Mat image=cvQueryFrame(pCapture); //将摄像头拍的以图片形式展现
    cvNamedWindow("frame",);  //命名一个窗口
    imshow("frame",image);       //在窗口显示图片
    string filename=format("C:\\images\\%d.jpg",i);
    char key=waitKey();
    switch(key)
    {
    case'p':
        i++;                                    //键盘上每按一次p，就拍一张照
        imwrite(filename,image);              //写入图片
        imshow("photo",image);               //展示照片
        waitKey();
        destroyWindow("photo");
        break;
        default:break;
        }
        }
}

实验效果：

②读取图片，显示在屏幕上

    Mat image=imread("C:\\images\\2.jpg",-);    //使用Mat创建一个对象，-1为打开类型的参数
    cvNamedWindow("图像显示",);                        //命名一个窗口 ，1为显示参数
    imshow("图像显示",image);
    cvWaitKey();  //很重要，不写读不出来

③将读取的图片进行检测出人脸。

首先找到opencv目录下，识别人脸的类的文件(包装在data路径下)

Haarcascades_frontalface_default 包装的是 检测人脸，将这个文件拷贝到你的vs工程下。

#include <iostream>
#include <string>
#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/gpu/gpu.hpp>
using namespace cv;
using namespace std;
string xmlPath="C:\\Users\\yu\\Documents\\Visual Studio 2010\\Projects\\加我南\\haarcascade_frontalface_default.xml";
//xmlpath 字符串记录那个.xml文件的路径
void detectAndDisplay(Mat image);
int main( int argc,char**argv )
{
    string path="C:\\Users\\yu\\Documents\\Visual Studio 2010\\Projects\\test\\images\\1.jpg";//以检测图片1.jpg为例
    Mat image =imread(path,-);

    CascadeClassifier a;     //创建脸部对象
    if(!a.load(xmlPath))     //如果读取文件不出错，则检测人脸
    {
        cout<<"无法加载xml文件"<<endl;
        return ;
    }
   detectAndDisplay(image);// 检测人脸
   return ;

}

void detectAndDisplay(Mat image)
{
    CascadeClassifier ccf;      //创建脸部对象
    ccf.load(xmlPath);           //导入opencv自带检测的文件
    vector<Rect> faces;
    Mat gray;
    cvtColor(image,gray,CV_BGR2GRAY);
    equalizeHist(gray,gray);
    ccf.detectMultiScale(gray,faces,1.1,,,Size(,),Size(,));
    for(vector<Rect>::const_iterator iter=faces.begin();iter!=faces.end();iter++)
    {
        rectangle(image,*iter,Scalar(,,),,); //画出脸部矩形
    }
    Mat image1;

    for(size_t i=;i<faces.size();i++)
    {
        Point center(faces[i].x + faces[i].width / , faces[i].y + faces[i].height / );
        image1= image(Rect(faces[i].x, faces[i].y, faces[i].width, faces[i].height));
    }

    imshow("",image);
    imshow("",image1);
    cvWaitKey();

}

实验结果如下：

④进行人脸检测

opencv的FaceRecogizer目前有三个类实现了它，特征脸和fisherface方法最少训练图像为两张，而LBP可以单张图像训练，LBP方法原理：

引用：http://blog.****.net/lsq2902101015/article/details/49717441

因此，我想到了与LBP算法类似的感知哈希算法。

说下原理过程：

（1）缩小尺寸：去除高频和细节的最快方法是缩小图片，将图片缩小到8x8的尺寸，共64个像素。不用保持纵横比，只需将其变成8x8的正方形，这样就可以摒弃不同尺寸、比例带来的图片差异
      （2）简化色彩：将8x8的小图片转换成灰度图像。
      （3）计算平均值：计算所有64个像素的灰度平均值
      （4）比较像素的灰度：将每个像素的灰度，与平均值进行比较，大于或等于就记为1，小于均值，就记为0；
       （5）计算hash值，将上面的比价比较结果组合在一起，构成了64位的哈希值，就是这张图片的指纹。
       （6）通过比较两张图片的哈希值，计算差值得到汉明距离。汉明距离越小，说明两张图片越相似。
　　引用：http://blog.****.net/zouxy09/article/details/17471401

#include <iostream>
#include <string>
#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/gpu/gpu.hpp>
using namespace cv;
string xmlPath="C:\\Users\\yu\\Documents\\Visual Studio 2010\\Projects\\加我南\\haarcascade_frontalface_default.xml";

string HashValue(Mat &src)      //得到图片的哈希值
//很久之前写的，现在想不起来了...注释就先不写了.....抱歉哈。但是是可以运行的
{
    string rst(,'\0');
    Mat img;
    if(src.channels()==)
        cvtColor(src,img,CV_BGR2GRAY);
    else
        img=src.clone();
    resize(img,img,Size(,));
    uchar *pData;
    for(int i=;i<img.rows;i++)
    {
        pData=img.ptr<uchar>(i);
        for(int j=;j<img.cols;j++)
        {
            pData[j]=pData[j]/;
        }
    }

    int average=mean(img).val[];
    Mat mask=(img>=(uchar)average);
    int index=;
    for(int i=;i<mask.rows;i++)
    {
        pData = mask.ptr<uchar>(i);
        for(int j=;j<mask.cols;j++)
        {
            if(pData[j]==)
                rst[index++]='';
            else
                rst[index++]='';
        }
    }
    return rst;
}
int HanmingDistance(string &str1,string &str2)       //求两张图片的汉明距离
{
    if((str1.size()!=)||(str2.size()!=))
        return -;
    int diff=;
    for(int i=;i<;i++)
    {
        if(str1[i]!=str2[i])
            diff++;
    }
    return diff;
}
void detectAndDisplay(Mat image)
{
    CascadeClassifier ccf;
    ccf.load(xmlPath);
    vector<Rect> faces;
    Mat gray;
    cvtColor(image,gray,CV_BGR2GRAY);
    equalizeHist(gray,gray);
    ccf.detectMultiScale(gray,faces,1.1,,,Size(,),Size(,));
    for(vector<Rect>::const_iterator iter=faces.begin();iter!=faces.end();iter++)
    {
        rectangle(image,*iter,Scalar(,,),,); //画出脸部矩形
    }
    for(size_t i=;i<faces.size();i++)
    {
        Point center(faces[i].x + faces[i].width / , faces[i].y + faces[i].height / );
        image= image(Rect(faces[i].x, faces[i].y, faces[i].width, faces[i].height));
    }
}             //识别并截取人脸
int main( int argc, char** argv )
{
    using std::cout;
    using std::endl;
    using std::cin;
    cout<<"请输入想要选择的图片"<<endl;
    int a,x,i;
    int diff[];
    cin>>a;
    const string path1=format("C:\\Users\\yu\\Documents\\Visual Studio 2010\\Projects\\test\\images\\%d.jpg",a);
    Mat image1,image2;
    image1=imread(path1,-);
    string str1,str2,path2;
    cvNamedWindow("选择的图片",);
    /*cvResizeWindow("选择的图片",700,500);*/
    imshow("选择的图片",image1);
    detectAndDisplay(image1);
    str1=HashValue(image1);
    cvWaitKey();
    for(i=;i<=;i++)//因为我完成的就是8张图片的检测，所以循环值为8
    {
        path2=format("C:\\Users\\yu\\Documents\\Visual Studio 2010\\Projects\\test\\images\\%d.jpg",i);
        image2=imread(path2,-);
        detectAndDisplay(image2);
        str2=HashValue(image2);
        diff[i]=HanmingDistance(str1,str2);
    }

    int min=,t;
    for(i=;i<=;i++)    //循环值为8，求与原图片汉明距离最小的那张图片
    {
        if(min>diff[i]&&diff[i]!=)
            {
                min=diff[i];
                t=i;}           //检测出的标记为t
    }
    path2=format("C:\\Users\\yu\\Documents\\Visual Studio 2010\\Projects\\test\\images\\%d.jpg",t);
    image2=imread(path2,-);//将图片t显示出来
    cvNamedWindow("相似的图片",);
    imshow("相似的图片",image2);//这时显示的就是最相似的照片
    cvWaitKey();
    cin.get();                    //吃掉回车符
}

实验结果如下：

我的照片库如下：

至此，简单地完成了检测并且识别人脸的功能。