利用hog+svm（梯度方向直方图和支持向量机）实现物体检测

最近利用hog+svm做了一个物体检测的小程序，可以先给大家看看实验的结果。从照片中，检测出以任意姿态摆放在任意位置的公仔。（其实打算检测是红色的大公仔，但是小的公仔也被检测了出来，至于为什么会这样以及这个问题的解决方法，咱们下面可以接着讨论）

其实吧，网上关于hog和svm的教程和书籍也非常多。但是很少有那种让初学者或者不太了解相关内容的人一看就懂的文章或是博客。反正我是看了好多的博客，文章，又找了程序动手做，才能大概理解程序的具体运行过程。所以，我这次重点做一下查漏补缺的工作，我把别人文章里经常会忽略掉的细节，同时也是初学者不太容易理解的地方，挑选出来，充分的捋一捋。

首先说hog，中文名为梯度方向直方图。这个网上的教程很多，我找了一个还不错的分享给大家：hog教程

教程里面讲解的非常详细，同时也有一些数学公式，刚开始看很可能一脸懵逼的。不过没关系，一开始只需要搞懂关键的问题就可以了。剩下的细节可以以后再慢慢的琢磨。

hog的话，相当于用一个滑动的窗口，在图像上从左到右，从上到下的滑动，每滑动到一个位置，计算其hog信息，重点要明白，这个hog信息，其实就是一个1*n的矩阵，说白了就是一个矢量，这个矢量就代表了这个窗口内的信息。

在物体检测方面，这个窗口内有或者没有我要检测的物体，其得到的hog矢量应该是有不同的。但是怎么去比较不同呢，很有肯能是上百维度甚至上千维度的矢量，这时候用svm就是一个很好的选择。

接下来说svm，也叫支持向量机，具体的教程可以看这里：svm教程

同样的，里面有很多数学公式，一时看不懂耶没关系，明白一点就可以了。svm就是一个二值分类器，能够将矢量进行二值分类。

说白了，给它一堆矢量，告诉它这些都是a类型，再给另外一堆矢量，告诉它这些矢量都是b类型，然后让svm自己去训练就好了。它能够训练出一个不错的方法，使得你再给它一个矢量的时候，它可以告诉你这个矢量是属于a类型还是b类型。

说到这里，hog+svm 检测物体的原理基本上也就全都说清楚了。将详细的过程再描述一遍，以本文检测公仔为例子：

1.首先需要确定hog检测窗口的大小，这里以64*64像素大小的方框作为检测窗口。

1.为了让svm得到充足的训练，首先要准备大量的正负样本。这里我收集了各个姿态下的公仔的图片，共3000多张，这些样本都是正样本，且都为64*64像素大小。如图：

2.同样的，还需要负样本，在没有公仔的场地内随意的拍照吧，大小也需要时64*64才行，共收集了15万张负样本图片，负样本图片里面都是不含有公仔的。（其实这里我偷了个懒，我用高分辨率的相机拍了很多照片，然后在这些照片中去截取64*64大小的像素块作为负样本，这样，一张普通的图片可以截取出上百张负样本图片，对于收集数据来说比较省事），如图：

3.然后，将正负样本送入svm中进行训练，得到一个可以检测正负样本的结果。（看着数据量不少，几十万张图片，其实运算速度还好，我用个普通的电脑，这个训练的过程也就用了大概十分钟吧。其实，这只是个例子，真正要训练的话，这些数量的训练数据还是不够的）

4.然后就需要对图片中的物体进行检测了。以64*64的滑动窗口在图像上滑动，每滑动到一个位置，计算其hog特征，然后给svm产生的结果进行比较。如果方框里有我们要找的物体，那么理论上可以将这个hog特征归类为正样本的类别，这就完成了物体的检测。

这里有个细节性的东西，图片中物体的大小不一样，如何以一个固定大小的窗口去检测大小不同的物体。其实，道理是，滑动窗口的大小不变，但是图片的尺度是可以放大缩小的。所以实际操作中，窗口大小始终为64*64，但是将图片放大缩小到多个分辨率上进行检测，就可以发现不同位置，不同大小的物体了。

