精华内容
下载资源
问答
  • 打开摄像头进行人脸检测 #include<iostream> #include<opencv2/objdetect/objdetect.hpp> #include<opencv2/highgui/highgui.hpp> #include<opencv2/imgproc/...

    配置好OpenCV环境来测试一下小程序。

    1. 打开摄像头进行人脸检测
       
      #include<iostream>
      #include<opencv2/objdetect/objdetect.hpp>
      #include<opencv2/highgui/highgui.hpp>
      #include<opencv2/imgproc/imgproc.hpp>
      using namespace cv;
      
      //人脸检测的类
      CascadeClassifier faceCascade;
      
      int main()
      {
      
      	faceCascade.load("haarcascade_frontalface_alt2.xml");   //加载分类器,注意文件路径
      
      	VideoCapture cap;
      	cap.open(0);   //打开摄像头
      				   //cap.open("../data/test.avi");   //打开视频
      	
      	Mat img, imgGray;
      	vector<Rect> faces;
      	int c = 0;
      
      	if (!cap.isOpened())
      	{
      		return 1;
      	}
      
      	while (c!=27)//按Esc退出
      	{
      		cap >> img;
      		if (img.channels() == 3)
      		{
      			cvtColor(img, imgGray, CV_RGB2GRAY);
      		}
      		else
      		{
      			imgGray = img;
      		}
      
      		faceCascade.detectMultiScale(imgGray, faces, 1.2, 2, 0, Size(0, 0));   //检测人脸
      
      		if (faces.size()>0)
      		{
      			for (int i = 0; i<faces.size(); i++)
      			{
      				rectangle(img, Point(f
    展开全文
  • 人脸检测XML

    2017-05-20 11:03:55
    这是我利用5000张正样本 4673张负样本训练的XML,识别率比opencv默认提供的XML低一点,但是误检率比opencv提供的要低很多
  • 人脸检测xml文件.zip

    2019-06-27 11:31:26
    人脸识别-opencv自带的人脸检测和眼睛检测的两个xml文件,可以用于做人脸检测
  • Haar人脸检测Xml文件

    2019-01-17 08:34:35
    haarcascades中的xml文件用于人脸检测库,下载之后拷贝到执行所在文件夹即可。
  • opencv 人脸检测 haarcascade_frontalface_default.xml 构建分类器所需要的xml文件
  • 亲测可用,欢迎各位童鞋下载使用!
  • 用于opencv的人脸和眼睛检测xml文件 haarcascade_frontalface_alt.xml haarcascade_eye_tree_eyeglasses.xml
  • python+opencv 实现图像人脸检测及视频中的人脸检测

    千次阅读 多人点赞 2020-09-01 17:13:38
    python+opencv 实现图像人脸检测及视频中的人脸检测,首先下载人脸检测要用到的分类器,熟悉opencv相关API的使用,然后利用python+opencv实现图像单人脸检测、图像多人脸检测、视频中人脸检测和摄像头人脸检测

    执着于理想,纯粹于当下。

    原文链接:https://yetingyun.blog.csdn.net/article/details/108153075
    创作不易,未经作者允许,禁止转载,更勿做其他用途,违者必究。

    一、数据和知识准备

    1. 下载HAAR与LBP数据

    人脸检测的常见步骤如下,如果想要将人脸准确地检测出来,需要通过建立人脸模型,获取准确区分人脸的分类器,这里我们使用网上公开的扩展包或已经训练好的分类器。

    将 haarcascades 与 lbpcascades 里面的相关 xml 文件下载到本地,便于之后调用,辅助进行人脸检测。

    下载地址:https://github.com/opencv/opencv/tree/master/data

    在这里插入图片描述

    2. opencv相关知识

    • cv.CascadeClassifier():是 OpenCV 中人脸检测的一个级联分类器,既可以使用 Haar 特征,也可以使用 LBP 特征。以 Haar 特征分类器为基础的对象检测技术是一种非常有效的技术,它是基于机器学习且使用大量的正负样本训练得到分类器。
    • detectMultiScale函数:检测人脸算法,其参数如下:
      image:要检测的输入图像
      scaleFactor:表示每次图像尺寸减小的比例
      minNeighbors:表示每一个目标至少要被检测到多少次才算是真的人脸,因为周围的像素和不同的窗口大小都可能检测成人脸
      minSize:表示目标的最小尺寸
      maxSize:表示目标的最小尺寸
    • Haar-like矩形特征:是用于物体检测的数字图像特征。这类矩形特征模板由两个或多个全等的黑白矩形相邻组合而成,而矩形特征值是白色矩形的灰度值的和减去黑色矩形的灰度值的和,矩形特征对一些简单的图形结构,如线段、边缘比较敏感。如果把这样的矩形放在一个非人脸区域,那么计算出的特征值应该和人脸特征值不一样,所以这些矩形就是为了把人脸特征量化,以区分人脸和非人脸。
    • LBP:是一种特征提取方式,能提取出图像的局部的纹理特征,最开始的 LBP 算子是在 3X3 窗口中,取中心像素的像素值为阀值,与其周围八个像素点的像素值比较,若像素点的像素值大于阀值,则此像素点被标记为1,否则标记为0。这样就能得到一个八位二进制的码,转换为十进制即 LBP 码,于是得到了这个窗口的 LBP 值,用这个值来反映这个窗口内的纹理信息。LBPH是在原始 LBP 上的一个改进,在 opencv 支持下可以直接调用函数直接创建一个 LBPH 人脸识别的模型。
      比如:cv2.face.LBPHFaceRecognizer_create()。

    二、python+opencv实现人脸检测

    1. 图像单人脸检测

    import cv2 as cv
    
    
    def face_detection(image):
        # 创建一个级联分类器 加载一个.xml分类器文件 它既可以是Haar特征也可以是LBP特征的分类器
        face_detecter = cv.CascadeClassifier(r'./face_detection/haarcascades/haarcascade_frontalface_default.xml')
        # 多个尺度空间进行人脸检测   返回检测到的人脸区域坐标信息
        faces = face_detecter.detectMultiScale(image=image, scaleFactor=1.1, minNeighbors=5)
        print('检测人脸信息如下:\n', faces)
        for x, y, w, h in faces:
            # 在原图像上绘制矩形标识
            cv.rectangle(img=image, pt1=(x, y), pt2=(x+w, y+h), color=(0, 0, 255), thickness=2)
        cv.imshow('result', image)
    
    
    src = cv.imread(r'./test/036.jpg')
    cv.imshow('input image', src)
    face_detection(src)
    cv.waitKey(0)
    cv.destroyAllWindows()
    

    运行效果如下:

    检测人脸信息如下:
     [[ 61  53 110 110]]
    
    Process finished with exit code 0
    

    在这里插入图片描述

    2. 图像多人脸检测

    import cv2 as cv
    
    
    def face_detection(image):
    	# 转成灰度图像
        gray = cv.cvtColor(image, cv.COLOR_BGR2GRAY)
        # 创建一个级联分类器 加载一个.xml分类器文件 它既可以是Haar特征也可以是LBP特征的分类器
        face_detecter = cv.CascadeClassifier(r'./face_detection/haarcascades/haarcascade_frontalface_default.xml')
        # 多个尺度空间进行人脸检测   返回检测到的人脸区域坐标信息
        faces = face_detecter.detectMultiScale(image=gray, scaleFactor=1.1, minNeighbors=5)
        print('检测人脸信息如下:\n', faces)
        for x, y, w, h in faces:
            # 在原图像上绘制矩形标识
            cv.rectangle(img=image, pt1=(x, y), pt2=(x+w, y+h), color=(0, 0, 255), thickness=2)
        cv.imshow('result', image)
    
    
    src = cv.imread(r'./test/044.jpg')
    cv.imshow('input image', src)
    face_detection(src)
    cv.waitKey(0)
    cv.destroyAllWindows()
    

    运行效果如下:

    检测人脸信息如下:
     [[329 157  49  49]
     [ 88 156  44  44]
     [157 158  54  54]
     [240 159  50  50]
     [ 86 370  68  68]
     [ 79 254  54  54]
     [339 250  58  58]
     [155 254  59  59]
     [251 247  59  59]
     [199 371  80  80]
     [308 370  69  69]]
    
    Process finished with exit code 0
    

    在这里插入图片描述

    3. 视频中人脸检测

    # -*- coding: UTF-8 -*-
    """
    @Author  :叶庭云
    @公众号  :修炼Python
    @CSDN    :https://yetingyun.blog.csdn.net/
    """
    import cv2
    
    
    # 加载视频
    cap = cv2.VideoCapture('test.mp4')
    # 创建一个级联分类器 加载一个.xml分类器文件 它既可以是Haar特征也可以是LBP特征的分类器
    face_detect = cv2.CascadeClassifier(r'./face_detection/haarcascades/haarcascade_frontalface_default.xml')
    
    while True:
        # 读取视频片段
        ret, frame = cap.read()
        if not ret:  # 读完视频后falg返回False
            break
        frame = cv2.resize(frame, None, fx=0.5, fy=0.5)
        # 灰度处理
        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
        # 多个尺度空间进行人脸检测   返回检测到的人脸区域坐标信息
        face_zone = face_detect.detectMultiScale(gray, scaleFactor=1.1, minNeighbors=8)
        # 绘制矩形和圆形检测人脸
        for x, y, w, h in face_zone:
            cv2.rectangle(frame, pt1=(x, y), pt2=(x + w, y + h), color=[0, 0, 255], thickness=2)
            cv2.circle(frame, center=(x + w // 2, y + h // 2), radius=w // 2, color=[0, 255, 0], thickness=2)
        # 显示图片
        cv2.imshow('video', frame)
        # 设置退出键和展示频率
        if ord('q') == cv2.waitKey(40):
            break
    
    # 释放资源
    cv2.destroyAllWindows()
    cap.release()
    

    截取新版倚天屠龙记某一集36:35到36:39的片段,简单实现实时检测人脸并显示,运行效果如下:

    在这里插入图片描述

    在这里插入图片描述

    在这里插入图片描述
    任何算法都不会 100% 识别准确,由于噪声、误差、算法、训练集等影响,某些时候也会出现一些错误识别。自己进行简单测试时也会发现,人物动作、视频中镜头切换过快、背景变化等因素,可能会造成对视频中人脸检测不准确。

    4. 摄像头人脸检测

    import cv2 as cv
    
    
    # 识别电脑摄像头并打开
    cap = cv.VideoCapture(0, cv.CAP_DSHOW)
    # 创建一个级联分类器 加载一个.xml分类器文件 它既可以是Haar特征也可以是LBP特征的分类器
    face_detect = cv.CascadeClassifier(r'./face_detection/haarcascades/haarcascade_frontalface_default.xml')
    
    while True:
        # 读取视频片段
        flag, frame = cap.read()
        frame = cv.flip(frame, 1)
        if not flag:   # 读完视频后falg返回False
            break
        # 灰度处理
        gray = cv.cvtColor(frame, cv.COLOR_BGR2GRAY)
        # 多个尺度空间进行人脸检测   返回检测到的人脸区域坐标信息
        face_zone = face_detect.detectMultiScale(gray, scaleFactor=1.1, minNeighbors=5)
        # 绘制矩形和圆形检测人脸
        for x, y, w, h in face_zone:
            cv.rectangle(frame, pt1=(x, y), pt2=(x + w, y + h), color=[0, 0, 255], thickness=2)
            cv.circle(frame, center=(x + w // 2, y + h // 2), radius=w // 2, color=[0, 255, 0], thickness=2)
        # 显示图片
        cv.imshow('video', frame)
        # 设置退出键q 展示频率
        if ord('q') == cv.waitKey(30):
            break
    
    # 释放资源
    cv.destroyAllWindows()
    cap.release()
    

    程序运行,即可调用电脑的摄像头识别面对摄像头的人脸,正脸和静止状态检测人脸的效果好。

    展开全文
  • xml.zip(人脸检测

    2020-04-01 14:29:04
    shape_predictor_68_face_landmarks.dat opencv_face_detector_uint8.pb opencv_face_detector.pbtxt deploy.prototxt res10_300x300_ssd_iter_140000_fp16.caffemodel haarcascade_frontalface_...haarcascade_eye.xml
  • 人脸检测工具,人眼检测工具,训练好的人眼文件haarcascade_eye_tree_eyeglasses.xml,配合opencv使用,进行人脸检测
  • 前一段时间写了一个人脸相关的算法,包括视频中的人脸检测,相机的人脸检测,图像中人脸检测,还有人脸识别。 使用的是VS2013和opencv。 首先创建头文件common.h #ifndef _COMMON_H #define _COMMON_H #include #...

    前一段时间写了一个人脸相关的算法,包括视频中的人脸检测,相机的人脸检测,图像中人脸检测,还有人脸识别。

    使用的是VS2013和opencv。

    首先创建头文件common.h

    #ifndef _COMMON_H
    #define _COMMON_H
    
    #include <opencv2/opencv.hpp>
    #include <opencv2/highgui/highgui.hpp>
    #include <opencv2/imgproc/imgproc.hpp>
    #include <iostream>
    #include <sys/types.h>
    #include <sys/stat.h>
    #include <fstream>
    #include <string>
    #include <ctime>
    #include <io.h>
    #include <direct.h>
    //#include <cstdlib>
    
    
    static const char help[] = "face detection on image:   needs image\n" \
                                "face detection on video:   needs video\n"  \
                                "face detection on camera:  needs camera\n" \
                                "face recognition:  needs images\n";
    
    /*
      功能:判断该路径指向的是文件还是文件夹
    
      函数:isFileOrFolder
      
      文件返回:   0
      文件夹返回: 1  
    */
    bool isFileOrFolder(const std::string fileName);
    
    #endif
    然后就是创建common.cpp文件,这里面有相关的实现。

    #include "common.h"
    
    bool isFileOrFolder(const std::string fileName)
    {
      const char* path = fileName.c_str();
      struct _stat buf = { 0 };
      _stat(path, &buf);
      return buf.st_mode & _S_IFDIR;
    }
    
    然后就是视频中的人脸检测创建文件face_detection_video.h

    #ifndef _FACE_DETETION_VIDEO_H_
    #define _FACE_DETETION_VIDEO_H_
    
    #include "common.h"
    void face_detetion_video(const std::string videoPath, const std::string cascadeName);
    
    #endif

    接着创建对应的cpp文件,face_detection_video.cpp

    #include "face_deteion_video.h"
    
    void face_detetion_video(const std::string videoPath, const std::string cascadeName)
    {
      cv::VideoCapture cap(videoPath);
      if (!cap.isOpened())
      {
        std::cout << "不能打开该视频文件!" << std::endl;
        return;
      }
    
      double scale = 2;
      cv::CascadeClassifier cascade;
      cascade.load(cascadeName);
      std::vector<cv::Rect> faces;
      
      double fps = cap.get(CV_CAP_PROP_FPS);  //获取帧率
    
      bool isVideoRewriteFile = true; // 是否把视频重新写入文件, 默认是false:不重新写入文件
      double dWidth = 0;
      double dHeight = 0;
      cv::Size frameSize;
      cv::VideoWriter vdWr;
      if (isVideoRewriteFile)
      {
        dWidth = cap.get(CV_CAP_PROP_FRAME_WIDTH);
        dHeight = cap.get(CV_CAP_PROP_FRAME_HEIGHT);
        frameSize = cv::Size(static_cast<int>(dWidth), static_cast<int>(dHeight));
    
        size_t pos = videoPath.find_last_of('.');
        std::string videoWritePath = videoPath.substr(0, pos);
        videoWritePath = videoWritePath + "_Result.avi";
        vdWr = cv::VideoWriter(videoWritePath, CV_FOURCC('M', 'J', 'P', 'G'), fps, frameSize, true);
        if (!vdWr.isOpened())
        {
          std::cout << "不能写入视频!" << std::endl;
          isVideoRewriteFile = false;
        }
      }
    
      while (1)
      {
        cv::Mat_<uchar> frame;
        bool bSuccess = cap.read(frame);
        if (!bSuccess)
        {
          break;
        }
    
        cv::Mat smallImg(cvRound(frame.rows / scale), cvRound(frame.cols / scale), CV_8UC1);  //cvRound对double型数据进行四舍五入
        cv::resize(frame, smallImg, smallImg.size(), 0, 0, cv::INTER_LINEAR);
        cvtColor(smallImg, smallImg, CV_RGB2GRAY);
        cv::equalizeHist(smallImg, smallImg);                                                 //equalizeHist提高图像的亮度和对比度
    
        cascade.detectMultiScale(smallImg, faces,
                                  1.1, 2, 0
                                  /*|CV_HAAR_FIND_BIGGEST_OBJECT
                                  |CV_HAAR_DO_ROUGH_SEARCH*/
                                  | CV_HAAR_SCALE_IMAGE
                                  ,
                                  cv::Size(30, 30));
    
        for (std::vector<cv::Rect>::const_iterator r = faces.begin(); r != faces.end(); r++){
          cv::Rect rect(0, 0, 0, 0);
    
          rect.x = int(r->x*scale);
          rect.y = int(r->y*scale);
          rect.width = int((r->width - 1)*scale);
          rect.height = int((r->height - 1)*scale);
    
          cv::rectangle(frame, rect, cv::Scalar(0, 0, 0), 3, 8);
        }
    
        //是否把检测结果写入文件
        if (isVideoRewriteFile)
        {
          vdWr.write(frame);
        }
    
        cv::imshow("Video", frame);
        cv::waitKey((int)(1000 / fps));
    
      }
    
      cap.release();
      vdWr.release();
    }
    然后是图像中的寻找人脸,文件名face_detection_img.h

    #ifndef _FACE_DETETION_IMAGE_H_
    #define _FACE_DETETION_IMAGE_H_
    
    #include "common.h"
    
    void face_detetion_img(const std::string imagePath, const std::string cascadeName);
    
    
    
    #endif

    接着就是对应头文件face_detection_img.cpp

    #include "face_detetion_img.h"
    
    
    void face_detetion_img(const std::string imgPath, const std::string cascadeName)
    {
      //bool fileOrFolder = isFileOrFolder(imgPath);
      
      std::ifstream fin;
      fin.open(imgPath);
    
      cv::CascadeClassifier cascade;
      double scale = 1.3;
      std::vector<cv::Rect> faces;
      cv::Mat gray;
    
      // --Detection
      cascade.load(cascadeName);
      std::string name;
      while (getline(fin, name)){
        name.erase(0, name.find_first_not_of(" \t"));
        name.erase(name.find_last_not_of(" \t") + 1);
    
        // Read Image
        cv::Mat_<uchar> image = cv::imread(name, 0);
        if (image.empty())
        {
          continue;
        }
    
        // Read Opencv Detection Bbx
        cv::Mat smallImg(cvRound(image.rows / scale), cvRound(image.cols / scale), CV_8UC1); //cvRound对double型数据进行四舍五入
        cv::resize(image, smallImg, smallImg.size(), 0, 0, cv::INTER_LINEAR);
        cv::equalizeHist(smallImg, smallImg);                                              //equalizeHist提高图像的亮度和对比度
        // --Detection
        cascade.detectMultiScale(smallImg, faces,
                                  1.1, 2, 0
                                  /*|CV_HAAR_FIND_BIGGEST_OBJECT
                                  |CV_HAAR_DO_ROUGH_SEARCH*/
                                  | CV_HAAR_SCALE_IMAGE
                                  ,
                                  cv::Size(30, 30));
        for (std::vector<cv::Rect>::const_iterator r = faces.begin(); r != faces.end(); r++){
          cv::Rect rect(0, 0, 0, 0);
    
          rect.x = int(r->x*scale);
          rect.y = int(r->y*scale);
          rect.width = int((r->width - 1)*scale);
          rect.height = int((r->height - 1)*scale);
    
          cv::rectangle(image, rect, cv::Scalar(0, 255, 0), 3, 8);
        }
    
        cv::imshow("test", image);
        char s = cv::waitKey(0);
        if ('s' == s )
        {
          size_t pos = name.find_last_of('.');
          std::string filename = name.substr(0, pos);
          
          filename = filename + ".bmp";
          std::cout << filename << std::endl;
          cv::imwrite(filename, image);
        }
      }
      fin.close();
    }

    然后就是从摄像投中读取人脸信息。创建文件face_detection_camera.h

    #ifndef _FACE_DETETION_CAMERA_H_
    #define _FACE_DETETION_CAMERA_H_
    
    #include "common.h"
    void face_detetion_camera(const std::string cascadeName);
    
    #endif
    接着就是对应cpp文件,face_detection_camera.cpp

    #include "face_detetion_camera.h"
    
    void face_detetion_camera(const std::string cascadeName)
    {
      cv::VideoCapture cap(0);
      if (!cap.isOpened())
      {
        std::cout << "不能打开该视频文件!" << std::endl;
        return;
      }
    
      double scale = 2;
      cv::CascadeClassifier cascade;
      cascade.load(cascadeName);
      std::vector<cv::Rect> faces;
    
      bool isVideoRewriteFile = false; // 是否把摄像头读取的数据写入文件。
      double dWidth = 0;
      double dHeight = 0;
      cv::Size frameSize;
      cv::VideoWriter vdWr;
      char tmp[1024] = { 0 };
      if (isVideoRewriteFile)
      {
        dWidth = cap.get(CV_CAP_PROP_FRAME_WIDTH);
        dHeight = cap.get(CV_CAP_PROP_FRAME_HEIGHT);
        frameSize = cv::Size(static_cast<int>(dWidth), static_cast<int>(dHeight));
    
        time_t t = time(0);
        memset(tmp, 0, sizeof(tmp));
        strftime(tmp, sizeof(tmp), "../camera_out_video/%Y.%m.%d-%H.%M.%S", localtime(&t));
        std::string videoWritePath(tmp);
        videoWritePath = videoWritePath + ".avi";
        vdWr = cv::VideoWriter(videoWritePath, CV_FOURCC('M', 'J', 'P', 'G'), 20, frameSize, true);
        if (!vdWr.isOpened())
        {
          std::cout << "不能写入视频!" << std::endl;
          isVideoRewriteFile = false;
        }
      }
    
      while (1)
      {
        cv::Mat frame;
        bool bSuccess = cap.read(frame);
        if (!bSuccess)
        {
          break;
        }
    
        cv::Mat smallImg(cvRound(frame.rows / scale), cvRound(frame.cols / scale), CV_8UC1);  //cvRound对double型数据进行四舍五入
        cv::resize(frame, smallImg, smallImg.size(), 0, 0, cv::INTER_LINEAR);
        cvtColor(smallImg, smallImg, CV_RGB2GRAY);
        cv::equalizeHist(smallImg, smallImg);                                                 //equalizeHist提高图像的亮度和对比度
    
        cascade.detectMultiScale(smallImg, faces,
                                    1.1, 2, 0
                                    /*|CV_HAAR_FIND_BIGGEST_OBJECT
                                    |CV_HAAR_DO_ROUGH_SEARCH*/
                                    | CV_HAAR_SCALE_IMAGE
                                    ,
                                    cv::Size(30, 30));
    
        for (std::vector<cv::Rect>::const_iterator r = faces.begin(); r != faces.end(); r++){
          cv::Rect rect(0, 0, 0, 0);
    
          rect.x = int(r->x*scale);
          rect.y = int(r->y*scale);
          rect.width = int((r->width - 1)*scale);
          rect.height = int((r->height - 1)*scale);
    
          cv::rectangle(frame, rect, cv::Scalar(0, 0, 0), 3, 8);
        }
    
        //是否把检测结果写入文件
        if (isVideoRewriteFile)
        {
          vdWr.write(frame);
        }
    
        cv::imshow("Video", frame);
        if (27 == cv::waitKey(20)){     // 按下ESC键,结束视频
          break;
        }
    
      }
    
      cap.release();
      vdWr.release();
    }
    最后是人脸识别的头文件:face_recognition.h

    #ifndef _FACE_RECOGNITION_H_
    #define _FACE_RECOGNITION_H_
    
    #include "common.h"
    
    void preDeal_original_img(const std::string recognitionPath, const std::string cascadeName);
    std::vector<std::pair<cv::Mat, std::string >> get_CropFace_And_ImgPathName(const std::string recognitionPath, const std::string cascadeName);
    bool matchFace(cv::Mat detectFace, cv::Mat dbFace);
    void face_recognition(std::string recognitionPath, const std::string cascadeName);
    
    #endif

    以及对应的cpp文件:face_recognition.cpp

    #include "face_recognition.h"
    
    void preDeal_original_img(const std::string recognitionPath, const std::string cascadeName)
    {
      std::ifstream fin;
      fin.open(recognitionPath);
      if (!fin)
      {
        std::cout << "Cannot open " + recognitionPath << std::endl;
        return;
      }
    
      // --Detection
      cv::CascadeClassifier cascade;
      cascade.load(cascadeName);
      if (cascade.empty())
      {
        std::cout << "Cascade path error!" << std::endl;
        return;
      }
    
      double scale = 1.3;
      std::vector<cv::Rect> faces;
      cv::Mat gray;
    
      std::string name;
      std::string camera_face = "../camera_face/";
      while (getline(fin, name)){
        if (name.empty())
        {
          continue;
        }
        name.erase(0, name.find_first_not_of(" \t"));
        name.erase(name.find_last_not_of(" \t") + 1);
    
        // Read Image
        cv::Mat img = cv::imread(name);
        if (img.empty())
        {
          continue;
        }
    
        cv::Mat_<uchar> image;
        if (img.channels() != 1)
        {
          cvtColor(img, image, CV_BGR2GRAY);
          image.convertTo(image, CV_8UC1);
        }
        else{
          image = img;
        }
        
    
        // 改变图像
        cv::Mat smallImg(cvRound(image.rows / scale), cvRound(image.cols / scale), CV_8UC1); //cvRound对double型数据进行四舍五入
        cv::resize(image, smallImg, smallImg.size(), 0, 0, cv::INTER_LINEAR);
        cv::equalizeHist(smallImg, smallImg);                                              //equalizeHist提高图像的亮度和对比度
        // --Detection
        cascade.detectMultiScale(smallImg, faces,
                                  1.1, 3, 0
                                  /*|CV_HAAR_FIND_BIGGEST_OBJECT
                                  |CV_HAAR_DO_ROUGH_SEARCH*/
                                  | CV_HAAR_SCALE_IMAGE
                                  ,
                                  cv::Size(30, 30));
        if (faces.size() > 0)
        {
          size_t pos = name.find_last_of('\\');
          std::string filename = name.substr(pos + 1);
    
          if (-1 == _access(camera_face.c_str(), 0))
          {
            _mkdir(camera_face.c_str());
          }
    
          filename = camera_face + filename;
          std::cout << filename << std::endl;
          cv::imwrite(filename, img);
        }
    
      }
      fin.close();
    
      //处理后的图片路径名写入Path_Image.txt中
      std::string getImgPathTxt = "cd " + camera_face + " && dir /b/s/p/w *.jpg > Path_Images.txt";
      system(getImgPathTxt.c_str());
    }
    
    std::vector<std::pair<cv::Mat, std::string >> get_CropFace_And_ImgPathName(const std::string recognitionPath, const std::string cascadeName)
    {
      std::vector<std::pair<cv::Mat, std::string>> cropFaceAndImgPathNames;
      std::pair<cv::Mat, std::string> cropFaceAndImgPathName;
    
      cv::CascadeClassifier cascade;
      cascade.load(cascadeName);
      if (cascade.empty())
      {
        std::cout << "Cascade path error!" << std::endl;
        return std::vector<std::pair<cv::Mat, std::string >>();
      }
    
      std::ifstream fdatabase;
      fdatabase.open(recognitionPath);
      if (!fdatabase)
      {
        std::cout << "Cannot open " + recognitionPath << std::endl;
        return std::vector<std::pair<cv::Mat, std::string >>();
      }
    
      double scale = 1.3;
      std::vector<cv::Rect> faces;
      cv::Mat gray;
      std::string name;
      
      std::cout << "[";
    
      while (getline(fdatabase, name)){
        if (name.empty())
        {
          continue;
        }
        name.erase(0, name.find_first_not_of(" \t"));
        name.erase(name.find_last_not_of(" \t") + 1);
    
        // Read Image
        cv::Mat img = cv::imread(name);
        if (img.empty())
        {
          continue;
        }
        cv::Mat image;
        if (img.channels() != 1)
        {
          cvtColor(img, image, CV_BGR2GRAY);
          image.convertTo(image, CV_8UC1);
        }
        else{
          image = img;
        }
        
        // Read Opencv Detection Bbx
        cv::Mat smallImg(cvRound(image.rows / scale), cvRound(image.cols / scale), CV_8UC1); //cvRound对double型数据进行四舍五入
        cv::resize(image, smallImg, smallImg.size(), 0, 0, cv::INTER_LINEAR);
        cv::equalizeHist(smallImg, smallImg);                                              //equalizeHist提高图像的亮度和对比度
        // --Detection
        cascade.detectMultiScale(smallImg, faces,
                                  1.1, 3, 0
                                  /*|CV_HAAR_FIND_BIGGEST_OBJECT
                                  |CV_HAAR_DO_ROUGH_SEARCH*/
                                  | CV_HAAR_SCALE_IMAGE
                                  ,
                                  cv::Size(30, 30));
        for (std::vector<cv::Rect>::iterator r = faces.begin(); r != faces.end(); r++)
        {
          cv::Rect face;
          face.x = int(r->x * scale);
          face.y = int(r->y * scale);
          face.width = int(r->width * scale);
          face.height = int(r->height * scale);
    
          // 边界检查,左边界,上边界,右边界,下边界。
          /*face.x = face.x < 1 ? 1 : face.x;
          face.y = face.y < 1 ? 1 : face.y;
          face.width = (face.x + face.width) > image.cols ? (image.cols - face.x) : face.width;
          face.height = (face.y + face.height) > image.rows ? (image.rows - face.y) : face.height;*/
    
          cv::Mat cropFace;
          cropFace = img(face);
          /*cv::moveWindow("cropface", 960 - cropFace.cols / 2, 540 - cropFace.rows / 2);
          cv::imshow("cropface", cropFace);
          cv::waitKey(100);
          cv::destroyWindow("cropface");*/
          
          cropFaceAndImgPathName = make_pair(cropFace, name);  //cropFaceAndImgPathName = std::pair<cv::Mat, std::string>(cropFace, name);
    
          cropFaceAndImgPathNames.push_back(cropFaceAndImgPathName);
    
          std::cout << '.';
        }
    
      }
    
      fdatabase.close();
      
      std::cout << "]" << std::endl;
    
      return cropFaceAndImgPathNames;
    }
    
    bool matchFace(cv::Mat detectFace, cv::Mat dbFace)
    {
      IplImage* srcImg = cvCloneImage(&(IplImage)detectFace);
      IplImage* dstImg = cvCloneImage(&(IplImage)dbFace);
    
      IplImage* src;
      IplImage* dst;
    
      if (srcImg->nChannels != 1)
      {
        src = cvCreateImage(cvSize(srcImg->width, srcImg->height), srcImg->depth, 1);
        cvCvtColor(srcImg, src, CV_BGR2GRAY);
      }
    
      if (dstImg->nChannels != 1)
      {
        dst = cvCreateImage(cvSize(dstImg->width, dstImg->height), dstImg->depth, 1);
        cvCvtColor(dstImg, dst, CV_BGR2GRAY);
      }
     
      int histogramBins = 256;
      float histogramRange1[2] = { 0, 255 };
      float *histogramRange[1] = { &histogramRange1[0] };
      CvHistogram *Histogram1 = cvCreateHist(1, &histogramBins, CV_HIST_ARRAY, histogramRange);
      CvHistogram *Histogram2 = cvCreateHist(1, &histogramBins, CV_HIST_ARRAY, histogramRange);
    
      cvCalcHist(&src, Histogram1);
      cvCalcHist(&dst, Histogram2);
      
      cvNormalizeHist(Histogram1, 1);
      cvNormalizeHist(Histogram2, 1);
      
      
      // CV_COMP_CHISQR,CV_COMP_BHATTACHARYYA这两种都可以用来做直方图的比较,值越小,说明图形越相似  
      //printf("CV_COMP_CHISQR : %.4f\n", cvCompareHist(Histogram1, Histogram2, CV_COMP_CHISQR));
      //printf("CV_COMP_BHATTACHARYYA : %.4f\n", cvCompareHist(Histogram1, Histogram2, CV_COMP_BHATTACHARYYA));  
    
    
      // CV_COMP_CORREL, CV_COMP_INTERSECT这两种直方图的比较,值越大,说明图形越相似  
      //printf("CV_COMP_CORREL : %.4f\n", cvCompareHist(Histogram1, Histogram2, CV_COMP_CORREL));  
      //printf("CV_COMP_INTERSECT : %.4f\n", cvCompareHist(Histogram1, Histogram2, CV_COMP_INTERSECT));
      double simility = cvCompareHist(Histogram1, Histogram2, CV_COMP_CHISQR);
    
      if (simility > 0.5)
      {
        return false;
      }
    
      return true;
    }
    
    void face_recognition(std::string recognitionPath, const std::string cascadeName)
    {
      bool isPreDeal = false;
      if (isPreDeal)              //是否进行预处理
      {
        preDeal_original_img(recognitionPath, cascadeName);
        recognitionPath = "../camera_face/";
      }
    
      //获取数据库中人脸图像
      std::string face_Database = "../face_database/Path_Images.txt";
      std::vector<std::pair<cv::Mat, std::string>> cropFaceAndImgPathNames;
      std::cout << "开始数据库中人脸数据的读取..." << std::endl;
      cropFaceAndImgPathNames = get_CropFace_And_ImgPathName(face_Database, cascadeName);
      std::cout << "结束数据库中人脸数据的读取。" << std::endl;
    
      //开始人脸匹配
      std::ifstream frecognition;
      frecognition.open(recognitionPath);
      if (!frecognition)
      {
        std::cout << "Images path Error!" << std::endl;
        return;
      }
    
      cv::CascadeClassifier cascade;
      cascade.load(cascadeName);
      if (cascade.empty())
      {
        std::cout << "Cascade path error!" << std::endl;
        return;
      }
    
      double scale = 1.3;
      std::vector<cv::Rect> faces;
      cv::Mat gray;
      std::string name;
    
      bool isExist = false;   //数据库中是否存在该匹配文件
    
      while (getline(frecognition, name)){
        if (name.empty())
        {
          continue;
        }
        name.erase(0, name.find_first_not_of(" \t"));
        name.erase(name.find_last_not_of(" \t") + 1);
    
        // Read Image
        cv::Mat img = cv::imread(name);
        cv::Mat image;
        if (img.channels() != 1)
        {
          cvtColor(img, image, CV_BGR2GRAY);
          image.convertTo(image, CV_8UC1);
        }
        else{
          image = img;
        }
        
        // Read Opencv Detection Bbx
        cv::Mat smallImg(cvRound(image.rows / scale), cvRound(image.cols / scale), CV_8UC1); //cvRound对double型数据进行四舍五入
        cv::resize(image, smallImg, smallImg.size(), 0, 0, cv::INTER_LINEAR);
        cv::equalizeHist(smallImg, smallImg);                                              //equalizeHist提高图像的亮度和对比度
        // --Detection
        cascade.detectMultiScale(smallImg, faces,
                                  1.1, 3, 0
                                  /*|CV_HAAR_FIND_BIGGEST_OBJECT
                                  |CV_HAAR_DO_ROUGH_SEARCH*/
                                  | CV_HAAR_SCALE_IMAGE
                                  ,
                                  cv::Size(30, 30));
        for (std::vector<cv::Rect>::iterator r = faces.begin(); r != faces.end(); r++)
        {
          cv::Rect face;
          face.x = int(r->x * scale);
          face.y = int(r->y * scale);
          face.width = int(r->width * scale);
          face.height = int(r->height * scale);
    
          cv::Mat detectFace = img(face);
    
          for (std::vector<std::pair<cv::Mat, std::string>>::iterator dbFace = cropFaceAndImgPathNames.begin(); dbFace != cropFaceAndImgPathNames.end(); dbFace++)
          {
            std::pair<cv::Mat, std::string> dbFaceImg = *dbFace;
            bool isMatch = matchFace(detectFace, dbFaceImg.first);
            if (isMatch){
              std::cout << name + " Matching " + dbFaceImg.second + " successful!" << std::endl;
              cv::imshow("detectFace", detectFace);
              cv::imshow("databaseFace", dbFaceImg.first);
              cv::waitKey(200);
              cv::destroyWindow("detectFace");
              cv::destroyWindow("databaseFace");
              isExist = true;
            }
          }
    
        }
      }
    
      if (!isExist)
      {
        std::cout << name + " Matching failed!" << std::endl;
      }
    
      frecognition.close();
    }
    

    还有最后的主函数:main.cpp
    #include "common.h"
    #include "face_detetion_img.h"
    #include "face_deteion_video.h"
    #include "face_detetion_camera.h"
    #include "face_recognition.h"
    
    
    int main(int argc, char ** argv)
    {
      
      std::string cascadeFileName = "./../haarcascade_DataBase/haarcascade_frontalface_alt.xml";
      
      //bool fileOrDir = isFileOrFolder(filePath);
      
      if (argc < 2)
      {
        printf(help);
      }
      else if (strcmp(argv[1], "face_detetion_img") == 0)
      {
        std::string imgPath = "E:/1/ImagePath.txt";
        face_detetion_img(imgPath, cascadeFileName);
      }
      else if (strcmp(argv[1], "face_detetion_video") == 0)
      {
        std::string videoPath = "E:\\DeepLeaning\\codes\\FindFaceInVideo\\VGGFace\\chengshd\\IMG_3170.mp4";
        face_detetion_video(videoPath, cascadeFileName);
      }
      else if (strcmp(argv[1], "face_detetion_camera") == 0)
      {
        face_detetion_camera(cascadeFileName);
      }
      else if (strcmp(argv[1], "face_recognition") == 0)
      {
        std::string recognitionPath = "E:/camera/Path_Images.txt";
        face_recognition(recognitionPath, cascadeFileName);
      }
      else
      {
        printf(help);
      }
    
      return 0;
    }
    如果想使用代码,适当修改一下都是可以使用的。

    展开全文
  • 人脸检测需要的xml文件下载

    千次阅读 2019-07-13 13:07:44
    做人脸检测基本能够用到的xml文件都在下面的链接中能够下载的到: https://github.com/opencv/opencv/tree/master/data/haarcascades 点进去如下图所示: 找到Raw,右键Raw,选择“将目标另存为”: 即可将...

    做人脸检测基本能够用到的xml文件都在下面的链接中能够下载的到:
    https://github.com/opencv/opencv/tree/master/data/haarcascades
    在这里插入图片描述点进去如下图所示:
    在这里插入图片描述
    找到Raw,右键Raw,选择“将目标另存为”:
    在这里插入图片描述
    即可将txt文件存到目标路径下,因为存的文件是txt格式的,而用到的是xml格式的文件,所以需要将下载好的txt文件后缀改成xml:
    在这里插入图片描述
    然后便可在python程序中使用了:
    在这里插入图片描述
    在这里插入图片描述先安装anaconda,然后在anaconda prompt中安装OpenCV,安装完anaconda后便会有Spyder,可以在这里面写python程序,而此前安装的python37的IDE不能配置anaconda环境,可以选择用Spyder来编译python程序

    展开全文
  • 人脸检测cpp

    2018-01-12 22:44:30
    亲测可用,方便对于XML文件进行应用,对人脸进行检测亲测可用,方便对于XML文件进行应用,对人脸进行检测亲测可用,方便对于XML文件进行应用,对人脸进行检测亲测可用,方便对于XML文件进行应用,对人脸进行检测亲测...
  • 视频人脸检测只是从摄像头读出每帧图像,然后采用静态图像中的人脸检测方法进行检测。至于视频人脸检测涉及到的其他处理过程,例如轨迹跟踪,将在以后完善。本文只介绍视频人脸检测,对于静态人脸检测,可通过本文...
  • opencv harr xml文件 有需要的拿走,opencv harr xml文件 有需要的拿走
  • opencv4版本下的终端人脸相关检测模型 haarcascade_eye.xml haarcascade_frontalcatface.xml haarcascade_frontalface_alt_tree.xml haarcascade_frontalface_alt.xml haarcascade_smile.xml
  • android 人脸检测_Android人脸检测

    千次阅读 2020-07-06 23:14:52
    android 人脸检测With the release of Google Play services 7.8, Google has brought in the Mobile Vision API that lets you do Face Detection, Barcode Detection and Text Detection. In this tutorial, we’...
  • 基于Python的OpenCV人脸检测

    万次阅读 多人点赞 2020-07-23 19:56:32
    本文将要讲述的是Python环境下如何用OpenCV检测人脸,本文的主要内容分为: 1、检测图片中的人脸 2、实时检测视频中出现的人脸 3、用运设备的摄像头实时检测人脸 提前做的准备: 安装好Python3 下载安装OpenCV库...
  • 包括opencv dnn人脸检测器在内的人脸检测器评估 您可以在Jupyter环境中的每个面部检测器中评估面部检测。 一些模块由类接口包装 OpenCV中的Haar级联脸部检测器 在opencv中使用resnet ssd人脸检测器 dlib正面人脸...
  • opencv人脸检测demo

    2018-12-22 12:20:51
    opencv人脸检测demo 该文件使用opencv官方的xml模型和权重文件进行检测
  • 人脸检测

    2016-07-14 14:10:05
    1.用OpenCV实现人脸检测  OpenCV2.4带有各种训练好的检测器,这些检测器以XML格式保存,可用于各种应用。下面列出一些 常用的检测器(名称):人脸检测器(默认)、人脸检测器(快速的Haar)、人脸检测器(快速的...
  • 人脸检测和识别的 .xml 文件haarcascade_frontalface_default.xml
  • 这篇博客将介绍一个**轻量级的人脸检测器——Haar级联人脸检测器**,并实现对图像进行检测和实时视频中进行人脸检测
  • opencv_face_detection opencv 人脸检测示例,稍作调整,并带有口部检测 xml
  • opencv人脸检测

    2017-08-22 16:14:54
    人脸检测人脸检测是指给定一张图片,判断图片中是否存在人脸,如果存在人脸,将人脸所在区域框出来。 opencv和dlib都自带了人脸检测模块,这一篇文章中,我们先来学习一下opencv自带的人脸检测器,基于adaboost...
  • 人脸识别之人脸检测

    2017-05-13 15:18:28
    人脸识别分为人脸检测、人脸预处理、搜集和学习人脸以及人脸识别四个部分,此部分将人脸检测。 本文基于opencv进行的。在opencv中常用的人脸检测器有基于LBP的特征检测、基于Haar的特征检测,两者的区别:前者比后...
  • 目录 1.Jetson Nano简介 2. Jetson Nano环境配置 2.1 开箱配件介绍 2.2 烧录系统 2.3 开机和基本设置 2.4 开发环境配置 2.4.1 更新源和软件 2.4.2 关屏时间设置 ...3.1 人脸检测 3.1.1 安装pip 3.1.2...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 9,067
精华内容 3,626
关键字:

xml人脸检测