OpenCV人脸检测demo--facedetect

&1 问题来源

　　在运行官网的facedetect这个demo的时候，总是不会出来result的图形，电脑右下角提示的错误是“显示器驱动程序已停止响应，而且已恢复 windows 8(R)”。

&2 前期处理

• 修改代码，各种代码上的调试都尝试过，demo运行失败了；
• 百度上的禁用视觉效果方案，即修改电脑的主题为“windows 经典”主题，demo运行失败了；
• 百度上的重新安装显卡驱动方案，即重新装集成网卡驱动，导致显示器黑屏，倒腾了一天才整回来，失败；

&3 成功解决

　　首先，打开注册表，找到HKEY_LOCAL_MACHINE，在SYSTEM中的CurrentControlSet中的Control的GrphicsDrivers上面点击右键，新建QEORD（64位）值（Q）,数值名称为：TdrDelay，数值数据为：8，基数不用改变，选择十六进制即可。

　　

　　然后，在你的项目编译文件夹内加入四个文件，haarcascade_eye_tree_eyeglasses.xml和haarcascade_frontalface_alt.xml、opencv_ffmpeg310_64.dll及opencv_world310d.dll；

　　

　　在opencv的环境配置中，(前面有博文介绍)，去掉可执行文件目录，去掉附加依赖项的opencv_world310.lib，至此，所有的环境配置方面已经完成。

&4 demo的代码和运行结果