5.由于滑动窗口移动的步长非常短，所以一个物体很有可能被检测出很多次，这些个检测出的框会密密麻麻的框住同一个物体。所以，后期还需要把这些同一个物体上的不同的框合成为一个。主要是根据框之间的距离和大小来进行方框的合并。最后合并完之后，就像下图一样：

然后对结果进行分析：

训练的时候，以红色的大公仔作为正样本，场地内不包含公仔的一些随机的场景图片作为负样本进行训练，理论上来讲，最理想的效果是应该能够检测出指定的红色大公仔。但是实际的结果是将红色的大公仔和蓝色的小公仔都检测出来了（有的时候还有可能把场地内没有公仔的地方检测出有公仔），这就说明，表示红色大公仔的hog特征和蓝色小公仔的hog特征有点相似，为了避免这种情况，可以再进行训练，训练的时候，把蓝色小公仔的图片作为负样本输入训练集，同样的，对于其他的没有物体而检测出物体的地方，也作为负样本输入，将本来有公仔但是没有检测出来的地方，同样也手动标出来作为正样本输入训练集。这样的过程可以重复几次。经过这种重复的训练，并且对正负样本进行校正，可以大大提高检测的准确度！

对了，最后把代码附上来：（代码中，上面被注释的一部分，是训练svm的代码，下面的一部分，是用训练好的svm模型来进行物体检测）

//#include<iostream>
//using namespace std;
//int main()
//{
//	cout<<"Hello World"<<endl;
//	return 0
//}
//#include "cui_hog_slow.h"
//#include"cui_hog.h"
#include<ctime>
#include <iostream>
#include <fstream>
#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include <opencv2/objdetect/objdetect.hpp>
#include <opencv2/ml/ml.hpp>

using namespace std;
using namespace cv;

#define squ 64       //方框的边长
#define PosSamNO 3513   //正样本个数
#define NegSamNO 157160    //负样本个数

#define TRAIN true    //是否进行训练,true表示重新训练，false表示读取xml文件中的SVM模型
#define CENTRAL_CROP true   //true:训练时，对96*160的INRIA正样本图片剪裁出中间的64*128大小人体

//HardExample：负样本个数。如果HardExampleNO大于0，表示处理完初始负样本集后，继续处理HardExample负样本集。
//不使用HardExample时必须设置为0，因为特征向量矩阵和特征类别矩阵的维数初始化时用到这个值
#define HardExampleNO 0  


//继承自CvSVM的类，因为生成setSVMDetector()中用到的检测子参数时，需要用到训练好的SVM的decision_func参数，
//但通过查看CvSVM源码可知decision_func参数是protected类型变量，无法直接访问到，只能继承之后通过函数访问
class MySVM : public CvSVM
{
public:
  //获得SVM的决策函数中的alpha数组
  double * get_alpha_vector()
  {
    return this->decision_func->alpha;
  }

  //获得SVM的决策函数中的rho参数,即偏移量
  float get_rho()
  {
    return this->decision_func->rho;
  }
};




