基于深度学习的人脸识别系统（Caffe+OpenCV+Dlib）【二】人脸预处理

其他 2018-08-30 11:43:37 阅读次数: 0
版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/Mr_Curry/article/details/52448931

前言

基于深度学习的人脸识别系统，一共用到了5个开源库：OpenCV（计算机视觉库）、Caffe（深度学习库）、Dlib（机器学习库）、libfacedetection（人脸检测库）、cudnn（gpu加速库）。
用到了一个开源的深度学习模型：VGG model。
最终的效果是很赞的，识别一张人脸的速度是0.039秒，而且最重要的是：精度高啊！！！
CPU：intel i5-4590
GPU：GTX 980
系统：Win 10
OpenCV版本：3.1（这个无所谓）
Caffe版本：Microsoft caffe （微软编译的Caffe，安装方便，在这里安利一波）
Dlib版本：19.0（也无所谓
CUDA版本：7.5
cudnn版本：4
libfacedetection：6月份之后的（这个有所谓，6月后出了64位版本的）
这个系列纯C++构成，有问题的各位朋同学可以直接在博客下留言，我们互相交流学习。
====================================================================

本篇是该系列的第二篇博客，介绍我如何设计人脸检测与预处理的接口。

思路

人脸检测与预处理作为人脸识别的步骤之一，其质量能够直接影响识别的精度。而如何在保持精度的条件下最大化运行速度也是需要注意的地方。这里我们不使用OpenCV自带的分类器，而使用一个开源的windows平台下的人脸检测库。具体可以看我的这篇博客：
http://blog.csdn.net/mr_curry/article/details/51804072
那么首先，我们先需要检测出人脸。新建FaceDetect.h，FaceRotate.h，FaceProcessing.h，一个FaceDetect.cpp，FaceProcessing.cpp开始编写。（这里假定你已经添加好dlib的属性表了）
注：下面的人脸预处理函数，是IEEE数据库上的一篇论文所述的方法，2011年的
FaceDetect.h：（提供一个总的接口）

#include "facedetect-dll.h"
#include <opencv.hpp>
using namespace cv;
// define 
Mat Facedetect(Mat frame);
//dlib的配置函数 后面几章会讲
void Dlib_Prodefine();

FaceRotate.h：（用于关键点矫正）

#include <dlib/image_processing/frontal_face_detector.h>
#include <dlib/image_processing/render_face_detections.h>
#include <dlib/image_processing.h>
#include <dlib/gui_widgets.h>
#include <dlib/image_io.h>
#include<dlib/opencv/cv_image.h>
#include <dlib/opencv.h>

using namespace dlib;

frontal_face_detector detector = get_frontal_face_detector();
shape_predictor sp;//Already get

FaceProcessing.h：（用于对人脸进行预处理）

#include <opencv2/opencv.hpp>

using namespace std;
using namespace cv;
Mat FaceProcessing(const Mat &img_, double gamma = 0.2, double sigma0 = 1, double sigma1 = -2, double mask = 0, double do_norm = 10);

FaceProcessing.cpp：

#include"FaceProcessing.h"

int gauss(float x[], float y[], int length, float sigma);
Mat gaussianfilter(Mat img, double sigma0, double sigma1, double shift1, double shift2);
Mat FaceProcessing(const Mat &img_, double gamma = 0.2, double sigma0 = 1, double sigma1 = -2, double mask = 0, double do_norm = 10);

