• 【Opencv450】HOG+SVM 与Hog+cascade进行行人检测

    因为从opencv3.0开始不再支持hog+cascade级联分类器。github上有人从opencv2.x导出了个hogcascade类，引入opencv4.x可以使用。

     

    行人检测

    带孔木块级联分类器识别效果 

    主程序源码：

    1. #include <iostream>
    2. #include <string>
    3. #include <opencv2/core/core.hpp>
    4. #include <opencv2/highgui/highgui.hpp>
    5. #include <opencv2/imgproc/imgproc.hpp>
    6. #include <opencv2/objdetect/objdetect.hpp>
    7. #include <opencv2/ml/ml.hpp>
    8. #include<ctime>
    9. #include "hogcascade.hpp"
    10. using namespace std;
    11. using namespace cv;
    12.  
    13.  
    14.  
    15. int main()
    16. {
    17. 	cout << "Red:Hog+svm------Green:Hog+cascade" << endl;
    18. 	Mat src = imread("1.jpg", 1);
    19. 	vector<Rect> found1, found_filtered1, found2, found_filtered2;//矩形框数组
    20.  
    21. 	clock_t start1, end1, start2, end2;
    22. 	//方法1，Hog+svm
    23. 	start1 = clock();
    24. 	HOGDescriptor hog;//HOG特征检测器
    25. 	hog.setSVMDetector(HOGDescriptor::getDefaultPeopleDetector());//设置SVM分类器为默认参数	
    26. 	hog.detectMultiScale(src, found1, 0, Size(2, 2), Size(0, 0), 1.05, 2);//对图像进行多尺度检测，检测窗口移动步长为(8,8)
    27. 	end1 = (double)(1000 * (clock() - start1) / CLOCKS_PER_SEC);
    28. 	//方法2.Hog+cascade
    29. 	start2 = clock();
    30. 	cv::HOGCascadeClassifier hogclassifier;
    31. 	//CascadeClassifier* cascade = new CascadeClassifier;
    32. 	hogclassifier.load("hogcascade_pedestrians.xml");//hogcascade_pedestrians.xml
    33.     //hogclassifier.load("blockhogcascade.xml"); //带孔木块 hog+cascade级联分类器
    34.     //hogclassifier.detectMultiScale(src, found2,1.05,5,0,Size(400,400),Size(800,800));//带孔木块
    35. 	hogclassifier.detectMultiScale(src, found2);
    36. 	end2 = (double)(1000 * (clock() - start2) / CLOCKS_PER_SEC);
    37.  
    38. 	cout << "Hog+svm:  " << end1 << "ms" << "    Hog+cascade:  " << end2 << "ms" << endl;
    39. 	//找出所有没有嵌套的矩形框r,并放入found_filtered中,如果有嵌套的话,则取外面最大的那个矩形框放入found_filtered中
    40. 	for (int i = 0; i < found1.size(); i++)
    41. 	{
    42. 		Rect r = found1[i];
    43. 		int j = 0;
    44. 		for (; j < found1.size(); j++)
    45. 			if (j != i && (r & found1[j]) == r)
    46. 				break;
    47. 		if (j == found1.size())
    48. 			found_filtered1.push_back(r);
    49. 	}
    50. 	for (int i = 0; i < found2.size(); i++)
    51. 	{
    52. 		Rect r = found2[i];
    53. 		int j = 0;
    54. 		for (; j < found2.size(); j++)
    55. 			if (j != i && (r & found2[j]) == r)
    56. 				break;
    57. 		if (j == found2.size())
    58. 			found_filtered2.push_back(r);
    59. 	}
    60.  
    61. 	//画矩形框，因为hog检测出的矩形框比实际人体框要稍微大些,所以这里需要做一些调整
    62. 	for (int i = 0; i < found_filtered1.size(); i++)
    63. 	{
    64. 		Rect r = found_filtered1[i];
    65. 		r.x += cvRound(r.width * 0.1);
    66. 		r.width = cvRound(r.width * 0.8);
    67. 		r.y += cvRound(r.height * 0.07);
    68. 		r.height = cvRound(r.height * 0.8);
    69. 		rectangle(src, r.tl(), r.br(), Scalar(0, 0, 255), 3);//红色 hog+svm
    70. 	}
    71. 	for (int i = 0; i < found_filtered2.size(); i++)
    72. 	{
    73. 		Rect r = found_filtered2[i];
    74. 		r.x += cvRound(r.width * 0.1);
    75. 		r.width = cvRound(r.width * 0.8);
    76. 		r.y += cvRound(r.height * 0.07);
    77. 		r.height = cvRound(r.height * 0.8);
    78. 		rectangle(src, r.tl(), r.br(), Scalar(0, 255, 0), 3);//绿色： hog+cascade
    79. 	}
    80.     //resize(src,src,Size(src.size()/3));  //带孔木块识别 缩放
    81. 	imshow("src", src);
    82. 	waitKey();
    83.  
    84. 	system("pause");
    85. 	return 0;
    86. }

    hogcascade.h

    1. /*M///
    2. //
    3. //  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
    4. //
    5. //  By downloading, copying, installing or using the software you agree to this license.
    6. //  If you do not agree to this license, do not download, install,
    7. //  copy or use the software.
    8. //
    9. //
    10. //                        Intel License Agreement
    11. //                For Open Source Computer Vision Library
    12. //
    13. // Copyright (C) 2000, Intel Corporation, all rights reserved.
    14. // Third party copyrights are property of their respective owners.
    15. //
    16. // Redistribution and use in source and binary forms, with or without modification,
    17. // are permitted provided that the following conditions are met:
    18. //
    19. //   * Redistribution's of source code must retain the above copyright notice,
    20. //     this list of conditions and the following disclaimer.
    21. //
    22. //   * Redistribution's in binary form must reproduce the above copyright notice,
    23. //     this list of conditions and the following disclaimer in the documentation
    24. //     and/or other materials provided with the distribution.
    25. //
    26. //   * The name of Intel Corporation may not be used to endorse or promote products
    27. //     derived from this software without specific prior written permission.
    28. //
    29. // This software is provided by the copyright holders and contributors "as is" and
    30. // any express or implied warranties, including, but not limited to, the implied
    31. // warranties of merchantability and fitness for a particular purpose are disclaimed.
    32. // In no event shall the Intel Corporation or contributors be liable for any direct,
    33. // indirect, incidental, special, exemplary, or consequential damages
    34. // (including, but not limited to, procurement of substitute goods or services;
    35. // loss of use, data, or profits; or business interruption) however caused
    36. // and on any theory of liability, whether in contract, strict liability,
    37. // or tort (including negligence or otherwise) arising in any way out of
    38. // the use of this software, even if advised of the possibility of such damage.
    39. //
    40. //M*/
    41. #pragma once
    42.  
    43. #include <opencv2/opencv.hpp>
    44. #include <string>
    45.  
    46. namespace cv
    47. {
    48.     using std::vector;
    49. #define CCC_CASCADE_PARAMS "cascadeParams"
    50. #define CCC_STAGE_TYPE     "stageType"
    51. #define CCC_FEATURE_TYPE   "featureType"
    52. #define CCC_HEIGHT         "height"
    53. #define CCC_WIDTH          "width"
    54.  
    55. #define CCC_STAGE_NUM    "stageNum"
    56. #define CCC_STAGES       "stages"
    57. #define CCC_STAGE_PARAMS "stageParams"
    58.  
    59. #define CCC_BOOST            "BOOST"
    60. #define CCC_MAX_DEPTH        "maxDepth"
    61. #define CCC_WEAK_COUNT       "maxWeakCount"
    62. #define CCC_STAGE_THRESHOLD  "stageThreshold"
    63. #define CCC_WEAK_CLASSIFIERS "weakClassifiers"
    64. #define CCC_INTERNAL_NODES   "internalNodes"
    65. #define CCC_LEAF_VALUES      "leafValues"
    66.  
    67. #define CCC_FEATURES       "features"
    68. #define CCC_FEATURE_PARAMS "featureParams"
    69. #define CCC_MAX_CAT_COUNT  "maxCatCount"
    70.  
    71. #define CCV_SUM_PTRS( p0, p1, p2, p3, sum, rect, step )                    \
    72.     /* (x, y) */                                                          \
    73.     (p0) = sum + (rect).x + (step) * (rect).y,                            \
    74.     /* (x + w, y) */                                                      \
    75.     (p1) = sum + (rect).x + (rect).width + (step) * (rect).y,             \
    76.     /* (x + w, y) */                                                      \
    77.     (p2) = sum + (rect).x + (step) * ((rect).y + (rect).height),          \
    78.     /* (x + w, y + h) */                                                  \
    79.     (p3) = sum + (rect).x + (rect).width + (step) * ((rect).y + (rect).height)
    80.  
    81. //#define CCV_TILTED_PTRS( p0, p1, p2, p3, tilted, rect, step )                        \
    82. //    /* (x, y) */                                                                    \
    83. //    (p0) = tilted + (rect).x + (step) * (rect).y,                                   \
    84. //    /* (x - h, y + h) */                                                            \
    85. //    (p1) = tilted + (rect).x - (rect).height + (step) * ((rect).y + (rect).height), \
    86. //    /* (x + w, y + w) */                                                            \
    87. //    (p2) = tilted + (rect).x + (rect).width + (step) * ((rect).y + (rect).width),   \
    88. //    /* (x + w - h, y + w + h) */                                                    \
    89. //    (p3) = tilted + (rect).x + (rect).width - (rect).height                         \
    90. //           + (step) * ((rect).y + (rect).width + (rect).height)
    91.  
    92. #define CCALC_SUM_(p0, p1, p2, p3, offset) \
    93.     ((p0)[offset] - (p1)[offset] - (p2)[offset] + (p3)[offset])
    94.  
    95. #define CCALC_SUM(rect,offset) CCALC_SUM_((rect)[0], (rect)[1], (rect)[2], (rect)[3], offset)
    96.  
    97. //#define CCC_HAAR   "HAAR"
    98. //#define CCC_RECTS  "rects"
    99. //#define CCC_TILTED "tilted"
    100. //
    101. //#define CCC_LBP  "LBP"
    102. #define CCC_RECT "rect"
    103.  
    104. #define CCC_HOG  "HOG"
    105.  
    106. class HOGEvaluator
    107. {
    108. public:
    109.     static const int HOG = 2;
    110.     struct Feature
    111.     {
    112.         Feature();
    113.         float calc( int offset ) const;
    114.         void updatePtrs( const vector<Mat>& _hist, const Mat &_normSum );
    115.         bool read( const FileNode& node );
    116.  
    117.         enum { CELL_NUM = 4, BIN_NUM = 9 };
    118.  
    119.         Rect rect[CELL_NUM];
    120.         int featComponent; //component index from 0 to 35
    121.         const float* pF[4]; //for feature calculation
    122.         const float* pN[4]; //for normalization calculation
    123.     };
    124.     HOGEvaluator();
    125.     virtual ~HOGEvaluator();
    126.     virtual bool read( const FileNode& node );
    127.     virtual Ptr<HOGEvaluator> clone() const;
    128.     virtual int getFeatureType() const { return HOGEvaluator::HOG; }
    129.     virtual bool setImage( const Mat& image, Size winSize );
    130.     virtual bool setWindow( Point pt );
    131.     double operator()(int featureIdx) const
    132.     {
    133.         return featuresPtr[featureIdx].calc(offset);
    134.     }
    135.     virtual double calcOrd( int featureIdx ) const
    136.     {
    137.         return (*this)(featureIdx);
    138.     }
    139.  
    140. private:
    141.     virtual void integralHistogram( const Mat& srcImage, vector<Mat> &histogram, Mat &norm, int nbins ) const;
    142.  
    143.     Size origWinSize;
    144.     Ptr<vector<Feature> > features;
    145.     Feature* featuresPtr;
    146.     vector<Mat> hist;
    147.     Mat normSum;
    148.     int offset;
    149. };
    150.  
    151. class CV_EXPORTS_W HOGCascadeClassifier
    152. {
    153. public:    
    154.     CV_WRAP HOGCascadeClassifier();
    155.     CV_WRAP HOGCascadeClassifier(const std::string& filename);
    156.     virtual ~HOGCascadeClassifier();
    157.     CV_WRAP virtual bool empty() const;
    158.     CV_WRAP bool load(const std::string& filename);
    159.     virtual bool read( const FileNode& node );
    160.     CV_WRAP void detectMultiScale(const Mat& image,
    161.                     CV_OUT std::vector<Rect>& objects,
    162.                     double scaleFactor = 1.1,
    163.                     int minNeighbors = 3, int flags = 0,
    164.                     Size minSize = Size(),
    165.                     Size maxSize = Size());
    166.                     
    167.     CV_WRAP void detectMultiScale( const Mat& image, vector<Rect>& objects,
    168.                     vector<int>& rejectLevels,
    169.                     vector<double>& levelWeights,
    170.                     double scaleFactor=1.1,
    171.                     int minNeighbors=3, int flags=0,
    172.                     Size minSize=Size(),
    173.                     Size maxSize=Size(),
    174.                     bool outputRejectLevels=false );
    175.                     
    176.     class CV_EXPORTS MaskGenerator
    177.     {
    178.     public:
    179.         virtual ~MaskGenerator() {}
    180.         virtual cv::Mat generateMask(const cv::Mat& src)=0;
    181.         virtual void initializeMask(const cv::Mat& /*src*/) {};
    182.     };
    183.     void setMaskGenerator(Ptr<MaskGenerator> maskGenerator);
    184.     Ptr<MaskGenerator> getMaskGenerator();
    185.                     
    186. protected:
    187.     Ptr<MaskGenerator> maskGenerator;
    188.     virtual int runAt( Ptr<HOGEvaluator>& feval, Point pt, double& weight );
    189.     virtual bool detectSingleScale( const Mat& image, int stripCount, Size processingRectSize,
    190.                                     int stripSize, int yStep, double factor, vector<Rect>& candidates,
    191.                                     vector<int>& rejectLevels, vector<double>& levelWeights, bool outputRejectLevels=false);
    192.  
    193.     friend class HOGCascadeClassifierInvoker;
    194.  
    195.     friend int HOGpredictOrdered( HOGCascadeClassifier& cascade, Ptr<HOGEvaluator> &featureEvaluator, double& weight);
    196.     friend int HOGpredictOrderedStump( HOGCascadeClassifier& cascade, Ptr<HOGEvaluator> &featureEvaluator, double& weight);
    197.  
    198.     class Data
    199.     {
    200.         public:
    201.         struct CV_EXPORTS DTreeNode
    202.         {
    203.             int featureIdx;
    204.             float threshold; // for ordered features only
    205.             int left;
    206.             int right;
    207.         };
    208.  
    209.         struct CV_EXPORTS DTree
    210.         {
    211.             int nodeCount;
    212.         };
    213.  
    214.         struct CV_EXPORTS Stage
    215.         {
    216.             int first;
    217.             int ntrees;
    218.             float threshold;
    219.         };
    220.  
    221.         bool read(const FileNode &node);
    222.  
    223.         bool isStumpBased;
    224.  
    225.         int stageType;
    226.         int featureType;
    227.         int ncategories;
    228.         Size origWinSize;
    229.  
    230.         vector<Stage> stages;
    231.         vector<DTree> classifiers;
    232.         vector<DTreeNode> nodes;
    233.         vector<float> leaves;
    234.         vector<int> subsets;
    235.     };
    236.     
    237.     Data data;
    238.     Ptr<HOGEvaluator> featureEvaluator;
    239. };
    240.  
    241. inline HOGEvaluator::Feature :: Feature()
    242. {
    243.     rect[0] = rect[1] = rect[2] = rect[3] = Rect();
    244.     pF[0] = pF[1] = pF[2] = pF[3] = 0;
    245.     pN[0] = pN[1] = pN[2] = pN[3] = 0;
    246.     featComponent = 0;
    247. }
    248.  
    249. inline float HOGEvaluator::Feature :: calc( int _offset ) const
    250. {
    251.     float res = CCALC_SUM(pF, _offset);
    252.     float normFactor = CCALC_SUM(pN, _offset);
    253.     res = (res > 0.001f) ? (res / ( normFactor + 0.001f) ) : 0.f;
    254.     return res;
    255. }
    256.  
    257. inline void HOGEvaluator::Feature :: updatePtrs( const vector<Mat> &_hist, const Mat &_normSum )
    258. {
    259.     int binIdx = featComponent % BIN_NUM;
    260.     int cellIdx = featComponent / BIN_NUM;
    261.     Rect normRect = Rect( rect[0].x, rect[0].y, 2*rect[0].width, 2*rect[0].height );
    262.  
    263.     const float* featBuf = (const float*)_hist[binIdx].data;
    264.     size_t featStep = _hist[0].step / sizeof(featBuf[0]);
    265.  
    266.     const float* normBuf = (const float*)_normSum.data;
    267.     size_t normStep = _normSum.step / sizeof(normBuf[0]);
    268.  
    269.     CCV_SUM_PTRS( pF[0], pF[1], pF[2], pF[3], featBuf, rect[cellIdx], featStep );
    270.     CCV_SUM_PTRS( pN[0], pN[1], pN[2], pN[3], normBuf, normRect, normStep );
    271. }
    272.  
    273. inline int HOGpredictOrdered( HOGCascadeClassifier& cascade, Ptr<HOGEvaluator> &_featureEvaluator, double& sum )
    274. {
    275.     int nstages = (int)cascade.data.stages.size();
    276.     int nodeOfs = 0, leafOfs = 0;
    277.     HOGEvaluator& featureEvaluator = (HOGEvaluator&)*_featureEvaluator;
    278.     float* cascadeLeaves = &cascade.data.leaves[0];
    279.     HOGCascadeClassifier::Data::DTreeNode* cascadeNodes = &cascade.data.nodes[0];
    280.     HOGCascadeClassifier::Data::DTree* cascadeWeaks = &cascade.data.classifiers[0];
    281.     HOGCascadeClassifier::Data::Stage* cascadeStages = &cascade.data.stages[0];
    282.  
    283.     for( int si = 0; si < nstages; si++ )
    284.     {
    285.         HOGCascadeClassifier::Data::Stage& stage = cascadeStages[si];
    286.         int wi, ntrees = stage.ntrees;
    287.         sum = 0;
    288.  
    289.         for( wi = 0; wi < ntrees; wi++ )
    290.         {
    291.             HOGCascadeClassifier::Data::DTree& weak = cascadeWeaks[stage.first + wi];
    292.             int idx = 0, root = nodeOfs;
    293.  
    294.             do
    295.             {
    296.                 HOGCascadeClassifier::Data::DTreeNode& node = cascadeNodes[root + idx];
    297.                 double val = featureEvaluator(node.featureIdx);
    298.                 idx = val < node.threshold ? node.left : node.right;
    299.             }
    300.             while( idx > 0 );
    301.             sum += cascadeLeaves[leafOfs - idx];
    302.             nodeOfs += weak.nodeCount;
    303.             leafOfs += weak.nodeCount + 1;
    304.         }
    305.         if( sum < stage.threshold )
    306.             return -si;
    307.     }
    308.     return 1;
    309. }
    310.  
    311. inline int HOGpredictOrderedStump( HOGCascadeClassifier& cascade, Ptr<HOGEvaluator> &_featureEvaluator, double& sum )
    312. {
    313.     int nodeOfs = 0, leafOfs = 0;
    314.     HOGEvaluator& featureEvaluator = (HOGEvaluator&)*_featureEvaluator;
    315.     float* cascadeLeaves = &cascade.data.leaves[0];
    316.     HOGCascadeClassifier::Data::DTreeNode* cascadeNodes = &cascade.data.nodes[0];
    317.     HOGCascadeClassifier::Data::Stage* cascadeStages = &cascade.data.stages[0];
    318.  
    319.     int nstages = (int)cascade.data.stages.size();
    320.     for( int stageIdx = 0; stageIdx < nstages; stageIdx++ )
    321.     {
    322.         HOGCascadeClassifier::Data::Stage& stage = cascadeStages[stageIdx];
    323.         sum = 0.0;
    324.  
    325.         int ntrees = stage.ntrees;
    326.         for( int i = 0; i < ntrees; i++, nodeOfs++, leafOfs+= 2 )
    327.         {
    328.             HOGCascadeClassifier::Data::DTreeNode& node = cascadeNodes[nodeOfs];
    329.             double value = featureEvaluator(node.featureIdx);
    330.             sum += cascadeLeaves[ value < node.threshold ? leafOfs : leafOfs + 1 ];
    331.         }
    332.  
    333.         if( sum < stage.threshold )
    334.             return -stageIdx;
    335.     }
    336.  
    337.     return 1;
    338. }
    339.  
    340. }

    hogcascade.cpp

    1. /*M///
    2. //
    3. //  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
    4. //
    5. //  By downloading, copying, installing or using the software you agree to this license.
    6. //  If you do not agree to this license, do not download, install,
    7. //  copy or use the software.
    8. //
    9. //
    10. //                        Intel License Agreement
    11. //                For Open Source Computer Vision Library
    12. //
    13. // Copyright (C) 2000, Intel Corporation, all rights reserved.
    14. // Third party copyrights are property of their respective owners.
    15. //
    16. // Redistribution and use in source and binary forms, with or without modification,
    17. // are permitted provided that the following conditions are met:
    18. //
    19. //   * Redistribution's of source code must retain the above copyright notice,
    20. //     this list of conditions and the following disclaimer.
    21. //
    22. //   * Redistribution's in binary form must reproduce the above copyright notice,
    23. //     this list of conditions and the following disclaimer in the documentation
    24. //     and/or other materials provided with the distribution.
    25. //
    26. //   * The name of Intel Corporation may not be used to endorse or promote products
    27. //     derived from this software without specific prior written permission.
    28. //
    29. // This software is provided by the copyright holders and contributors "as is" and
    30. // any express or implied warranties, including, but not limited to, the implied
    31. // warranties of merchantability and fitness for a particular purpose are disclaimed.
    32. // In no event shall the Intel Corporation or contributors be liable for any direct,
    33. // indirect, incidental, special, exemplary, or consequential damages
    34. // (including, but not limited to, procurement of substitute goods or services;
    35. // loss of use, data, or profits; or business interruption) however caused
    36. // and on any theory of liability, whether in contract, strict liability,
    37. // or tort (including negligence or otherwise) arising in any way out of
    38. // the use of this software, even if advised of the possibility of such damage.
    39. //
    40. //M*/
    41.  
    42. #include "hogcascade.hpp"
    43. #include <cassert>
    44.  
    45. namespace cv
    46. {
    47.     using std::string;
    48. class HOGCascadeClassifierInvoker : public ParallelLoopBody
    49. {
    50. public:
    51.     HOGCascadeClassifierInvoker( HOGCascadeClassifier& _cc, Size _sz1, int _stripSize, int _yStep, double _factor,
    52.         vector<Rect>& _vec, vector<int>& _levels, vector<double>& _weights, bool outputLevels, const Mat& _mask, Mutex* _mtx)
    53.     {
    54.         classifier = &_cc;
    55.         processingRectSize = _sz1;
    56.         stripSize = _stripSize;
    57.         yStep = _yStep;
    58.         scalingFactor = _factor;
    59.         rectangles = &_vec;
    60.         rejectLevels = outputLevels ? &_levels : 0;
    61.         levelWeights = outputLevels ? &_weights : 0;
    62.         mask = _mask;
    63.         mtx = _mtx;
    64.     }
    65.  
    66.     void operator()(const Range& range) const
    67.     {
    68.         Ptr<HOGEvaluator> evaluator = classifier->featureEvaluator->clone();
    69.  
    70.         Size winSize(cvRound(classifier->data.origWinSize.width * scalingFactor), cvRound(classifier->data.origWinSize.height * scalingFactor));
    71.  
    72.         int y1 = range.start * stripSize;
    73.         int y2 = min(range.end * stripSize, processingRectSize.height);
    74.         for( int y = y1; y < y2; y += yStep )
    75.         {
    76.             for( int x = 0; x < processingRectSize.width; x += yStep )
    77.             {
    78.                 if ( (!mask.empty()) && (mask.at<uchar>(Point(x,y))==0)) {
    79.                     continue;
    80.                 }
    81.  
    82.                 double gypWeight;
    83.                 int result = classifier->runAt(evaluator, Point(x, y), gypWeight);
    84.                 if( rejectLevels )
    85.                 {
    86.                     if( result == 1 )
    87.                         result =  -(int)classifier->data.stages.size();
    88.                     if( classifier->data.stages.size() + result < 4 )
    89.                     {
    90.                         mtx->lock();
    91.                         rectangles->push_back(Rect(cvRound(x*scalingFactor), cvRound(y*scalingFactor), winSize.width, winSize.height));
    92.                         rejectLevels->push_back(-result);
    93.                         levelWeights->push_back(gypWeight);
    94.                         mtx->unlock();
    95.                     }
    96.                 }
    97.                 else if( result > 0 )
    98.                 {
    99.                     mtx->lock();
    100.                     rectangles->push_back(Rect(cvRound(x*scalingFactor), cvRound(y*scalingFactor),
    101.                                                winSize.width, winSize.height));
    102.                     mtx->unlock();
    103.                 }
    104.                 if( result == 0 )
    105.                     x += yStep;
    106.             }
    107.         }
    108.     }
    109.  
    110.     HOGCascadeClassifier* classifier;
    111.     vector<Rect>* rectangles;
    112.     Size processingRectSize;
    113.     int stripSize, yStep;
    114.     double scalingFactor;
    115.     vector<int> *rejectLevels;
    116.     vector<double> *levelWeights;
    117.     Mat mask;
    118.     Mutex* mtx;
    119. };
    120.     
    121. bool HOGEvaluator::Feature :: read( const FileNode& node )
    122. {
    123.     FileNode rnode = node[CCC_RECT];
    124.     FileNodeIterator it = rnode.begin();
    125.     it >> rect[0].x >> rect[0].y >> rect[0].width >> rect[0].height >> featComponent;
    126.     rect[1].x = rect[0].x + rect[0].width;
    127.     rect[1].y = rect[0].y;
    128.     rect[2].x = rect[0].x;
    129.     rect[2].y = rect[0].y + rect[0].height;
    130.     rect[3].x = rect[0].x + rect[0].width;
    131.     rect[3].y = rect[0].y + rect[0].height;
    132.     rect[1].width = rect[2].width = rect[3].width = rect[0].width;
    133.     rect[1].height = rect[2].height = rect[3].height = rect[0].height;
    134.     return true;
    135. }
    136.  
    137. HOGEvaluator::HOGEvaluator()
    138. {
    139.     features = Ptr<vector<Feature> >(new vector<Feature>());
    140. }
    141.  
    142. HOGEvaluator::~HOGEvaluator()
    143. {
    144. }
    145.  
    146. bool HOGEvaluator::read( const FileNode& node )
    147. {
    148.     features->resize(node.size());
    149.     featuresPtr = &(*features)[0];
    150.     FileNodeIterator it = node.begin(), it_end = node.end();
    151.     for(int i = 0; it != it_end; ++it, i++)
    152.     {
    153.         if(!featuresPtr[i].read(*it))
    154.             return false;
    155.     }
    156.     return true;
    157. }
    158.  
    159. Ptr<HOGEvaluator> HOGEvaluator::clone() const
    160. {
    161.     Ptr<HOGEvaluator> ret = Ptr<HOGEvaluator>(new HOGEvaluator);
    162.     ret->origWinSize = origWinSize;
    163.     ret->features = features;
    164.     ret->featuresPtr = &(*ret->features)[0];
    165.     ret->offset = offset;
    166.     ret->hist = hist;
    167.     ret->normSum = normSum;
    168.     return ret;
    169. }
    170.  
    171. bool HOGEvaluator::setImage( const Mat& image, Size winSize )
    172. {
    173.     int rows = image.rows + 1;
    174.     int cols = image.cols + 1;
    175.     origWinSize = winSize;
    176.     if( image.cols < origWinSize.width || image.rows < origWinSize.height )
    177.         return false;
    178.     hist.clear();
    179.     for( int bin = 0; bin < Feature::BIN_NUM; bin++ )
    180.     {
    181.         hist.push_back( Mat(rows, cols, CV_32FC1) );
    182.     }
    183.     normSum.create( rows, cols, CV_32FC1 );
    184.  
    185.     integralHistogram( image, hist, normSum, Feature::BIN_NUM );
    186.  
    187.     size_t featIdx, featCount = features->size();
    188.  
    189.     for( featIdx = 0; featIdx < featCount; featIdx++ )
    190.     {
    191.         featuresPtr[featIdx].updatePtrs( hist, normSum );
    192.     }
    193.     return true;
    194. }
    195.  
    196. bool HOGEvaluator::setWindow(Point pt)
    197. {
    198.     if( pt.x < 0 || pt.y < 0 ||
    199.         pt.x + origWinSize.width >= hist[0].cols-2 ||
    200.         pt.y + origWinSize.height >= hist[0].rows-2 )
    201.         return false;
    202.     offset = pt.y * ((int)hist[0].step/sizeof(float)) + pt.x;
    203.     return true;
    204. }
    205.  
    206. void HOGEvaluator::integralHistogram(const Mat &img, vector<Mat> &histogram, Mat &norm, int nbins) const
    207. {
    208.     CV_Assert( img.type() == CV_8U || img.type() == CV_8UC3 );
    209.     int x, y, binIdx;
    210.  
    211.     Size gradSize(img.size());
    212.     Size histSize(histogram[0].size());
    213.     Mat grad(gradSize, CV_32F);
    214.     Mat qangle(gradSize, CV_8U);
    215.  
    216.     AutoBuffer<int> mapbuf(gradSize.width + gradSize.height + 4);
    217.     int* xmap = (int*)mapbuf + 1;
    218.     int* ymap = xmap + gradSize.width + 2;
    219.  
    220.     const int borderType = (int)BORDER_REPLICATE;
    221.  
    222.     for( x = -1; x < gradSize.width + 1; x++ )
    223.         xmap[x] = borderInterpolate(x, gradSize.width, borderType);
    224.     for( y = -1; y < gradSize.height + 1; y++ )
    225.         ymap[y] = borderInterpolate(y, gradSize.height, borderType);
    226.  
    227.     int width = gradSize.width;
    228.     AutoBuffer<float> _dbuf(width*4);
    229.     float* dbuf = _dbuf;
    230.     Mat Dx(1, width, CV_32F, dbuf);
    231.     Mat Dy(1, width, CV_32F, dbuf + width);
    232.     Mat Mag(1, width, CV_32F, dbuf + width*2);
    233.     Mat Angle(1, width, CV_32F, dbuf + width*3);
    234.  
    235.     float angleScale = (float)(nbins/CV_PI);
    236.  
    237.     for( y = 0; y < gradSize.height; y++ )
    238.     {
    239.         const uchar* currPtr = img.data + img.step*ymap[y];
    240.         const uchar* prevPtr = img.data + img.step*ymap[y-1];
    241.         const uchar* nextPtr = img.data + img.step*ymap[y+1];
    242.         float* gradPtr = (float*)grad.ptr(y);
    243.         uchar* qanglePtr = (uchar*)qangle.ptr(y);
    244.  
    245.         for( x = 0; x < width; x++ )
    246.         {
    247.             dbuf[x] = (float)(currPtr[xmap[x+1]] - currPtr[xmap[x-1]]);
    248.             dbuf[width + x] = (float)(nextPtr[xmap[x]] - prevPtr[xmap[x]]);
    249.         }
    250.         cartToPolar( Dx, Dy, Mag, Angle, false );
    251.         for( x = 0; x < width; x++ )
    252.         {
    253.             float mag = dbuf[x+width*2];
    254.             float angle = dbuf[x+width*3];
    255.             angle = angle*angleScale - 0.5f;
    256.             int bidx = cvFloor(angle);
    257.             angle -= bidx;
    258.             if( bidx < 0 )
    259.                 bidx += nbins;
    260.             else if( bidx >= nbins )
    261.                 bidx -= nbins;
    262.  
    263.             qanglePtr[x] = (uchar)bidx;
    264.             gradPtr[x] = mag;
    265.         }
    266.     }
    267.     integral(grad, norm, grad.depth());
    268.  
    269.     float* histBuf;
    270.     const float* magBuf;
    271.     const uchar* binsBuf;
    272.  
    273.     int binsStep = (int)( qangle.step / sizeof(uchar) );
    274.     int histStep = (int)( histogram[0].step / sizeof(float) );
    275.     int magStep = (int)( grad.step / sizeof(float) );
    276.     for( binIdx = 0; binIdx < nbins; binIdx++ )
    277.     {
    278.         histBuf = (float*)histogram[binIdx].data;
    279.         magBuf = (const float*)grad.data;
    280.         binsBuf = (const uchar*)qangle.data;
    281.  
    282.         memset( histBuf, 0, histSize.width * sizeof(histBuf[0]) );
    283.         histBuf += histStep + 1;
    284.         for( y = 0; y < qangle.rows; y++ )
    285.         {
    286.             histBuf[-1] = 0.f;
    287.             float strSum = 0.f;
    288.             for( x = 0; x < qangle.cols; x++ )
    289.             {
    290.                 if( binsBuf[x] == binIdx )
    291.                     strSum += magBuf[x];
    292.                 histBuf[x] = histBuf[-histStep + x] + strSum;
    293.             }
    294.             histBuf += histStep;
    295.             binsBuf += binsStep;
    296.             magBuf += magStep;
    297.         }
    298.     }
    299. }
    300.  
    301. HOGCascadeClassifier::HOGCascadeClassifier()
    302. {
    303. }
    304.  
    305. HOGCascadeClassifier::HOGCascadeClassifier(const std::string& filename)
    306. {
    307.     load(filename);
    308. }
    309.  
    310. HOGCascadeClassifier::~HOGCascadeClassifier()
    311. {
    312. }
    313.  
    314. bool HOGCascadeClassifier::empty() const
    315. {
    316.     return data.stages.empty();
    317. }
    318.  
    319. bool HOGCascadeClassifier::load(const std::string& filename)
    320. {
    321.     data = Data();
    322.     featureEvaluator.release();
    323.  
    324.     FileStorage fs(filename, FileStorage::READ);
    325.     if( !fs.isOpened() )
    326.         return false;
    327.  
    328.     if( read(fs.getFirstTopLevelNode()) )
    329.         return true;
    330.  
    331.     fs.release();
    332.     
    333.     return false;
    334. }
    335.  
    336. bool HOGCascadeClassifier::Data::read(const FileNode &root)
    337. {
    338.     static const float THRESHOLD_EPS = 1e-5f;
    339.  
    340.     // load stage params
    341.     string stageTypeStr = (string)root[CCC_STAGE_TYPE];
    342.     if( stageTypeStr == CCC_BOOST )
    343.         stageType = 0;
    344.     else
    345.         return false;
    346.  
    347.     string featureTypeStr = (string)root[CCC_FEATURE_TYPE];
    348.     if( featureTypeStr == CCC_HOG )
    349.         featureType = HOGEvaluator::HOG;
    350.     else
    351.         return false;
    352.  
    353.     origWinSize.width = (int)root[CCC_WIDTH];
    354.     origWinSize.height = (int)root[CCC_HEIGHT];
    355.     CV_Assert( origWinSize.height > 0 && origWinSize.width > 0 );
    356.  
    357.     isStumpBased = (int)(root[CCC_STAGE_PARAMS][CCC_MAX_DEPTH]) == 1 ? true : false;
    358.  
    359.     // load feature params
    360.     FileNode fn = root[CCC_FEATURE_PARAMS];
    361.     if( fn.empty() )
    362.         return false;
    363.  
    364.     ncategories = fn[CCC_MAX_CAT_COUNT];
    365.     int subsetSize = (ncategories + 31)/32,
    366.         nodeStep = 3 + ( ncategories>0 ? subsetSize : 1 );
    367.  
    368.     // load stages
    369.     fn = root[CCC_STAGES];
    370.     if( fn.empty() )
    371.         return false;
    372.  
    373.     stages.reserve(fn.size());
    374.     classifiers.clear();
    375.     nodes.clear();
    376.  
    377.     FileNodeIterator it = fn.begin(), it_end = fn.end();
    378.  
    379.     for( int si = 0; it != it_end; si++, ++it )
    380.     {
    381.         FileNode fns = *it;
    382.         Stage stage;
    383.         stage.threshold = (float)fns[CCC_STAGE_THRESHOLD] - THRESHOLD_EPS;
    384.         fns = fns[CCC_WEAK_CLASSIFIERS];
    385.         if(fns.empty())
    386.             return false;
    387.         stage.ntrees = (int)fns.size();
    388.         stage.first = (int)classifiers.size();
    389.         stages.push_back(stage);
    390.         classifiers.reserve(stages[si].first + stages[si].ntrees);
    391.  
    392.         FileNodeIterator it1 = fns.begin(), it1_end = fns.end();
    393.         for( ; it1 != it1_end; ++it1 ) // weak trees
    394.         {
    395.             FileNode fnw = *it1;
    396.             FileNode internalNodes = fnw[CCC_INTERNAL_NODES];
    397.             FileNode leafValues = fnw[CCC_LEAF_VALUES];
    398.             if( internalNodes.empty() || leafValues.empty() )
    399.                 return false;
    400.  
    401.             DTree tree;
    402.             tree.nodeCount = (int)internalNodes.size()/nodeStep;
    403.             classifiers.push_back(tree);
    404.  
    405.             nodes.reserve(nodes.size() + tree.nodeCount);
    406.             leaves.reserve(leaves.size() + leafValues.size());
    407.             if( subsetSize > 0 )
    408.                 subsets.reserve(subsets.size() + tree.nodeCount*subsetSize);
    409.  
    410.             FileNodeIterator internalNodesIter = internalNodes.begin(), internalNodesEnd = internalNodes.end();
    411.  
    412.             for( ; internalNodesIter != internalNodesEnd; ) // nodes
    413.             {
    414.                 DTreeNode node;
    415.                 node.left = (int)*internalNodesIter; ++internalNodesIter;
    416.                 node.right = (int)*internalNodesIter; ++internalNodesIter;
    417.                 node.featureIdx = (int)*internalNodesIter; ++internalNodesIter;
    418.                 if( subsetSize > 0 )
    419.                 {
    420.                     for( int j = 0; j < subsetSize; j++, ++internalNodesIter )
    421.                         subsets.push_back((int)*internalNodesIter);
    422.                     node.threshold = 0.f;
    423.                 }
    424.                 else
    425.                 {
    426.                     node.threshold = (float)*internalNodesIter; ++internalNodesIter;
    427.                 }
    428.                 nodes.push_back(node);
    429.             }
    430.  
    431.             internalNodesIter = leafValues.begin(), internalNodesEnd = leafValues.end();
    432.  
    433.             for( ; internalNodesIter != internalNodesEnd; ++internalNodesIter ) // leaves
    434.                 leaves.push_back((float)*internalNodesIter);
    435.         }
    436.     }
    437.  
    438.     return true;
    439. }
    440.  
    441. bool HOGCascadeClassifier::read(const FileNode& root)
    442. {
    443.     if( !data.read(root) )
    444.         return false;
    445.  
    446.     // load features
    447.     featureEvaluator = Ptr<HOGEvaluator>(new HOGEvaluator);
    448.     FileNode fn = root[CCC_FEATURES];
    449.     if( fn.empty() )
    450.         return false;
    451.  
    452.     return featureEvaluator->read(fn);
    453. }
    454.  
    455. bool HOGCascadeClassifier::detectSingleScale( const Mat& image, int stripCount, Size processingRectSize,
    456.                                            int stripSize, int yStep, double factor, vector<Rect>& candidates,
    457.                                            vector<int>& levels, vector<double>& weights, bool outputRejectLevels )
    458. {
    459.     if( !featureEvaluator->setImage( image, data.origWinSize ) )
    460.         return false;
    461.  
    462.     Mat currentMask;
    463.     if (!maskGenerator.empty()) {
    464.         currentMask=maskGenerator->generateMask(image);
    465.     }
    466.  
    467.     vector<Rect> candidatesVector;
    468.     vector<int> rejectLevels;
    469.     vector<double> levelWeights;
    470.     Mutex mtx;
    471.     if( outputRejectLevels )
    472.     {
    473.         parallel_for_(Range(0, stripCount), HOGCascadeClassifierInvoker( *this, processingRectSize, stripSize, yStep, factor,
    474.             candidatesVector, rejectLevels, levelWeights, true, currentMask, &mtx));
    475.         levels.insert( levels.end(), rejectLevels.begin(), rejectLevels.end() );
    476.         weights.insert( weights.end(), levelWeights.begin(), levelWeights.end() );
    477.     }
    478.     else
    479.     {
    480.          parallel_for_(Range(0, stripCount), HOGCascadeClassifierInvoker( *this, processingRectSize, stripSize, yStep, factor,
    481.             candidatesVector, rejectLevels, levelWeights, false, currentMask, &mtx));
    482.     }
    483.     candidates.insert( candidates.end(), candidatesVector.begin(), candidatesVector.end() );
    484.     return true;
    485. }
    486.  
    487. int HOGCascadeClassifier::runAt( Ptr<HOGEvaluator>& evaluator, Point pt, double& weight )
    488. {
    489.     assert( data.featureType == HOGEvaluator::HOG );
    490.  
    491.     if( !evaluator->setWindow(pt) )
    492.         return -1;
    493.     if( data.isStumpBased )
    494.     {
    495.         return HOGpredictOrderedStump( *this, evaluator, weight );
    496.     }
    497.     else
    498.     {
    499.         return HOGpredictOrdered( *this, evaluator, weight );
    500.     }
    501. }
    502.  
    503. void HOGCascadeClassifier::detectMultiScale( const Mat& image, vector<Rect>& objects,
    504.                                           vector<int>& rejectLevels,
    505.                                           vector<double>& levelWeights,
    506.                                           double scaleFactor, int minNeighbors,
    507.                                           int flags, Size minObjectSize, Size maxObjectSize,
    508.                                           bool outputRejectLevels )
    509. {
    510.     const double GROUP_EPS = 0.2;
    511.  
    512.     CV_Assert( scaleFactor > 1 && image.depth() == CV_8U );
    513.  
    514.     if( empty() )
    515.         return;
    516.  
    517.     objects.clear();
    518.  
    519.     // TODO
    520.     if (!maskGenerator.empty()) {
    521.         maskGenerator->initializeMask(image);
    522.     }
    523.  
    524.  
    525.     if( maxObjectSize.height == 0 || maxObjectSize.width == 0 )
    526.         maxObjectSize = image.size();
    527.  
    528.     Mat grayImage = image;
    529.     if( grayImage.channels() > 1 )
    530.     {
    531.         Mat temp;
    532.         cvtColor(grayImage, temp, COLOR_BGR2GRAY);
    533.         grayImage = temp;
    534.     }
    535.  
    536.     Mat imageBuffer(image.rows + 1, image.cols + 1, CV_8U);
    537.     vector<Rect> candidates;
    538.  
    539.     for( double factor = 1; ; factor *= scaleFactor )
    540.     {
    541.         Size originalWindowSize = data.origWinSize;
    542.  
    543.         Size windowSize( cvRound(originalWindowSize.width*factor), cvRound(originalWindowSize.height*factor) );
    544.         Size scaledImageSize( cvRound( grayImage.cols/factor ), cvRound( grayImage.rows/factor ) );
    545.         Size processingRectSize( scaledImageSize.width - originalWindowSize.width, scaledImageSize.height - originalWindowSize.height );
    546.  
    547.         if( processingRectSize.width <= 0 || processingRectSize.height <= 0 )
    548.             break;
    549.         if( windowSize.width > maxObjectSize.width || windowSize.height > maxObjectSize.height )
    550.             break;
    551.         if( windowSize.width < minObjectSize.width || windowSize.height < minObjectSize.height )
    552.             continue;
    553.  
    554.         Mat scaledImage( scaledImageSize, CV_8U, imageBuffer.data );
    555.         resize( grayImage, scaledImage, scaledImageSize, 0, 0, INTER_LINEAR );
    556.  
    557.         int yStep = 4;
    558.         int stripCount, stripSize;
    559.  
    560.         const int PTS_PER_THREAD = 1000;
    561.         stripCount = ((processingRectSize.width/yStep)*(processingRectSize.height + yStep-1)/yStep + PTS_PER_THREAD/2)/PTS_PER_THREAD;
    562.         stripCount = std::min(std::max(stripCount, 1), 100);
    563.         stripSize = (((processingRectSize.height + stripCount - 1)/stripCount + yStep-1)/yStep)*yStep;
    564.  
    565.         if( !detectSingleScale( scaledImage, stripCount, processingRectSize, stripSize, yStep, factor, candidates,
    566.             rejectLevels, levelWeights, outputRejectLevels ) )
    567.             break;
    568.     }
    569.  
    570.  
    571.     objects.resize(candidates.size());
    572.     std::copy(candidates.begin(), candidates.end(), objects.begin());
    573.  
    574.     if( outputRejectLevels )
    575.     {
    576.         groupRectangles( objects, rejectLevels, levelWeights, minNeighbors, GROUP_EPS );
    577.     }
    578.     else
    579.     {
    580.         groupRectangles( objects, minNeighbors, GROUP_EPS );
    581.     }
    582. }
    583.  
    584. void HOGCascadeClassifier::detectMultiScale( const Mat& image, vector<Rect>& objects,
    585.                                           double scaleFactor, int minNeighbors,
    586.                                           int flags, Size minObjectSize, Size maxObjectSize)
    587. {
    588.     vector<int> fakeLevels;
    589.     vector<double> fakeWeights;
    590.     detectMultiScale( image, objects, fakeLevels, fakeWeights, scaleFactor,
    591.         minNeighbors, flags, minObjectSize, maxObjectSize, false );
    592. }
    593.  
    594. void HOGCascadeClassifier::setMaskGenerator(Ptr<MaskGenerator> _maskGenerator)
    595. {
    596.     maskGenerator=_maskGenerator;
    597. }
    598. Ptr<HOGCascadeClassifier::MaskGenerator> HOGCascadeClassifier::getMaskGenerator()
    599. {
    600.     return maskGenerator;
    601. }
    602.  
    603. }

    参考：

    https://github.com/Schmetzler/opencv3_CascadeHOGhttps://github.com/Schmetzler/opencv3_CascadeHOG

    综述行人检测算法 - 腾讯云开发者社区-腾讯云行人检测( Pedestrian Detection)一直是计算机视觉研究中的热点和难点。行人检测要解决的问题是：找出图像或视频帧中所有的行人，包括位置和大小，...https://cloud.tencent.com/developer/article/1526509

    https://github.com/watersink/hoghttps://github.com/watersink/hog

  • 相关阅读:
    开关电源模块 遥控开/关电路
    基于 PowerMax 架构的银行双活数据中心实践分享
    全职RISC-V芯片D1开发板使用adb串口COM连接设备和文件上传下载
    教育现代化浪潮下 “游戏化”教育加速入场
    全栈开发性能优化基础第七单元日考技能测
    Socket.D 基于消息的响应式应用层网络协议
    如何运营好技术相关的自媒体？
    uni-app - 城市选择索引列表 / 通过 A-Z 排序的城市列表（uview 组件库 IndexList 索引列表）
    电子邮件漏洞以及 S/MIME 如何提供帮助
    11.27学术报告听讲笔记
  • 原文地址：https://blog.csdn.net/cxyhjl/article/details/125556569