注意：在opencv安装文件夹sources\samples\cpp中的文件facedetect.cpp即是源代码。

 #include "opencv2/objdetect.hpp"
 #include "opencv2/highgui.hpp"
 #include "opencv2/imgproc.hpp"
 #include <iostream>

 using namespace std;
 using namespace cv;

 static void help()

 {
 　　cout << "\nThis program demonstrates the cascade recognizer. Now you can use Haar or LBP features.\n"
 　　"This classifier can recognize many kinds of rigid objects, once the appropriate classifier is trained.\n"
 　　"It's most known use is for faces.\n"
 　　"Usage:\n"
 　　"./facedetect [--cascade=<cascade_path> this is the primary trained classifier such as frontal face]\n"
 　　" [--nested-cascade[=nested_cascade_path this an optional secondary classifier such as eyes]]\n"
 　　" [--scale=<image scale greater or equal to 1, try 1.3 for example>]\n"
 　　" [--try-flip]\n"
 　　" [filename|camera_index]\n\n"
 　　"see facedetect.cmd for one call:\n"
 　　"./facedetect --cascade=\"../../data/haarcascades/haarcascade_frontalface_alt.xml\" --nested-cascade=\"../../data/haarcascades/haarcascade_eye_tree_eyeglasses.xml\" --scale=1.3\n\n"
 　　"During execution:\n\tHit any key to quit.\n"
 　　"\tUsing OpenCV version " << CV_VERSION << "\n" << endl;
 }

 void detectAndDraw(Mat& img, CascadeClassifier& cascade,
 CascadeClassifier& nestedCascade,
 double scale, bool tryflip);

 string cascadeName;
 string nestedCascadeName;

 int main(int argc, const char** argv)
 {
 　　VideoCapture capture;
 　　Mat frame, image;
 　　string inputName;
 　　bool tryflip;
 　　CascadeClassifier cascade, nestedCascade;
 　　double scale;

 　　cv::CommandLineParser parser(argc, argv,
 　　　　"{help h||}"
 　　　　"{cascade|haarcascade_frontalface_alt.xml|}"
 　　　　"{nested-cascade|haarcascade_eye_tree_eyeglasses.xml|}"
 　　　　"{scale|1|}{try-flip||}{@filename|lena.jpg|}"
 　　);

 　　if (parser.has("help"))
 　　{
 　　　　help();
 　　　　return ;
 　　}
 　　cascadeName = parser.get<string>("cascade");
 　　nestedCascadeName = parser.get<string>("nested-cascade");
 　　scale = parser.get<double>("scale");
 　　if (scale < )
 　　　　scale = ;
 　　tryflip = parser.has("try-flip");
 　　inputName = parser.get<string>("@filename");
 　　if (!parser.check())
 　　{
 　　　　parser.printErrors();
 　　　　return ;
 　　}
 　　if (!nestedCascade.load(nestedCascadeName))
 　　　　cerr << "WARNING: Could not load classifier cascade for nested objects" << endl;
 　　if (!cascade.load(cascadeName))
 　　{
 　　　　cerr << "ERROR: Could not load classifier cascade" << endl;
 　　　　help();
 　　　　return -;
 　　}
 　　if (inputName.empty() || (isdigit(inputName[]) && inputName.size() == ))
 　　{
 　　　　int c = inputName.empty() ?  : inputName[] - '';
 　　　　if (!capture.open(c))
 　　　　cout << "Capture from camera #" << c << " didn't work" << endl;
 　　}
 　　else if (inputName.size())
 　　{
 　　　　image = imread(inputName, );
 　　　　if (image.empty())
 　　　　{
 　　　　　　if (!capture.open(inputName))
 　　　　　　cout << "Could not read " << inputName << endl;
 　　　　}
 　　}
 　　else
 　　{
 　　　　image = imread("../data/lena.jpg", );
 　　　　if (image.empty()) cout << "Couldn't read ../data/lena.jpg" << endl;
 　　}

 　　if (capture.isOpened())
 　　{
 　　　　cout << "Video capturing has been started ..." << endl;

 　　　　for (;;)
 　　　　{
 　　　　　　capture >> frame;
 　　　　　　if (frame.empty())
 　　　　　　break;

 　　　　　　Mat frame1 = frame.clone();
 　　　　　　detectAndDraw(frame1, cascade, nestedCascade, scale, tryflip);

 　　　　　　int c = waitKey();
 　　　　　　if (c ==  || c == 'q' || c == 'Q')
 　　　　　　break;
 　　　　}
 　　}
 　　else
 　　{
 　　　　cout << "Detecting face(s) in " << inputName << endl;
 　　　　if (!image.empty())
 　　　　{
 　　　　　　detectAndDraw(image, cascade, nestedCascade, scale, tryflip);
 　　　　　　waitKey();
 　　　　}
 　　else if (!inputName.empty())
 　　{
 　　　　/* assume it is a text file containing the
 　　　　list of the image filenames to be processed - one per line */
 　　　　FILE* f = fopen(inputName.c_str(), "rt");
 　　　　if (f)
 　　　　{
 　　　　　　char buf[ + ];
 　　　　　　while (fgets(buf, , f))
 　　　　　　{
 　　　　　　　　int len = (int)strlen(buf), c;
 　　　　　　　　while (len >  && isspace(buf[len - ]))
 　　　　　　　　len--;
 　　　　　　　　buf[len] = '\0';
 　　　　　　　　cout << "file " << buf << endl;
 　　　　　　　　image = imread(buf, );
 　　　　　　　　if (!image.empty())
 　　　　　　　　{
 　　　　　　　　　　detectAndDraw(image, cascade, nestedCascade, scale, tryflip);
 　　　　　　　　　　c = waitKey();
 　　　　　　　　　　if (c ==  || c == 'q' || c == 'Q')
 　　　　　　　　　　　　break;
 　　　　　　　　}
 　　　　　　　　else
 　　　　　　　　{
 　　　　　　　　　　cerr << "Aw snap, couldn't read image " << buf << endl;
 　　　　　　　　}
 　　　　　　}
 　　　　fclose(f);
 　　　　}
 　　}
 }

 return ;
 }

 void detectAndDraw(Mat& img, CascadeClassifier& cascade,
 CascadeClassifier& nestedCascade,
 double scale, bool tryflip)
 {
 double t = ;
 vector<Rect> faces, faces2;
 const static Scalar colors[] =
 {
 Scalar(, , ),
 Scalar(, , ),
 Scalar(, , ),
 Scalar(, , ),
 Scalar(, , ),
 Scalar(, , ),
 Scalar(, , ),
 Scalar(, , )
 };
 Mat gray, smallImg;

 cvtColor(img, gray, COLOR_BGR2GRAY);
 double fx =  / scale;
 resize(gray, smallImg, Size(), fx, fx, INTER_LINEAR);
 equalizeHist(smallImg, smallImg);

 t = (double)cvGetTickCount();
 cascade.detectMultiScale(smallImg, faces,
 1.1, ,
 //|CASCADE_FIND_BIGGEST_OBJECT
 //|CASCADE_DO_ROUGH_SEARCH
 | CASCADE_SCALE_IMAGE,
 Size(, ));
 if (tryflip)
 {
 flip(smallImg, smallImg, );
 cascade.detectMultiScale(smallImg, faces2,
 1.1, ,
 //|CASCADE_FIND_BIGGEST_OBJECT
 //|CASCADE_DO_ROUGH_SEARCH
 | CASCADE_SCALE_IMAGE,
 Size(, ));
 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()*.));
 for (size_t i = ; i < faces.size(); i++)
 {
 Rect r = faces[i];
 Mat smallImgROI;
 vector<Rect> nestedObjects;
 Point center;
 Scalar color = colors[i % ];
 int radius;

 double aspect_ratio = (double)r.width / r.height;
 if (0.75 < aspect_ratio && aspect_ratio < 1.3)
 {
 center.x = cvRound((r.x + r.width*0.5)*scale);
 center.y = cvRound((r.y + r.height*0.5)*scale);
 radius = cvRound((r.width + r.height)*0.25*scale);
 circle(img, center, radius, color, , , );
 }
 else
 rectangle(img, cvPoint(cvRound(r.x*scale), cvRound(r.y*scale)),
 cvPoint(cvRound((r.x + r.width - )*scale), cvRound((r.y + r.height - )*scale)),
 color, , , );
 if (nestedCascade.empty())
 continue;
 smallImgROI = smallImg(r);
 nestedCascade.detectMultiScale(smallImgROI, nestedObjects,
 1.1, ,
 //|CASCADE_FIND_BIGGEST_OBJECT
 //|CASCADE_DO_ROUGH_SEARCH
 //|CASCADE_DO_CANNY_PRUNING
 | CASCADE_SCALE_IMAGE,
 Size(, ));
 for (size_t j = ; j < nestedObjects.size(); j++)
 {
 Rect nr = nestedObjects[j];
 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, , , );
 }
 }
 imshow("result", img);
 }

facedetect源码

结果：