//找出矩阵中的最大值或最小值，输入MAX，或MIN
double MatMaxMin(Mat im, String flag = "MAX")
{
    double value = im.ptr<float>(0)[0];
    if (flag == "MAX")
    {
        for (int i = 0; i<im.rows; i++)
            for (int j = 0; j<im.cols; j++)
                if (im.ptr<float>(i)[j]>value)
                    value = im.ptr<float>(i)[j];
        return value;
    }
    else if (flag == "MIN")
    {
        for (int i = 0; i<im.rows; i++)
            for (int j = 0; j<im.cols; j++)
                if (im.ptr<float>(i)[j]<value)
                    value = im.ptr<float>(i)[j];
        return value;
    }
    return -1;
}
//高斯滤波
Mat gaussianfilter(Mat img, double sigma0, double sigma1, double shift1 = 0, double shift2 = 0)
{
    int i, j;
    sigma0 = (float)sigma0;
    sigma1 = (float)sigma1;
    shift1 = (float)shift1;
    shift2 = (float)shift2;
    Mat img2 = img;
    Mat img3 = img;
    Mat  imgResult;

    //将数据存入横向高斯模板中
    int rowLength = (int)(floor(3.0*sigma0 + 0.5 - shift1) - ceil(-3.0*sigma0 - 0.5 - shift1) + 1);
    int rowBegin = (int)ceil(-3.0*sigma0 - 0.5 - shift1);
    float rowArray[30], Gx[30];
    for (i = 0; i < rowLength; i++)
    {
        rowArray[i] = rowBegin + i;
    }
    gauss(rowArray, Gx, rowLength, sigma0);
    Mat kx = Mat(1, rowLength, CV_32F); //转换成mat类型
    float *pData1 = kx.ptr<float>(0);
    for (i = 0; i < rowLength; i++)
    {
        pData1[i] = Gx[i];
    }
    //将数据存入纵向高斯模板中
    int colLength = (int)(floor(3.0*sigma1 + 0.5 - shift2) - ceil(-3.0*sigma1 - 0.5 - shift2) + 1);
    int colBegin = (int)ceil(-3.0*sigma1 - 0.5 - shift2);
    float colArray[30], Gy[30];
    for (i = 0; i<colLength; i++)
    {
        colArray[i] = colBegin + i;
    }
    gauss(colArray, Gy, colLength, sigma1);
    Mat ky = Mat(colLength, 1, CV_32F);
    float *pData2;
    for (i = 0; i < colLength; i++)
    {
        pData2 = ky.ptr<float>(i);
        pData2[0] = Gy[i];
    }
    filter2D(img, img2, img.depth(), kx, Point(-1, -1));
    filter2D(img2, imgResult, img2.depth(), ky, Point(-1, -1));
    return imgResult;

}
//行列卷积
int gauss(float x[], float y[], int length, float sigma)
{
    int i;
    float sum = 0.0;
    for (i = 0; i<length; i++)
    {
        x[i] = exp(-pow(x[i], 2) / (2 * pow(sigma, 2)));
        sum += x[i];
    }
    for (i = 0; i<length; i++)
    {
        y[i] = x[i] / sum;
    }
    return 1;
}


