hog人体检测

opencv中的 HOGDescriptor 类

struct CV_EXPORTS_W HOGDescriptor  
{  
public:  
    enum { L2Hys=0 };  
    enum { DEFAULT_NLEVELS=64 };  
  
    CV_WRAP HOGDescriptor() : winSize(64,128), blockSize(16,16), blockStride(8,8),  
        cellSize(8,8), nbins(9), derivAperture(1), winSigma(-1),  
        histogramNormType(HOGDescriptor::L2Hys), L2HysThreshold(0.2), gammaCorrection(true),  
        nlevels(HOGDescriptor::DEFAULT_NLEVELS)  
    {}  
  
    CV_WRAP HOGDescriptor(Size _winSize, Size _blockSize, Size _blockStride,  
                  Size _cellSize, int _nbins, int _derivAperture=1, double _winSigma=-1,  
                  int _histogramNormType=HOGDescriptor::L2Hys,  
                  double _L2HysThreshold=0.2, bool _gammaCorrection=false,  
                  int _nlevels=HOGDescriptor::DEFAULT_NLEVELS)  
    : winSize(_winSize), blockSize(_blockSize), blockStride(_blockStride), cellSize(_cellSize),  
    nbins(_nbins), derivAperture(_derivAperture), winSigma(_winSigma),  
    histogramNormType(_histogramNormType), L2HysThreshold(_L2HysThreshold),  
    gammaCorrection(_gammaCorrection), nlevels(_nlevels)  
    {}  
  
    CV_WRAP HOGDescriptor(const String& filename)  
    {  
        load(filename);  
    }  
  
    HOGDescriptor(const HOGDescriptor& d)  
    {  
        d.copyTo(*this);  
    }  
  
    virtual ~HOGDescriptor() {}  
  
    CV_WRAP size_t getDescriptorSize() const;  
    CV_WRAP bool checkDetectorSize() const;  
    CV_WRAP double getWinSigma() const;  
  
    CV_WRAP virtual void setSVMDetector(InputArray _svmdetector);  
  
    virtual bool read(FileNode& fn);  
    virtual void write(FileStorage& fs, const String& objname) const;  
  
    CV_WRAP virtual bool load(const String& filename, const String& objname=String());  
    CV_WRAP virtual void save(const String& filename, const String& objname=String()) const;  
    virtual void copyTo(HOGDescriptor& c) const;  
  
    CV_WRAP virtual void compute(const Mat& img,  
                         CV_OUT vector<float>& descriptors,  
                         Size winStride=Size(), Size padding=Size(),  
                         const vector<Point>& locations=vector<Point>()) const;  
    //with found weights output  
    CV_WRAP virtual void detect(const Mat& img, CV_OUT vector<Point>& foundLocations,  
                        CV_OUT vector<double>& weights,  
                        double hitThreshold=0, Size winStride=Size(),  
                        Size padding=Size(),  
                        const vector<Point>& searchLocations=vector<Point>()) const;  
    //without found weights output  
    virtual void detect(const Mat& img, CV_OUT vector<Point>& foundLocations,  
                        double hitThreshold=0, Size winStride=Size(),  
                        Size padding=Size(),  
                        const vector<Point>& searchLocations=vector<Point>()) const;  
    //with result weights output  
    CV_WRAP virtual void detectMultiScale(const Mat& img, CV_OUT vector<Rect>& foundLocations,  
                                  CV_OUT vector<double>& foundWeights, double hitThreshold=0,  
                                  Size winStride=Size(), Size padding=Size(), double scale=1.05,  
                                  double finalThreshold=2.0,bool useMeanshiftGrouping = false) const;  
    //without found weights output  
    virtual void detectMultiScale(const Mat& img, CV_OUT vector<Rect>& foundLocations,  
                                  double hitThreshold=0, Size winStride=Size(),  
                                  Size padding=Size(), double scale=1.05,  
                                  double finalThreshold=2.0, bool useMeanshiftGrouping = false) const;  
  
    CV_WRAP virtual void computeGradient(const Mat& img, CV_OUT Mat& grad, CV_OUT Mat& angleOfs,  
                                 Size paddingTL=Size(), Size paddingBR=Size()) const;  
  
    CV_WRAP static vector<float> getDefaultPeopleDetector();  
    CV_WRAP static vector<float> getDaimlerPeopleDetector();  
  
    CV_PROP Size winSize;  
    CV_PROP Size blockSize;  
    CV_PROP Size blockStride;  
    CV_PROP Size cellSize;  
    CV_PROP int nbins;  
    CV_PROP int derivAperture;  
    CV_PROP double winSigma;  
    CV_PROP int histogramNormType;  
    CV_PROP double L2HysThreshold;  
    CV_PROP bool gammaCorrection;  
    CV_PROP vector<float> svmDetector;  
    CV_PROP int nlevels;  
  
  
   // evaluate specified ROI and return confidence value for each location  
   void detectROI(const cv::Mat& img, const vector<cv::Point> &locations,  
                                   CV_OUT std::vector<cv::Point>& foundLocations, CV_OUT std::vector<double>& confidences,  
                                   double hitThreshold = 0, cv::Size winStride = Size(),  
                                   cv::Size padding = Size()) const;  
  
   // evaluate specified ROI and return confidence value for each location in multiple scales  
   void detectMultiScaleROI(const cv::Mat& img,  
                                                       CV_OUT std::vector<cv::Rect>& foundLocations,  
                                                       std::vector<DetectionROI>& locations,  
                                                       double hitThreshold = 0,  
                                                       int groupThreshold = 0) const;  
  
   // read/parse Dalal's alt model file  
   void readALTModel(std::string modelfile);  
};  

其中hog.setSVMDetector(HOGDescriptor::getDefaultPeopleDetector());得到svm的检测算子。

hog.detectMultiScale(img, found, 0, Size(8,8), Size(32,32), 1.05, 2);得到检测的结果。

人体检测代码：

vector<Rect> getBodyArea(Mat rawFrame)
{
   vector<Rect> foundRect,foundFilteredRect;
   HOGDescriptor peopleDectectHog;
   peopleDectectHog .setSVMDetector (HOGDescriptor::getDefaultPeopleDetector());//默认人体检测器
 
   peopleDectectHog.detectMultiScale (rawFrame ,foundRect, 0 ,Size(8,8),Size(32,32),1.05,2);
   size_t i,j;
   for(i=0;i<foundRect.size() ;i++)//下面的这个for语句是找出所有没有嵌套的矩形框r,并放入found_filtered中,
   {//如果有嵌套的话,则取外面最大的那个矩形框放入found_filtered中

       Rect r=foundRect[i];

	   for(j=0;j<foundRect.size();j++)
	   {
		   if(j!=i&&(r&foundRect[j])==r)
			   break ;
	   }
	   if(j==foundRect.size())
		   foundFilteredRect .push_back (r);
   }
   for(i=0;i<foundFilteredRect.size ();i++)//调整大小
   {
      Rect r=foundFilteredRect [i];
	  r.x+=cvRound (r.width *0.1);
	  r.width =cvRound(r.width *0.8);
	  r.y+=cvRound(r.height *0.07);
	  r.height =cvRound(r.height *0.8);
	  rectangle (rawFrame ,r.tl(),r.br(),Scalar(0,255,0),3);

      
   }
   return foundFilteredRect ;
}

结果如下: