关于opencv中人脸识别主函数的部分注释详解。

     近段时间在搞opencv的视频人脸识别，无奈自带的分类器的准确度，实在是不怎么样，但又能怎样呢？自己又研究不清楚各大类检测算法。

     正所谓，功能是由函数完成的，于是自己便看cvHaarDetectObjects 这个识别主函数的源代码，尝试了解并进行改造它，以提高精确度。

     可惜实力有限啊，里面的结构非常复杂，参杂着更多的函数体，有一些是网上找不到用法的，导致最终无法整体了解，只搞了一般，这里分享

下我自己总结的注释。

---

CvSeq* cvHaarDetectObjects( const CvArr* _img,//传入图像
                     CvHaarClassifierCascade* cascade, //传入xml路径
                     CvMemStorage* storage,//传入内存容器
                     double scaleFactor,//传入缩放值
                     int minNeighbors, 
                     int flags,
                     CvSize minSize, 
                     CvSize maxSize ){

    std::vector<int> fakeLevels;//int 类型的容器
    std::vector<double> fakeWeights;//double
    return cvHaarDetectObjectsForROC( _img, cascade, storage, fakeLevels, fakeWeights,
                                scaleFactor, minNeighbors, flags, minSize, maxSize, false );//进入这个参数
    //执行目标检测，这个函数
}

