devbox
weixin_40725706
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

OpenCV 2.4.9源码分析（一）：detectMultiScale_detectmultiscale 多线程

作者：weixin_40725706 | 2024-06-18 04:51:37

赞

踩

detectmultiscale 多线程

OpenCV使用级联分类器做人脸识别的时候，调用了void CascadeClassifier::detectMultiScale方法，采用的滑窗机制，这里列出该函数的源码实现过程。

代码读起来不复杂，但是很有趣^_^。

  1. void CascadeClassifier::detectMultiScale( const Mat& image, vector<Rect>& objects,
  2.                                           double scaleFactor, int minNeighbors,
  3.                                           int flags, Size minObjectSize, Size maxObjectSize)
  4. {
  5.     vector<int> fakeLevels;	// 检测未通过层的级数
  6.     vector<double> fakeWeights;	// 未通过层的强分类器的输出, 不使用时outputRejectLevels = false;
  7.     detectMultiScale( image, objects, fakeLevels, fakeWeights, scaleFactor,
  8.         minNeighbors, flags, minObjectSize, maxObjectSize, false );
  9. }
  1. void CascadeClassifier::detectMultiScale( const Mat& image, vector<Rect>& objects,
  2.                                           vector<int>& rejectLevels,
  3.                                           vector<double>& levelWeights,
  4.                                           double scaleFactor, int minNeighbors,
  5.                                           int flags, Size minObjectSize, Size maxObjectSize,
  6.                                           bool outputRejectLevels )
  7. {
  8.     const double GROUP_EPS = 0.2;
  9.  
  10.     CV_Assert( scaleFactor > 1 && image.depth() == CV_8U );	// comment@2018.04.08  scaleFactor大于1且图像是8位的。
  11.  
  12.     if( empty() )
  13.         return;
  14.  
  15.     if( isOldFormatCascade() )
  16.     {
  17.         MemStorage storage(cvCreateMemStorage(0));
  18.         CvMat _image = image;
  19.         CvSeq* _objects = cvHaarDetectObjectsForROC( &_image, oldCascade, storage, rejectLevels, levelWeights, scaleFactor,
  20.                                               minNeighbors, flags, minObjectSize, maxObjectSize, outputRejectLevels );
  21.         vector<CvAvgComp> vecAvgComp;
  22.         Seq<CvAvgComp>(_objects).copyTo(vecAvgComp);
  23.         objects.resize(vecAvgComp.size());
  24.         std::transform(vecAvgComp.begin(), vecAvgComp.end(), objects.begin(), getRect());
  25.         return;
  26.     }
  27.  
  28.     objects.clear();	// 清空存放检测结果的容器
  29.  
  30.     if (!maskGenerator.empty()) {	//
  31.         maskGenerator->initializeMask(image);
  32.     }
  33.  
  34.  
  35.     if( maxObjectSize.height == 0 || maxObjectSize.width == 0 )
  36.         maxObjectSize = image.size();	// 默认检测目标最大为图像本身大小
  37.  
  38.     Mat grayImage = image;
  39.     if( grayImage.channels() > 1 )	// 通道数大于1,则转成灰度图
  40.     {
  41.         Mat temp;
  42.         cvtColor(grayImage, temp, CV_BGR2GRAY);
  43.         grayImage = temp;
  44.     }
  45.  
  46.     Mat imageBuffer(image.rows + 1, image.cols + 1, CV_8U);  // comment@2018.04.08 多加一行一列
  47.     vector<Rect> candidates;	// 存放候选 rect
  48.  
  49. 	// 多尺度，每次放大scaleFactor倍
  50.     for( double factor = 1; ; factor *= scaleFactor )
  51.     {
  52.     	// 分类器训练的时候的图像大小
  53.         Size originalWindowSize = getOriginalWindowSize();  // <height>20</height> <width>20</width> xml文件中的首两行即为训练的目标窗口大小
  54.  
  55. 		// 每次放大sacleFactor倍
  56.         Size windowSize( cvRound(originalWindowSize.width*factor), cvRound(originalWindowSize.height*factor) );
  57.  
  58. 		// 原图一次缩小
  59.         Size scaledImageSize( cvRound( grayImage.cols/factor ), cvRound( grayImage.rows/factor ) );
  60.  
  61. 		// 可供原始窗口移动的范围大小
  62.         Size processingRectSize( scaledImageSize.width - originalWindowSize.width, scaledImageSize.height - originalWindowSize.height );
  63.  
  64. 		// 检测窗口可以动区域小于0，表明图像比originalWindowSize还小，然后退出
  65.         if( processingRectSize.width <= 0 || processingRectSize.height <= 0 )
  66.             break;
  67.  
  68. 		// 窗口大于最大检测目标时，退出；默认是输入图像大小
  69.         if( windowSize.width > maxObjectSize.width || windowSize.height > maxObjectSize.height )
  70.             break;
  71.  
  72. 		// 窗口小于最小检测目标，跳过
  73.         if( windowSize.width < minObjectSize.width || windowSize.height < minObjectSize.height )
  74.             continue;
  75.  
  76. 		// 拷贝数据
  77.         Mat scaledImage( scaledImageSize, CV_8U, imageBuffer.data );
  78.         resize( grayImage, scaledImage, scaledImageSize, 0, 0, CV_INTER_LINEAR );
  79.  
  80. 		// y步长
  81.         int yStep;
  82.         if( getFeatureType() == cv::FeatureEvaluator::HOG )
  83.         {
  84.             yStep = 4;			// HOG特征，步长设为 4
  85.         }
  86.         else
  87.         {
  88.             yStep = factor > 2. ? 1 : 2;	// 缩放因子大于2时，步长为1，否则为2
  89.         }
  90.  
  91.         int stripCount, stripSize;	// 并行计算个数及大小，分行并行计算
  92.  
  93.         const int PTS_PER_THREAD = 1000;	// 预订时间标准系统
  94.         stripCount = ((processingRectSize.width/yStep)*(processingRectSize.height + yStep-1)/yStep + PTS_PER_THREAD/2)/PTS_PER_THREAD;
  95.         stripCount = std::min(std::max(stripCount, 1), 100);
  96.         stripSize = (((processingRectSize.height + stripCount - 1)/stripCount + yStep-1)/yStep)*yStep;
  97.  
  98. 		// 调用但尺度检测函数
  99.         if( !detectSingleScale( scaledImage, stripCount, processingRectSize, stripSize, yStep, factor, candidates,
  100.             rejectLevels, levelWeights, outputRejectLevels ) )
  101.             break;
  102.     }
  103.  
  104.  
  105.     objects.resize(candidates.size());
  106.     std::copy(candidates.begin(), candidates.end(), objects.begin());
  107.  
  108.     if( outputRejectLevels )
  109.     {
  110.         groupRectangles( objects, rejectLevels, levelWeights, minNeighbors, GROUP_EPS );
  111.     }
  112.     else
  113.     {
  114.         groupRectangles( objects, minNeighbors, GROUP_EPS );	// 合并检测结果
  115.     }
  116. }
  1. bool CascadeClassifier::detectSingleScale( const Mat& image, int stripCount, Size processingRectSize,
  2.                                            int stripSize, int yStep, double factor, vector<Rect>& candidates,
  3.                                            vector<int>& levels, vector<double>& weights, bool outputRejectLevels )
  4. {
  5. 	/*
  6. 		getOriginalWindowSize --> data.origWinSize (width=20, height=20)
  7. 	*/
  8.     if( !featureEvaluator->setImage( image, data.origWinSize ) )	// 对图像做积分图
  9.         return false;
  10.  
  11. #if defined (LOG_CASCADE_STATISTIC)
  12.     logger.setImage(image);
  13. #endif
  14.  
  15.     Mat currentMask;
  16.     if (!maskGenerator.empty()) {
  17.         currentMask=maskGenerator->generateMask(image);
  18.     }
  19.  
  20.     vector<Rect> candidatesVector;
  21.     vector<int> rejectLevels;
  22.     vector<double> levelWeights;
  23.     Mutex mtx;
  24.     if( outputRejectLevels )	// outputRejectLevels = false
  25.     {
  26.         parallel_for_(Range(0, stripCount), CascadeClassifierInvoker( *this, processingRectSize, stripSize, yStep, factor,
  27.             candidatesVector, rejectLevels, levelWeights, true, currentMask, &mtx));
  28.         levels.insert( levels.end(), rejectLevels.begin(), rejectLevels.end() );
  29.         weights.insert( weights.end(), levelWeights.begin(), levelWeights.end() );
  30.     }
  31.     else
  32.     {
  33.     	// parallel_for_ 为了TBB加速时使用
  34.     	// 生成stripCount个平行线程（每个线程生成一个CascadeClassifierInvoker），
  35.     	// 在每个CascadeClassifierInvoker中分配当前缩放图像的N行做检测，这是TBB利用多线程做的加速计算
  36.          parallel_for_(Range(0, stripCount), CascadeClassifierInvoker( *this, processingRectSize, stripSize, yStep, factor,
  37.             candidatesVector, rejectLevels, levelWeights, false, currentMask, &mtx));
  38.     }
  39.     candidates.insert( candidates.end(), candidatesVector.begin(), candidatesVector.end() );
  40.  
  41. #if defined (LOG_CASCADE_STATISTIC)
  42.     logger.write();
  43. #endif
  44.  
  45.     return true;
  46. }
  1. class CascadeClassifierInvoker : public ParallelLoopBody
  2. {
  3. public:
  4.     CascadeClassifierInvoker( CascadeClassifier& _cc, Size _sz1, int _stripSize, int _yStep, double _factor,
  5.         vector<Rect>& _vec, vector<int>& _levels, vector<double>& _weights, bool outputLevels, const Mat& _mask, Mutex* _mtx)
  6.     {
  7.         classifier = &_cc;
  8.         processingRectSize = _sz1;
  9.         stripSize = _stripSize;
  10.         yStep = _yStep;
  11.         scalingFactor = _factor;
  12.         rectangles = &_vec;
  13.         rejectLevels = outputLevels ? &_levels : 0;
  14.         levelWeights = outputLevels ? &_weights : 0;
  15.         mask = _mask;
  16.         mtx = _mtx;
  17.     }
  18.  
  19.     void operator()(const Range& range) const
  20.     {
  21.         Ptr<FeatureEvaluator> evaluator = classifier->featureEvaluator->clone();
  22.  
  23.         Size winSize(cvRound(classifier->data.origWinSize.width * scalingFactor), cvRound(classifier->data.origWinSize.height * scalingFactor));
  24.  
  25.         int y1 = range.start * stripSize;
  26.         int y2 = min(range.end * stripSize, processingRectSize.height);
  27.         for( int y = y1; y < y2; y += yStep )
  28.         {
  29.             for( int x = 0; x < processingRectSize.width; x += yStep )
  30.             {
  31.                 if ( (!mask.empty()) && (mask.at<uchar>(Point(x,y))==0)) {
  32.                     continue;
  33.                 }
  34.  
  35.                 double gypWeight;
  36.  
  37. 				// //result =1表示通过所有分类器，result<0表示失败的级数。
  38.                 int result = classifier->runAt(evaluator, Point(x, y), gypWeight);
  39.  
  40. #if defined (LOG_CASCADE_STATISTIC)
  41.  
  42.                 logger.setPoint(Point(x, y), result);
  43. #endif
  44.                 if( rejectLevels )
  45.                 {
  46.                     if( result == 1 )
  47.                         result =  -(int)classifier->data.stages.size();
  48.                     if( classifier->data.stages.size() + result < 4 )
  49.                     {
  50.                         mtx->lock();
  51.                         rectangles->push_back(Rect(cvRound(x*scalingFactor), cvRound(y*scalingFactor), winSize.width, winSize.height));
  52.                         rejectLevels->push_back(-result);
  53.                         levelWeights->push_back(gypWeight);
  54.                         mtx->unlock();
  55.                     }
  56.                 }
  57.                 else if( result > 0 )
  58.                 {
  59.                     mtx->lock();
  60.                     rectangles->push_back(Rect(cvRound(x*scalingFactor), cvRound(y*scalingFactor),
  61.                                                winSize.width, winSize.height));
  62.                     mtx->unlock();
  63.                 }
  64.                 if( result == 0 )
  65.                     x += yStep;
  66.             }
  67.         }
  68.     }
  69.  
  70.     CascadeClassifier* classifier;
  71.     vector<Rect>* rectangles;
  72.     Size processingRectSize;
  73.     int stripSize, yStep;
  74.     double scalingFactor;
  75.     vector<int> *rejectLevels;
  76.     vector<double> *levelWeights;
  77.     Mat mask;
  78.     Mutex* mtx;
  79. };
  1. int CascadeClassifier::runAt( Ptr<FeatureEvaluator>& evaluator, Point pt, double& weight )
  2. {
  3.     CV_Assert( oldCascade.empty() );
  4.  
  5.     assert( data.featureType == FeatureEvaluator::HAAR ||
  6.             data.featureType == FeatureEvaluator::LBP ||
  7.             data.featureType == FeatureEvaluator::HOG );
  8.  
  9.     if( !evaluator->setWindow(pt) )
  10.         return -1;
  11.     if( data.isStumpBased )
  12.     {
  13.         if( data.featureType == FeatureEvaluator::HAAR )
  14.             return predictOrderedStump<HaarEvaluator>( *this, evaluator, weight );
  15.         else if( data.featureType == FeatureEvaluator::LBP )
  16.             return predictCategoricalStump<LBPEvaluator>( *this, evaluator, weight );
  17.         else if( data.featureType == FeatureEvaluator::HOG )
  18.             return predictOrderedStump<HOGEvaluator>( *this, evaluator, weight );
  19.         else
  20.             return -2;
  21.     }
  22.     else
  23.     {
  24.         if( data.featureType == FeatureEvaluator::HAAR )
  25.             return predictOrdered<HaarEvaluator>( *this, evaluator, weight );
  26.         else if( data.featureType == FeatureEvaluator::LBP )
  27.             return predictCategorical<LBPEvaluator>( *this, evaluator, weight );
  28.         else if( data.featureType == FeatureEvaluator::HOG )
  29.             return predictOrdered<HOGEvaluator>( *this, evaluator, weight );
  30.         else
  31.             return -2;
  32.     }
  33. }