Mat FaceProcessing(const Mat &img_, double gamma , double sigma0 , double sigma1, double mask , double do_norm)
{
    Mat img;
    img_.convertTo(img, CV_32F);
    Mat imT1, imT2;
    int rows = img.rows;
    int cols = img.cols;
    Mat im = img;
    int b = floor(3 * abs(sigma1));//左右扩充边缘的距离
    Mat imtemp(Size(cols + 2 * b, rows + 2 * b), CV_32F, Scalar(0));//保存扩充的图形
    Mat imtemp2(Size(cols, rows), CV_32F, Scalar(0));
    float s = 0.0;
    //Gamma correct input image to increase local contrast in shadowed regions.
    if (gamma == 0)
    {
        double impixeltemp = 0;
        double Max = MatMaxMin(im, "MAX");//等价于max(1,max(max(im)))
        for (int i = 0; i<rows; i++)
            for (int j = 0; j<cols; j++)
            {
                impixeltemp = log(im.ptr<float>(i)[j] + Max / 256);
                im.ptr<float>(i)[j] = impixeltemp;
            }
    }
    else
    {
        for (int i = 0; i<rows; i++)
            for (int j = 0; j<cols; j++)
                im.ptr<float>(i)[j] = pow(im.ptr<float>(i)[j], gamma);
    }
    float *pData1;
    //run prefilter, if any
    if (sigma1)
    {
        double border = 1;
        if (border) //add extend-as-constant image border to reduce 
            //boundary effects
        {
            for (int i = 0; i<rows + 2 * b - 1; i++)
            {
                pData1 = imtemp.ptr<float>(i);
                for (int j = 0; j<cols + 2 * b - 1; j++){
                    //中间
                    if (i >= b&&i<im.rows + b&&j >= b&&j<im.cols + b)
                        pData1[j] = im.ptr<float>(i - b)[j - b];
                    //左上
                    else if (i<b&&j<b)
                        pData1[j] = im.ptr<float>(0)[0];
                    //右上
                    else if (i<b&&j >= im.cols + b&&j<cols + 2 * b)
                        pData1[j] = im.ptr<float>(0)[cols - 1];
                    //左下
                    else if (i >= im.rows + b&&i<rows + 2 * b&&j<b)
                        pData1[j] = im.ptr<float>(rows - 1)[0];
                    //右下
                    else if (i >= im.rows + b&&j >= im.cols + b)
                        pData1[j] = im.ptr<float>(im.rows - 1)[im.cols - 1];
                    //上方
                    else if (i<b&&j >= b&&j<im.cols + b)
                        pData1[j] = im.ptr<float>(0)[j - b];
                    //下方
                    else if (i >= im.rows + b&&j >= b&&j<im.cols + b)
                        pData1[j] = im.ptr<float>(im.rows - 1)[j - b];
                    //左方
                    else if (j<b&&i >= b&&i<im.rows + b)
                        pData1[j] = im.ptr<float>(i - b)[0];
                    //右方
                    else if (j >= im.cols + b&&i >= b&&i<im.rows + b)
                        pData1[j] = im.ptr<float>(i - b)[im.cols - 1];/**/
                }
            }
        }

        else
        {
            if (sigma0>0)
            {
                imT1 = gaussianfilter(imtemp, sigma0, sigma0);
                imT2 = gaussianfilter(imtemp, -sigma1, -sigma1);
                imtemp = imT1 - imT2;
                //imtemp=gaussianfilter(imtemp,sigma0,sigma0)-gaussianfilter(imtemp,-sigma1,-sigma1);
            }
            else
                imtemp = imtemp - gaussianfilter(imtemp, -sigma1, -sigma1);
        }

        if (border)
        {
            //再取回中间部分
            for (int i = 0; i<rows; i++)
            {
                pData1 = im.ptr<float>(i);
                for (int j = 0; j<cols; j++)
                    pData1[j] = imtemp.ptr<float>(i + b)[j + b];
            }
        }
        //  test=im.ptr<float>(19)[19];
    }

    /*
    % Global contrast normalization. Normalizes the spread of output
    % values. The mean is near 0 so we don't bother to subtract
    % it. We use a trimmed robust scatter measure for resistance to
    % outliers such as specularities and image borders that have
    % different values from the main image.  Usually trim is about
    % 10.
    */

    if (do_norm)
    {
        double a = 0.1;
        double trim = abs(do_norm);

        //im = im./mean(mean(abs(im).^a))^(1/a);
        imtemp2 = abs(im);

        //cvPow(&im,&im,a)//为每个元素求pow
        for (int i = 0; i<rows; i++)
        {
            pData1 = imtemp2.ptr<float>(i);//imtemp2为零矩阵
            for (int j = 0; j<cols; j++)
                pData1[j] = pow(imtemp2.ptr<float>(i)[j], a);
        }

        //求平均值s
        s = 0.0;
        for (int i = 0; i<rows; i++)
        {
            pData1 = imtemp2.ptr<float>(i);
            for (int j = 0; j<cols; j++)
                s += imtemp2.ptr<float>(i)[j];
        }
        s /= (im.rows*im.cols);
        double temp = pow(s, 1 / a);
        for (int i = 0; i<rows; i++)
        {
            pData1 = im.ptr<float>(i);
            for (int j = 0; j<cols; j++)
                pData1[j] = pData1[j] / temp;//点除
        }

        //im = im./mean(mean(min(trim,abs(im)).^a))^(1/a);
        imtemp2 = abs(im);
        for (int i = 0; i<rows; i++)
        {
            pData1 = imtemp2.ptr<float>(i);
            for (int j = 0; j<cols; j++)
                if (pData1[j]>trim)
                    pData1[j] = trim;//min(trim,abs(im))
        }
        //cvPow(&im,&im,a);////为每个元素求pow
        for (int i = 0; i<rows; i++)
        {
            pData1 = imtemp2.ptr<float>(i);
            for (int j = 0; j<cols; j++)
                pData1[j] = pow(pData1[j], a);
        }
        //求平均值
        s = 0.0;
        for (int i = 0; i<rows; i++)
        {
            pData1 = imtemp2.ptr<float>(i);
            for (int j = 0; j<cols; j++)
                s += pData1[j];
        }
        s /= (im.rows*im.cols);
        temp = pow(s, 1 / a);//
        for (int i = 0; i<rows; i++)
        {
            pData1 = im.ptr<float>(i);
            for (int j = 0; j<cols; j++)
                pData1[j] = pData1[j] / temp;//点除
        }

        if (do_norm>0)
        {//im = trim*tanh(im/trim);
            for (int i = 0; i<rows; i++)
            {
                pData1 = im.ptr<float>(i);
                for (int j = 0; j<cols; j++)
                    pData1[j] = trim*tanh(pData1[j] / trim);
            }
        }

    }
    //归一化处理
    double Min;
    Min = MatMaxMin(im, "MIN");//找到矩阵的最小值
    for (int i = 0; i<rows; i++)
    {
        pData1 = im.ptr<float>(i);
        for (int j = 0; j<cols; j++)
            pData1[j] += Min;
    }
    //im.convertTo(im, CV_32F, 1.0/255.0);

    normalize(im, im, 0, 255, NORM_MINMAX);
    //normalize(im,im,0,255,NORM_MINMAX);
    /*  for(int i=0;i<rows;i++)
    {
    pData1=im.ptr<float>(i);
    for(int j=0;j<cols;j++)
    pData1[j]*=255;
    }*/
    im.convertTo(im, CV_8UC1);
    return im;
}