CvSeq* cvHaarDetectObjectsForROC(const CvArr* _img,
     CvHaarClassifierCascade* cascade,
     CvMemStorage* storage,
     std::vector<int>& rejectLevels, 
     std::vector<double>& levelWeights,
     double scaleFactor,
     int minNeighbors, 
     int flags,
     CvSize minSize, 
     CvSize maxSize,
     bool outputRejectLevels ){

    const double GROUP_EPS = 0.2;//定义一个double常数据
    CvMat stub, *img = (CvMat*)_img;//定义一个矩阵stub和把传入的图片转化为矩阵
    cv::Ptr<CvMat> temp, sum, tilted, sqsum, normImg, sumcanny, imgSmall;//定义矩阵类
    CvSeq* result_seq = 0;//定义最终返回的指针数据变量
    cv::Ptr<CvMemStorage> temp_storage;//内存类的定义

    std::vector<cv::Rect> allCandidates;//矩形类
    std::vector<cv::Rect> rectList;//矩形类
    std::vector<int> rweights;//int 容器
    double factor;
    int coi;
    bool doCannyPruning = (flags & CV_HAAR_DO_CANNY_PRUNING) != 0;//这三个都是判断传入的flags是什么类型，这个是做canny边缘处理
    bool findBiggestObject = (flags & CV_HAAR_FIND_BIGGEST_OBJECT) != 0;
    bool roughSearch = (flags & CV_HAAR_DO_ROUGH_SEARCH) != 0;
    //CV_HAAR_DO_CANNY_PRUNING利用Canny边缘检测器来排除一些边缘很少或者很多的图像区域
    //CV_HAAR_SCALE_IMAGE  按比例正常检测
    //CV_HAAR_FIND_BIGGEST_OBJECT只检测最大的物体
    //CV_HAAR_DO_ROUGH_SEARCH只做初略检测

    cv::Mutex mtx;//定义互斥锁，确保线程唯一

    if( !CV_IS_HAAR_CLASSIFIER(cascade) )
        CV_Error( !cascade ? CV_StsNullPtr : CV_StsBadArg, "Invalid classifier cascade" );//无效的级联分类器，输出

    if( !storage )
        CV_Error( CV_StsNullPtr, "Null storage pointer" );//内存为空

    img = cvGetMat( img, &stub, &coi );//IplImage 到cvMat 的转换
    if( coi )
        CV_Error( CV_BadCOI, "COI is not supported" );

    if( CV_MAT_DEPTH(img->type) != CV_8U )//对图像的深度判断
        CV_Error( CV_StsUnsupportedFormat, "Only 8-bit images are supported" );

    if( scaleFactor <= 1 )//对缩放值的判断
        CV_Error( CV_StsOutOfRange, "scale factor must be > 1" );

    if( findBiggestObject )
        flags &= ~CV_HAAR_SCALE_IMAGE;

    if( maxSize.height == 0 || maxSize.width == 0 )//判断，如果传进来的检测窗口的尺寸，如果有一个为0，下面赋值为矩阵的行数和列数
    {
        maxSize.height = img->rows;
        maxSize.width = img->cols;
    }

    temp = cvCreateMat( img->rows, img->cols, CV_8UC1 );//中间值矩阵模板初始化
    sum = cvCreateMat( img->rows + 1, img->cols + 1, CV_32SC1 );//积分图求和的结果矩阵模板
    sqsum = cvCreateMat( img->rows + 1, img->cols + 1, CV_64FC1 );////积分图求和的平方的结果

    if( !cascade->hid_cascade )
        icvCreateHidHaarClassifierCascade(cascade);//创建分类器，填写 casecade 中相关的头信息，如有多少个 stage,  每个 stage 下有多少个 tree ，每个 tree 下有多少个 node ，以及相关的阈值等信息

    if( cascade->hid_cascade->has_tilted_features )
        tilted = cvCreateMat( img->rows + 1, img->cols + 1, CV_32SC1 );//创建用于存放积分图求和并倾斜45度的检测结果矩阵

    result_seq = cvCreateSeq( 0, sizeof(CvSeq), sizeof(CvAvgComp), storage );//初始化最总返回结果变量

    if( CV_MAT_CN(img->type) > 1 )//如果由传入的图片转化为的矩阵的数据类型是比32位浮点高为真，进入if语句
    {
        cvCvtColor( img, temp, CV_BGR2GRAY );//灰度转化，此时temp指针式灰度数据的
        img = temp;//把值给会img，temp只起到一个中间保存的作用
    }

    if( findBiggestObject )//是否只检测最大的物体，是，则进入if语句
        flags &= ~(CV_HAAR_SCALE_IMAGE|CV_HAAR_DO_CANNY_PRUNING);

    if( flags & CV_HAAR_SCALE_IMAGE )//按比例正常检测，&是位运算 1|1=1,
    {
        CvSize winSize0 = cascade->orig_window_size;//获取检测窗口的大小，由分类器返回

        //下面是定义块，如果有定义HAVE_IPP,那么进入下面的数据赋值
        //但是在CvHaarClassifierCascade结构体里面的CvHidHaarClassifierCascade是空的
#ifdef HAVE_IPP    
        int use_ipp = cascade->hid_cascade->ipp_stages != 0;
        if( use_ipp )
            normImg = cvCreateMat( img->rows, img->cols, CV_32FC1 );
#endif

        imgSmall = cvCreateMat( img->rows + 1, img->cols + 1, CV_8UC1 );//创建新矩阵

        for( factor = 1; ; factor *= scaleFactor )//无循环条件的死循环
        {
            //定义3个矩形 大小
            //经输出测试过，矩阵的width和cols是一样大
            //我们假设上面的 winSize0 的 width，height都是10，factor循环到4，那么winSize的width和height都是40
            //我们再假设img的width和height都是10，sz的就变为2.5
            //sz1的就变为负的了，下面直接跳出循环，所以一般图片的w和h都比检测的窗口size要大得多
            //重新假设他们都是100，那么sz就是25，sz1就是16
            //此时改factor为5，sz为20，sz1为20-10+1=11
            //由此可知，随着factor的增大，sz1的双值减小，由于factor *= scaleFactor的，且scaleFactor比1大，所以
            //sz1必递减
            //综上述，检测窗口win会越来越大，sz类窗口会越来越小
            CvSize winSize = { cvRound(winSize0.width*factor), cvRound(winSize0.height*factor) };
            CvSize sz = { cvRound( img->cols/factor ), cvRound( img->rows/factor ) };
            CvSize sz1 = { sz.width - winSize0.width + 1, sz.height - winSize0.height + 1 };

            //定义矩形框,icv_object_win_border，这个东西，找遍没找到

            CvRect equRect = { icv_object_win_border, icv_object_win_border,
                winSize0.width - icv_object_win_border*2,
                winSize0.height - icv_object_win_border*2 };

            CvMat img1, sum1, sqsum1, norm1, tilted1, mask1;
            CvMat* _tilted = 0;

            if( sz1.width <= 0 || sz1.height <= 0 )//当sz1窗口大小为负的时候，循环结束。
                break;
            if( winSize.width > maxSize.width || winSize.height > maxSize.height )//当检测窗口过大，也跳出循环
                break;
            if( winSize.width < minSize.width || winSize.height < minSize.height )//过小，也跳出，不过它是继续循环
                continue;

            //在还没跳出循环的情况下，下面分别以sz的宽和高创建矩阵
            img1 = cvMat( sz.height, sz.width, CV_8UC1, imgSmall->data.ptr );
            sum1 = cvMat( sz.height+1, sz.width+1, CV_32SC1, sum->data.ptr );
            sqsum1 = cvMat( sz.height+1, sz.width+1, CV_64FC1, sqsum->data.ptr );
            if( tilted )//这个是矩阵类
            {
                tilted1 = cvMat( sz.height+1, sz.width+1, CV_32SC1, tilted->data.ptr );//一样是初始化
                _tilted = &tilted1;
            }

            //这下面的是以sz1为基础初始化的矩阵
            norm1 = cvMat( sz1.height, sz1.width, CV_32FC1, normImg ? normImg->data.ptr : 0 );
            mask1 = cvMat( sz1.height, sz1.width, CV_8UC1, temp->data.ptr );

            cvResize( img, &img1, CV_INTER_LINEAR );//双线性插值，重新调整img的大小，相关数据存入img1
            cvIntegral( &img1, &sum1, &sqsum1, _tilted );//由img1开始积分计算，存入sum1、sqsum1、tilted

            int ystep = factor > 2 ? 1 : 2;//这里判断了下factor的大小，大于2，ystep就是1
            const int LOCS_PER_THREAD = 1000;
            //接着上面的假设，factor是4，那么此时的yster是1
            //stripCount就是（11/1 * 11/1+1000/2）/1000 < 1
            int stripCount = ((sz1.width/ystep)*(sz1.height + ystep-1)/ystep + LOCS_PER_THREAD/2)/LOCS_PER_THREAD;
            stripCount = std::min(std::max(stripCount, 1), 100);
            //然后和1对比，找出最大值，再和100比较，找出最小

#ifdef HAVE_IPP
            if( use_ipp )
            {
                cv::Mat fsum(sum1.rows, sum1.cols, CV_32F, sum1.data.ptr, sum1.step);
                cv::Mat(&sum1).convertTo(fsum, CV_32F, 1, -(1<<24));
            }
            else
#endif
            cvSetImagesForHaarClassifierCascade( cascade, &sum1, &sqsum1, _tilted, 1. );
            //上面这个函数是为隐藏的cascade(hidden cascade)指定图像积分图像、平方和图像与倾斜和图像、特征矩形，然后让它检测
            //sum1是上面生成的32bt积分图像，sqsum 单通道64比特图像的平方和图像 
            //tilted 单通道32比特整数格式的图像的倾斜和
            //1是窗口比例，如果 scale=1, 就只用原始窗口尺寸检测 (只检测同样尺寸大小的目标物体) 
            //- 原始窗口尺寸在函数cvLoadHaarClassifierCascade中定义 (在 "<default_face_cascade>"中缺省为24x24), 
            //如果scale=2, 使用的窗口是上面的两倍 (在face cascade中缺省值是48x48 )。
            //这样尽管可以将检测速度提高四倍，但同时尺寸小于48x48的人脸将不能被检测到
            cv::Mat _norm1(&norm1), _mask1(&mask1);

            //HaarDetectObjects_ScaleImage_Invoker进行并行运算（可以返回rejectLevels和levelWeights）
            cv::parallel_for_(cv::Range(0, stripCount),
                         cv::HaarDetectObjects_ScaleImage_Invoker(cascade,
                                (((sz1.height + stripCount - 1)/stripCount + ystep-1)/ystep)*ystep,
                                factor, cv::Mat(&sum1), cv::Mat(&sqsum1), &_norm1, &_mask1,
                                cv::Rect(equRect), allCandidates, rejectLevels, levelWeights, outputRejectLevels, &mtx));
        }
    }
    else
    {
        int n_factors = 0;
        cv::Rect scanROI;

        cvIntegral( img, sum, sqsum, tilted );//由img1开始积分计算，存入sum1、sqsum1、tilted

        if( doCannyPruning )//边缘处理
        {
            sumcanny = cvCreateMat( img->rows + 1, img->cols + 1, CV_32SC1 );
            cvCanny( img, temp, 0, 50, 3 );//得到边缘图像
            cvIntegral( temp, sumcanny );//再次积分
        }

        for( n_factors = 0, factor = 1;
             factor*cascade->orig_window_size.width < img->cols - 10 &&
             factor*cascade->orig_window_size.height < img->rows - 10;
             n_factors++, factor *= scaleFactor )
            ;

        if( findBiggestObject )
        {
            scaleFactor = 1./scaleFactor;
            factor *= scaleFactor;
        }
        else
            factor = 1;

        for( ; n_factors-- > 0; factor *= scaleFactor )
        {
            const double ystep = std::max( 2., factor );
            CvSize winSize = { cvRound( cascade->orig_window_size.width * factor ),
                                cvRound( cascade->orig_window_size.height * factor )};
            CvRect equRect = { 0, 0, 0, 0 };
            int *p[4] = {0,0,0,0};
            int *pq[4] = {0,0,0,0};
            int startX = 0, startY = 0;
            int endX = cvRound((img->cols - winSize.width) / ystep);
            int endY = cvRound((img->rows - winSize.height) / ystep);

            if( winSize.width < minSize.width || winSize.height < minSize.height )
            {
                if( findBiggestObject )
                    break;
                continue;
            }

            if ( winSize.width > maxSize.width || winSize.height > maxSize.height )
            {
                if( !findBiggestObject )
                    break;
                continue;
            }

            cvSetImagesForHaarClassifierCascade( cascade, sum, sqsum, tilted, factor );
            cvZero( temp );

            if( doCannyPruning )
            {
                equRect.x = cvRound(winSize.width*0.15);
                equRect.y = cvRound(winSize.height*0.15);
                equRect.width = cvRound(winSize.width*0.7);
                equRect.height = cvRound(winSize.height*0.7);

                p[0] = (int*)(sumcanny->data.ptr + equRect.y*sumcanny->step) + equRect.x;
                p[1] = (int*)(sumcanny->data.ptr + equRect.y*sumcanny->step)
                            + equRect.x + equRect.width;
                p[2] = (int*)(sumcanny->data.ptr + (equRect.y + equRect.height)*sumcanny->step) + equRect.x;
                p[3] = (int*)(sumcanny->data.ptr + (equRect.y + equRect.height)*sumcanny->step)
                            + equRect.x + equRect.width;

                pq[0] = (int*)(sum->data.ptr + equRect.y*sum->step) + equRect.x;
                pq[1] = (int*)(sum->data.ptr + equRect.y*sum->step)
                            + equRect.x + equRect.width;
                pq[2] = (int*)(sum->data.ptr + (equRect.y + equRect.height)*sum->step) + equRect.x;
                pq[3] = (int*)(sum->data.ptr + (equRect.y + equRect.height)*sum->step)
                            + equRect.x + equRect.width;
            }

            if( scanROI.area() > 0 )
            {
                //adjust start_height and stop_height
                startY = cvRound(scanROI.y / ystep);
                endY = cvRound((scanROI.y + scanROI.height - winSize.height) / ystep);

                startX = cvRound(scanROI.x / ystep);
                endX = cvRound((scanROI.x + scanROI.width - winSize.width) / ystep);
            }

            cv::parallel_for_(cv::Range(startY, endY),
                cv::HaarDetectObjects_ScaleCascade_Invoker(cascade, winSize, cv::Range(startX, endX),
                                                           ystep, sum->step, (const int**)p,
                                                           (const int**)pq, allCandidates, &mtx ));

            if( findBiggestObject && !allCandidates.empty() && scanROI.area() == 0 )
            {
                rectList.resize(allCandidates.size());
                std::copy(allCandidates.begin(), allCandidates.end(), rectList.begin());

                groupRectangles(rectList, std::max(minNeighbors, 1), GROUP_EPS);

                if( !rectList.empty() )
                {
                    size_t i, sz = rectList.size();
                    cv::Rect maxRect;

                    for( i = 0; i < sz; i++ )
                    {
                        if( rectList[i].area() > maxRect.area() )
                            maxRect = rectList[i];
                    }

                    allCandidates.push_back(maxRect);

                    scanROI = maxRect;
                    int dx = cvRound(maxRect.width*GROUP_EPS);
                    int dy = cvRound(maxRect.height*GROUP_EPS);
                    scanROI.x = std::max(scanROI.x - dx, 0);
                    scanROI.y = std::max(scanROI.y - dy, 0);
                    scanROI.width = std::min(scanROI.width + dx*2, img->cols-1-scanROI.x);
                    scanROI.height = std::min(scanROI.height + dy*2, img->rows-1-scanROI.y);

                    double minScale = roughSearch ? 0.6 : 0.4;
                    minSize.width = cvRound(maxRect.width*minScale);
                    minSize.height = cvRound(maxRect.height*minScale);
                }
            }
        }
    }

    //上面的循环结束后，进入到这里
    rectList.resize(allCandidates.size());
    if(!allCandidates.empty())
        std::copy(allCandidates.begin(), allCandidates.end(), rectList.begin());

    if( minNeighbors != 0 || findBiggestObject )
    {
        if( outputRejectLevels )
        {
            groupRectangles(rectList, rejectLevels, levelWeights, minNeighbors, GROUP_EPS );
        }
        else
        {
            groupRectangles(rectList, rweights, std::max(minNeighbors, 1), GROUP_EPS);
        }
    }
    else
        rweights.resize(rectList.size(),0);

    if( findBiggestObject && rectList.size() )
    {
        CvAvgComp result_comp = {{0,0,0,0},0};

        for( size_t i = 0; i < rectList.size(); i++ )
        {
            cv::Rect r = rectList[i];
            if( r.area() > cv::Rect(result_comp.rect).area() )
            {
                result_comp.rect = r;
                result_comp.neighbors = rweights[i];
            }
        }
        cvSeqPush( result_seq, &result_comp );
    }
    else
    {
        for( size_t i = 0; i < rectList.size(); i++ )
        {
            CvAvgComp c;
            c.rect = rectList[i];
            c.neighbors = !rweights.empty() ? rweights[i] : 0;
            cvSeqPush( result_seq, &c );
        }
    }

    return result_seq;
}

---

      正在看本人博客的这位童鞋，我看你气度不凡，谈吐间隐隐有王者之气，日后必有一番作为！旁边有“推荐”二字，你就顺手把它点了吧，相得准，我分文不收；相不准，你也好回来找我。