合并候选框的函数 groupRectangles，在上一篇的文章里介绍了。 

  1. void groupRectangles(vector<Rect>& rectList, int groupThreshold, double eps, vector<int>* weights, vector<double>* levelWeights)
  2. {
  3. 	/*
  4. 	当组合阈值groupThreshold小于等于0的时候，如果输出weights，
  5. 	则weights中返回与rectList同样个数个1，函数直接返回，不进行合并操作
  6. 	*/
  7.     if( groupThreshold <= 0 || rectList.empty() )
  8.     {
  9.         if( weights )
  10.         {
  11.             size_t i, sz = rectList.size();
  12.             weights->resize(sz);
  13.             for( i = 0; i < sz; i++ )
  14.                 (*weights)[i] = 1;
  15.         }
  16.         return;
  17.     }
  18.  
  19. 	// 调用partition函数对rectList中的矩形进行分类
  20. 	// 其中nclasses表示组合类别，labels表示每个rect属于哪个类别的，相似度计算使用SimilarRects类
  21.     vector<int> labels;
  22.     int nclasses = partition(rectList, labels, SimilarRects(eps));
  23.  
  24.     vector<Rect> rrects(nclasses);
  25.     vector<int> rweights(nclasses, 0);
  26.     vector<int> rejectLevels(nclasses, 0);
  27.     vector<double> rejectWeights(nclasses, DBL_MIN);
  28.     int i, j, nlabels = (int)labels.size();
  29.  
  30. 	/*
  31. 	 *	组合分到同一类别的矩形并保存当前类别下通过stage的最大值以及最大的权重
  32. 	 */
  33.     for( i = 0; i < nlabels; i++ )
  34.     {
  35.         int cls = labels[i];
  36.         rrects[cls].x += rectList[i].x;
  37.         rrects[cls].y += rectList[i].y;
  38.         rrects[cls].width += rectList[i].width;
  39.         rrects[cls].height += rectList[i].height;
  40.         rweights[cls]++;
  41.     }
  42.     if ( levelWeights && weights && !weights->empty() && !levelWeights->empty() )
  43.     {
  44.         for( i = 0; i < nlabels; i++ )
  45.         {
  46.             int cls = labels[i];
  47.             if( (*weights)[i] > rejectLevels[cls] )
  48.             {
  49.                 rejectLevels[cls] = (*weights)[i];
  50.                 rejectWeights[cls] = (*levelWeights)[i];
  51.             }
  52.             else if( ( (*weights)[i] == rejectLevels[cls] ) && ( (*levelWeights)[i] > rejectWeights[cls] ) )
  53.                 rejectWeights[cls] = (*levelWeights)[i];
  54.         }
  55.     }
  56.  
  57.     for( i = 0; i < nclasses; i++ )
  58.     {
  59.         Rect r = rrects[i];
  60.         float s = 1.f/rweights[i];
  61.         rrects[i] = Rect(saturate_cast<int>(r.x*s),
  62.              saturate_cast<int>(r.y*s),
  63.              saturate_cast<int>(r.width*s),
  64.              saturate_cast<int>(r.height*s));
  65.     }
  66.  
  67.     rectList.clear();
  68.     if( weights )
  69.         weights->clear();
  70.     if( levelWeights )
  71.         levelWeights->clear();
  72.  
  73. 	// 按照groupThreshold合并规则，以及是否存在包含关系输出合并后的矩形
  74.     for( i = 0; i < nclasses; i++ )
  75.     {
  76.         Rect r1 = rrects[i];
  77.         int n1 = levelWeights ? rejectLevels[i] : rweights[i];
  78.         double w1 = rejectWeights[i];
  79.         if( n1 <= groupThreshold )
  80.             continue;
  81.         // filter out small face rectangles inside large rectangles
  82.         for( j = 0; j < nclasses; j++ )
  83.         {
  84.             int n2 = rweights[j];
  85.  
  86.             if( j == i || n2 <= groupThreshold )
  87.                 continue;
  88.             Rect r2 = rrects[j];
  89.  
  90.             int dx = saturate_cast<int>( r2.width * eps );
  91.             int dy = saturate_cast<int>( r2.height * eps );
  92.  
  93. 			// 当r1在r2的内部时，跳出
  94.             if( i != j &&
  95.                 r1.x >= r2.x - dx &&
  96.                 r1.y >= r2.y - dy &&
  97.                 r1.x + r1.width <= r2.x + r2.width + dx &&
  98.                 r1.y + r1.height <= r2.y + r2.height + dy &&
  99.                 (n2 > std::max(3, n1) || n1 < 3) )
  100.                 break;
  101.         }
  102.  
  103.         if( j == nclasses )
  104.         {
  105.             rectList.push_back(r1);
  106.             if( weights )
  107.                 weights->push_back(n1);
  108.             if( levelWeights )
  109.                 levelWeights->push_back(w1);
  110.         }
  111.     }
  112. }













声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/weixin_40725706/article/detail/733723
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号