FaceDetect.cpp：

#include <FaceDetect.h>
#include <FaceRotate.h>
#include <FaceProcessing.h>
void Dlib_Prodefine()
{
    deserialize("shape_predictor_68_face_landmarks.dat") >> sp;//读入标记点文件
}
Mat Facedetect(Mat frame)//脸是否存在
{
    Mat gray,error;
    cvtColor(frame, gray, CV_BGR2GRAY);
    int * pResults = NULL;
    pResults = facedetect_frontal_tmp((unsigned char*)(gray.ptr(0)), gray.cols, gray.rows, gray.step, 1.2f, 5, 24);
    int peopleNUM = (pResults ? *pResults : 0);

    for (int i = 0; i < peopleNUM; i++)//代表有几张人脸(pResults ? *pResults : 0)
    {
        short * p = ((short*)(pResults + 1)) + 6 * i;
        Rect opencvRect(p[0], p[1], p[2], p[3]);
        //gray = gray(opencvRect);
        dlib::rectangle dlibRect((long)opencvRect.tl().x, (long)opencvRect.tl().y, (long)opencvRect.br().x - 1, (long)opencvRect.br().y - 1);
        dlib::full_object_detection shape = sp(dlib::cv_image<uchar>(gray), dlibRect);//标记点
        std::vector<full_object_detection> shapes;
        shapes.push_back(shape);//把点保存在了shape中
        dlib::array<array2d<rgb_pixel>>  face_chips;
        extract_image_chips(dlib::cv_image<uchar>(gray), get_face_chip_details(shapes), face_chips);
        Mat pic = toMat(face_chips[0]);
        cvtColor(pic, pic, CV_BGR2GRAY);
        resize(pic, pic, Size(224, 224));
        return FaceProcessing(pic);
    }
    return error;//如果没有检测出人脸 将返回一个空矩阵
}

在上述代码中，关于dlib的array2d< rgb_pixel >类型与Mat类型的转换可以在这里进行体现：

dlib::array<array2d<rgb_pixel>>  face_chips;
        extract_image_chips(dlib::cv_image<uchar>(gray), get_face_chip_details(shapes), face_chips);
        Mat pic = toMat(face_chips[0]);

其中face_chips[0]即为一个array2d< rgb_pixel >的类型，可以通过toMat函数进行转换。
将Mat类型转换为array2d< rgb_pixel >则可以用：

Mat gray;
dlib::cv_image<uchar>(gray);

在这个地方，我们特别需要注意，还要转换一次灰度：

cvtColor(pic, pic, CV_BGR2GRAY);
        resize(pic, pic, Size(224, 224));
        return FaceProcessing(pic);

为什么？因为在测试过程中我发现，dlib函数中的toMat函数返回的不是CV_BGR2GRAY（OpenCV中的灰度图像类型），如果这里你不加，那么这个预处理将会只卷积左半部分脸。
我们可以看看识别的效果。调用FaceDetect()函数接口：

Dlib_Prodefine();
    //Caffe_Prodefine();
    Mat lena = imread("lena.jpg");
    imshow("Face Detect", Facedetect(lena));
    waitKey(0);

当然，这个地方，在进行检测之前，我们最好还是先判断FaceDetect(lena)是否为空，再进行Imshow.
检测与处理图片效果显示：
这里写图片描述
为什么要把图片最后转换为224*224的尺寸？因为：Vgg网络模型接收的就是224*224的尺寸，后面还会讲这个东西。

猜你喜欢

转载自blog.csdn.net/Mr_Curry/article/details/52448931
今日推荐
《美国对全球网络空间安全与发展的威胁和破坏》报告发布
火速冲上 GitHub 热榜 —— 开源编程语言、框架哪有这么可爱？
北京人形机器人创新中心发布全球首个纯电驱拟人奔跑的全尺寸人形机器人“天工”
LFOSSA 源来如此公开课 | 掌握云原生未来：CNCF 认证全面攻略与备考秘籍
国产云输入法——仅华为无云端数据上传安全问题
周排行
Python环境安装与基础语法（1）——计算机基础知识
IMU预积分
ADAS中的LDW、FCW、BSD、LCA、ACC、AEB、APA、DMS代表的含义
B站笔试两道题
skyeye arm 硬件虚拟机环境的搭建
Web前端静态页面示例
数组-合并排序数组 II-简单
springcloud之版本问题启动报错
面向对象-------------匿名对象(六)
输入URL到页面呈现中间发生了什么？
每日归档
更多
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)
2024-04-27(56)
2024-04-26(39)
2024-04-25(22)
2024-04-24(36)
2024-04-23(26)
2024-04-22(39)
2024-04-21(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022