int main()
{
	
 // //检测窗口(96,96),块尺寸(16,16),块步长(8,8),cell尺寸(8,8),直方图bin个数9
 // HOGDescriptor hog(Size(squ,squ),Size(16,16),Size(8,8),Size(8,8),9);//HOG检测器，用来计算HOG描述子的
 // int DescriptorDim;//HOG描述子的维数，由图片大小、检测窗口大小、块大小、细胞单元中直方图bin个数决定
 // MySVM svm;//SVM分类器

 // //若TRAIN为true，重新训练分类器
 // if(TRAIN)
 // {
 //   //string ImgName;//图片名(绝对路径)
 //   ifstream finPos("INRIAPerson96X160PosList.txt");//正样本图片的文件名列表
 //   //ifstream finPos("PersonFromVOC2012List.txt");//正样本图片的文件名列表
 //   ifstream finNeg("NoPersonFromINRIAList.txt");//负样本图片的文件名列表

 //   Mat sampleFeatureMat;//所有训练样本的特征向量组成的矩阵，行数等于所有样本的个数，列数等于HOG描述子维数	
 //   Mat sampleLabelMat;//训练样本的类别向量，行数等于所有样本的个数，列数等于1；1表示有人，-1表示无人


 //   //依次读取正样本图片，生成HOG描述子
 //   //for(int num=1; num<(PosSamNO+1) && getline(finPos,ImgName); num++)
	//for(int num=0; num<PosSamNO; num++)
 //   {
	//  string ImgName;//图片名(绝对路径)
	//  stringstream stream;  
	//  stream<<(num+1);  
	//  ImgName=stream.str(); 
 //     cout<<"处理："<<ImgName<<endl;
 //     //ImgName = "D:\\DataSet\\PersonFromVOC2012\\" + ImgName;//加上正样本的路径名
	//  ImgName = "D:\\file\\ylab_copy\\photo\\true_64\\" + ImgName+".jpg";
	//  cout<<ImgName<<endl;
 //     //ImgName = "D:\\DataSet\\INRIAPerson\\INRIAPerson\\96X160H96\\Train\\pos\\" + ImgName;//加上正样本的路径名
 //     Mat src = imread(ImgName);//读取图片
 //     //if(CENTRAL_CROP)
 //      //src = src(Rect(16,16,64,128));//将96*160的INRIA正样本图片剪裁为64*128，即剪去上下左右各16个像素
 //     //resize(src,src,Size(64,128));

 //     vector<float> descriptors;//HOG描述子向量
 //     hog.compute(src,descriptors,Size(8,8));//计算HOG描述子，检测窗口移动步长(8,8)
 //     //cout<<"描述子维数："<<descriptors.size()<<endl;

 //     //处理第一个样本时初始化特征向量矩阵和类别矩阵，因为只有知道了特征向量的维数才能初始化特征向量矩阵
 //     if( 0 == num )
 //     {
 //       DescriptorDim = descriptors.size();//HOG描述子的维数
 //       //初始化所有训练样本的特征向量组成的矩阵，行数等于所有样本的个数，列数等于HOG描述子维数sampleFeatureMat
 //       sampleFeatureMat = Mat::zeros(PosSamNO+NegSamNO+HardExampleNO, DescriptorDim, CV_32FC1);
 //       //初始化训练样本的类别向量，行数等于所有样本的个数，列数等于1；1表示有人，0表示无人
 //       sampleLabelMat = Mat::zeros(PosSamNO+NegSamNO+HardExampleNO, 1, CV_32FC1);
 //     }

 //     //将计算好的HOG描述子复制到样本特征矩阵sampleFeatureMat
 //     for(int i=0; i<DescriptorDim; i++)
 //       sampleFeatureMat.at<float>(num,i) = descriptors[i];//第num个样本的特征向量中的第i个元素
 //     sampleLabelMat.at<float>(num,0) = 1;//正样本类别为1，有人
 //   }

 //   //依次读取负样本图片，生成HOG描述子
 //   //for(int num=1; num<(NegSamNO+1) && getline(finNeg,ImgName); num++)
	//for(int num=0; num<NegSamNO; num++)
 //   {
	//  string ImgName;//图片名(绝对路径)
	//  stringstream stream;  
	//  stream<<(num+1);  
	//  ImgName=stream.str(); 
 //     cout<<"处理："<<ImgName<<endl;
	//  ImgName = "D:\\file\\ylab_copy\\photo\\false_64\\" + ImgName+".jpg";
 //     //ImgName = "D:\\DataSet\\NoPersonFromINRIA\\" + ImgName;//加上负样本的路径名
 //     Mat src = imread(ImgName);//读取图片
 //     //resize(src,img,Size(64,128));

 //     vector<float> descriptors;//HOG描述子向量
 //     hog.compute(src,descriptors,Size(8,8));//计算HOG描述子，检测窗口移动步长(8,8)
 //     //cout<<"描述子维数："<<descriptors.size()<<endl;

 //     //将计算好的HOG描述子复制到样本特征矩阵sampleFeatureMat
 //     for(int i=0; i<DescriptorDim; i++)
 //       sampleFeatureMat.at<float>(num+PosSamNO,i) = descriptors[i];//第PosSamNO+num个样本的特征向量中的第i个元素
 //     sampleLabelMat.at<float>(num+PosSamNO,0) = -1;//负样本类别为-1，无人
 //   }

 //   //处理HardExample负样本
 //   //if(HardExampleNO > 0)
 //   //{
 //   //  ifstream finHardExample("HardExample_2400PosINRIA_12000NegList.txt");//HardExample负样本的文件名列表
 //   //  //依次读取HardExample负样本图片，生成HOG描述子
 //   //  for(int num=0; num<HardExampleNO && getline(finHardExample,ImgName); num++)
 //   //  {
 //   //    cout<<"处理："<<ImgName<<endl;
 //   //    ImgName = "D:\\DataSet\\HardExample_2400PosINRIA_12000Neg\\" + ImgName;//加上HardExample负样本的路径名
 //   //    Mat src = imread(ImgName);//读取图片
 //   //    //resize(src,img,Size(64,128));

 //   //    vector<float> descriptors;//HOG描述子向量
 //   //    hog.compute(src,descriptors,Size(8,8));//计算HOG描述子，检测窗口移动步长(8,8)
 //   //    //cout<<"描述子维数："<<descriptors.size()<<endl;

 //   //    //将计算好的HOG描述子复制到样本特征矩阵sampleFeatureMat
 //   //    for(int i=0; i<DescriptorDim; i++)
 //   //      sampleFeatureMat.at<float>(num+PosSamNO+NegSamNO,i) = descriptors[i];//第PosSamNO+num个样本的特征向量中的第i个元素
 //   //    sampleLabelMat.at<float>(num+PosSamNO+NegSamNO,0) = -1;//负样本类别为-1，无人
 //   //  }
 //   //}

 //   输出样本的HOG特征向量矩阵到文件
 //   //ofstream fout("SampleFeatureMat.txt");
 //   //for(int i=0; i<PosSamNO+NegSamNO; i++)
 //   //{
 //   //	fout<<i<<endl;
 //   //	for(int j=0; j<DescriptorDim; j++)
 //   //		fout<<sampleFeatureMat.at<float>(i,j)<<"  ";
 //   //	fout<<endl;
 //   //}

 //   //训练SVM分类器
 //   //迭代终止条件，当迭代满1000次或误差小于FLT_EPSILON时停止迭代
 //   CvTermCriteria criteria = cvTermCriteria(CV_TERMCRIT_ITER+CV_TERMCRIT_EPS, 1000, FLT_EPSILON);
 //   //SVM参数：SVM类型为C_SVC；线性核函数；松弛因子C=0.01
 //   CvSVMParams param(CvSVM::C_SVC, CvSVM::LINEAR, 0, 1, 0, 0.01, 0, 0, 0, criteria);
 //   cout<<"开始训练SVM分类器"<<endl;
 //   svm.train(sampleFeatureMat, sampleLabelMat, Mat(), Mat(), param);//训练分类器
 //   cout<<"训练完成"<<endl;
 //   svm.save("SVM_HOG.xml");//将训练好的SVM模型保存为xml文件

 // }
 // else //若TRAIN为false，从XML文件读取训练好的分类器
 // {
 //   svm.load("SVM_HOG_2400PosINRIA_12000Neg_HardExample(误报少了漏检多了).xml");//从XML文件读取训练好的SVM模型
 // }








 // //*************************************************************************************************
 // // 线性SVM训练完成后得到的XML文件里面，有一个数组，叫做support vector，还有一个数组，叫做alpha,有一个浮点数，叫做rho;
 // //将alpha矩阵同support vector相乘，注意，alpha*supportVector,将得到一个列向量。之后，再该列向量的最后添加一个元素rho。
 // //如此，变得到了一个分类器，利用该分类器，直接替换opencv中行人检测默认的那个分类器（cv::HOGDescriptor::setSVMDetector()），
 // //就可以利用你的训练样本训练出来的分类器进行行人检测了。
 // //***************************************************************************************************/
 // DescriptorDim = svm.get_var_count();//特征向量的维数，即HOG描述子的维数
 // int supportVectorNum = svm.get_support_vector_count();//支持向量的个数
 // cout<<"支持向量个数："<<supportVectorNum<<endl;

 // Mat alphaMat = Mat::zeros(1, supportVectorNum, CV_32FC1);//alpha向量，长度等于支持向量个数
 // Mat supportVectorMat = Mat::zeros(supportVectorNum, DescriptorDim, CV_32FC1);//支持向量矩阵
 // Mat resultMat = Mat::zeros(1, DescriptorDim, CV_32FC1);//alpha向量乘以支持向量矩阵的结果

 // //将支持向量的数据复制到supportVectorMat矩阵中
 // for(int i=0; i<supportVectorNum; i++)
 // {
 //   const float * pSVData = svm.get_support_vector(i);//返回第i个支持向量的数据指针
 //   for(int j=0; j<DescriptorDim; j++)
 //   {
 //     //cout<<pData[j]<<" ";
 //     supportVectorMat.at<float>(i,j) = pSVData[j];
 //   }
 // }

 // //将alpha向量的数据复制到alphaMat中
 // double * pAlphaData = svm.get_alpha_vector();//返回SVM的决策函数中的alpha向量
 // for(int i=0; i<supportVectorNum; i++)
 // {
 //   alphaMat.at<float>(0,i) = pAlphaData[i];
 // }

 // //计算-(alphaMat * supportVectorMat),结果放到resultMat中
 // //gemm(alphaMat, supportVectorMat, -1, 0, 1, resultMat);//不知道为什么加负号？
 // resultMat = -1 * alphaMat * supportVectorMat;

 // //得到最终的setSVMDetector(const vector<float>& detector)参数中可用的检测子
 // vector<float> myDetector;
 // //将resultMat中的数据复制到数组myDetector中
 // for(int i=0; i<DescriptorDim; i++)
 // {
 //   myDetector.push_back(resultMat.at<float>(0,i));
 // }
 // //最后添加偏移量rho，得到检测子
 // myDetector.push_back(svm.get_rho());
 // cout<<"检测子维数："<<myDetector.size()<<endl;
 // //设置HOGDescriptor的检测子
 // HOGDescriptor myHOG(Size(squ,squ),Size(16,16),Size(8,8),Size(8,8),9);
 // myHOG.setSVMDetector(myDetector);
 // //myHOG.setSVMDetector(HOGDescriptor::getDefaultPeopleDetector());

 // //保存检测子参数到文件
 // ofstream fout("HOGDetector.txt");
 // for(int i=0; i<myDetector.size(); i++)
 // {
 //   fout<<myDetector[i]<<endl;
 // }
 // cout<<"训练完成！"<<endl;


  //**************读入图片进行HOG行人检测******************/



  vector<float> myDetector;
  float f;
  String ds;
  HOGDescriptor myHOG(Size(squ,squ),Size(16,16),Size(8,8),Size(8,8),9);
  ifstream finPos("HOGDetector_64.txt");
  while(getline(finPos,ds))
  {
	  //cout<<ds<<endl;
	  f=atof(ds.c_str());
	  myDetector.push_back(f);
	  //cout<<f<<endl;
  }
  myHOG.setSVMDetector(myDetector);


 
  Mat src = imread("D:\\file\\ylab_copy\\photo\\test\\5.jpg");
  
  Mat image;
  resize(src,image,Size(src.cols/2,src.rows/2));

  vector<Rect> found, found_filtered;//矩形框数组
  clock_t t1,t2,t3;//用来统计程序的运行时间
  t1=clock();
  myHOG.detectMultiScale(image, found, 0, Size(8,8), Size(32,32), 1.07, 2);
  //myHOG.detectMultiScale(image, found, 0, Size(8,8), Size(32,32), 1.05, 2);//对图片进行多尺度行人检测
  cout<<"找到的矩形框个数："<<found.size()<<endl;
  t2=clock();
  //找出所有没有嵌套的矩形框r,并放入found_filtered中,如果有嵌套的话,则取外面最大的那个矩形框放入found_filtered中
  for(int i=0; i < found.size(); i++)
  {
    Rect r = found[i];
    int j=0;
    for(; j < found.size(); j++)
      if(j != i && (r & found[j]) == r)  //按位与操作
        break;
    if( j == found.size())
      found_filtered.push_back(r);
  }
 
 
  for(int i=0; i<found.size(); i++)
  {
    Rect r = found[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(image, r.tl(), r.br(), Scalar(0,255,0), 3);
  }
      
  cout << t2-t1   << "/" << CLOCKS_PER_SEC  << " (s) "<< endl;
  cout << t3-t2   << "/" << CLOCKS_PER_SEC  << " (s) "<< endl;

  //imwrite("ImgProcessed.jpg",src);
  
  imshow("image",image);
  //imwrite("D:\\file\\ylab_copy\\photo\\result\\64\\1.jpg",image);
  waitKey(0);//
  
}