OpenCV Hog+SVM 学习

原文地址：http://blog.csdn.net/candyforever/article/details/8564746#comments

使用工具 ：VS2010 + OpenCV 2.4.3

手写数字库：http://code.google.com/p/supplement-of-the-mnist-database-of-handwritten-digits/downloads/list

Hog +SVM 训练10K个图片数据得到分类器：HOG_SVM_DATA.xml   整个过程大概需要5分钟左右，看个人电脑配置，若想提高正确率增大训练样本！

有关批处理的命令见下一篇博客，大家共同学习！

 #include "stdafx.h"
 #include "opencv2/opencv.hpp"
 #include "windows.h"
 #include "fstream"
 using namespace std;
 using namespace cv;
 int _tmain(int argc, _TCHAR* argv[])
 {
     vector img_path;//输入文件名变量
     vector<int> img_catg;
     int nLine = 0;
     string buf;
     ifstream svm_data( "D:/nums/hb.txt" );//训练样本图片的路径都写在这个txt文件中，使用bat批处理文件可以得到这个txt文件
     unsigned long n;
     while( svm_data )//将训练样本文件依次读取进来
     {
         if( getline( svm_data, buf ) )
         {
             nLine ++;
             if( nLine % 2 == 0 )//注：奇数行是图片全路径，偶数行是标签
             {
                  img_catg.push_back( atoi( buf.c_str() ) );//atoi将字符串转换成整型，标志(0,1，2，...，9)，注意这里至少要有两个类别，否则会出错
             }
             else
             {
                 img_path.push_back( buf );//图像路径
             }
         }
     }
     svm_data.close();//关闭文件
     CvMat *data_mat, *res_mat;
     int nImgNum = nLine / 2; //nImgNum是样本数量，只有文本行数的一半，另一半是标签
     data_mat = cvCreateMat( nImgNum, 324, CV_32FC1 );  //第二个参数，即矩阵的列是由下面的descriptors的大小决定的，可以由descriptors.size()得到，且对于不同大小的输入训练图片，这个值是不同的
     cvSetZero( data_mat );
     //类型矩阵,存储每个样本的类型标志
     res_mat = cvCreateMat( nImgNum, 1, CV_32FC1 );
     cvSetZero( res_mat );
     IplImage* src;
     IplImage* trainImg=cvCreateImage(cvSize(28,28),8,3);//需要分析的图片，这里默认设定图片是28*28大小，所以上面定义了324，如果要更改图片大小，可以先用debug查看一下descriptors是多少，然后设定好再运行

     //处理HOG特征
     for( string::size_type i = 0; i != img_path.size(); i++ )
     {
             src=cvLoadImage(img_path[i].c_str(),1);
             if( src == NULL )
             {
                 cout<<" can not load the image: "<
                 continue;
             }

             cout<<" 处理： "<

             cvResize(src,trainImg);
             HOGDescriptor *hog=new HOGDescriptor(cvSize(28,28),cvSize(14,14),cvSize(7,7),cvSize(7,7),9);
             vector<float>descriptors;//存放结果
             hog->compute(trainImg, descriptors,Size(1,1), Size(0,0)); //Hog特征计算
             cout<<"HOG dims: "<
             n=0;
             for(vector<float>::iterator iter=descriptors.begin();iter!=descriptors.end();iter++)
             {
                 cvmSet(data_mat,i,n,*iter);//存储HOG特征
                 n++;
             }
             cvmSet( res_mat, i, 0, img_catg[i] );
             cout<<" 处理完毕: "<" "<
     }


     CvSVM svm = CvSVM();//新建一个SVM
     CvSVMParams param;//这里是SVM训练相关参数
     CvTermCriteria criteria;
     criteria = cvTermCriteria( CV_TERMCRIT_EPS, 1000, FLT_EPSILON );
     param = CvSVMParams( CvSVM::C_SVC, CvSVM::RBF, 10.0, 0.09, 1.0, 10.0, 0.5, 1.0, NULL, criteria );

     svm.train( data_mat, res_mat, NULL, NULL, param );//训练数据
     //保存训练好的分类器
     svm.save( "HOG_SVM_DATA.xml" );

    //检测样本
     IplImage *test;
     char result[512];
     vector img_tst_path;
     ifstream img_tst( "D:/SVM_TEST.txt" );  //加载需要预测的图片集合，这个文本里存放的是图片全路径，不要标签
     while( img_tst )
     {
         if( getline( img_tst, buf ) )
         {
             img_tst_path.push_back( buf );
         }
     }
     img_tst.close();

     ofstream predict_txt( "SVM_PREDICT.txt" );//把预测结果存储在这个文本中
     for( string::size_type j = 0; j != img_tst_path.size(); j++ )//依次遍历所有的待检测图片
     {
         test = cvLoadImage( img_tst_path[j].c_str(), 1);
         if( test == NULL )
         {
             cout<<" can not load the image: "<
             continue;
         }
         IplImage* trainTempImg=cvCreateImage(cvSize(28,28),8,3);
         cvZero(trainTempImg);
         cvResize(test,trainTempImg);
         HOGDescriptor *hog=new HOGDescriptor(cvSize(28,28),cvSize(14,14),cvSize(7,7),cvSize(7,7),9);
         vector<float>descriptors;//结果数组
         hog->compute(trainTempImg, descriptors,Size(1,1), Size(0,0));
         cout<<"HOG dims: "<
         CvMat* SVMtrainMat=cvCreateMat(1,descriptors.size(),CV_32FC1);
          int n=0;
         for(vector<float>::iterator iter=descriptors.begin();iter!=descriptors.end();iter++)
         {
                cvmSet(SVMtrainMat,0,n,*iter);
                n++;
         }

         int ret = svm.predict(SVMtrainMat);//检测结果
         sprintf( result, "%s  %d\r\n",img_tst_path[j].c_str(),ret );
         predict_txt<//输出检测结果到文本
     }
         predict_txt.close();
         cvReleaseMat( &data_mat );
         cvReleaseMat( &res_mat );
         cvReleaseImage(&test);
         cvReleaseImage(&trainImg);
         return 0;
 }

训练样本hb.txt文本内容大致如下（总共20000行，批处理得到如下数据）：

总共有10个标签，0到9

待预测文本内容如下（同样批处理得到）：

预测结果文本内容如下：

后面的数字是预测结果，正确率还可以。

训练好了分类器，以后就不要再训练了，直接加载分类器

 #include "stdafx.h"
 #include "opencv2/opencv.hpp"
 #include "windows.h"
 #include "fstream"
 using namespace std;
 using namespace cv;
 int _tmain(int argc, _TCHAR* argv[])
 {

     CvSVM svm = CvSVM();
     svm.load("HOG_SVM_DATA.xml");//加载训练好的xml文件，这里训练的是10K个手写数字
     //检测样本
     IplImage *test;
     char result[300]; //存放预测结果
     test = cvLoadImage("5.bmp", 1); //待预测图片，用系统自带的画图工具随便手写
     if (!test)
      {
       MessageBox(NULL,TEXT("待预测图像不存在！"),TEXT("提示"),MB_ICONWARNING);
       return -1;
      }
      IplImage* trainTempImg=cvCreateImage(cvSize(28,28),8,3);
      cvZero(trainTempImg);
      cvResize(test,trainTempImg);
      HOGDescriptor *hog=new HOGDescriptor(cvSize(28,28),cvSize(14,14),cvSize(7,7),cvSize(7,7),9);
      vector<float>descriptors;//存放结果
      hog->compute(trainTempImg, descriptors,Size(1,1), Size(0,0)); //Hog特征计算
      cout<<"HOG dims: "<//打印Hog特征维数  ，这里是324
      CvMat* SVMtrainMat=cvCreateMat(1,descriptors.size(),CV_32FC1);
      int n=0;
      for(vector<float>::iterator iter=descriptors.begin();iter!=descriptors.end();iter++)
      {
            cvmSet(SVMtrainMat,0,n,*iter);
            n++;
       }

       int ret = svm.predict(SVMtrainMat);//检测结果
       sprintf(result, "%d\r\n",ret );
       cvNamedWindow("dst",1);
       cvShowImage("dst",test);
       MessageBox(NULL,result,TEXT("预测结果"),MB_OK);
       cvReleaseImage(&test);
       cvReleaseImage(&trainTempImg);
       return 0;
 }

待预测图像：

预测结果：

__________________________________________________________________________________________________________________

其中，关于HOG函数HOGDescriptor，见博客 http://blog.csdn.net/raocong2010/article/details/6239431

另外，自己需要把这个程序嵌入到另外一个工程中去，因为那里数据类型是Mat，不是cvMat，所以我又修改了上面的程序，并且图片大小也不是固定的64*64，需要自己设置一下图片大小，因为太懒，直接把改好的程序放过来：

 #include "stdafx.h"

 #include "cv.h"
 #include "highgui.h"
 #include "stdafx.h"
 #include
 #include
 #include
 #include
 #include
 using namespace cv;
 using namespace std;


 int main(int argc, char** argv)
 {
     int ImgWidht = 120;
     int ImgHeight = 120;
     vector img_path;
     vector<int> img_catg;
     int nLine = 0;
     string buf;
     ifstream svm_data( "E:/apple/SVM_DATA.txt" );
     unsigned long n;

     while( svm_data )
     {
         if( getline( svm_data, buf ) )
         {
             nLine ++;
             if( nLine < 5 )
             {
                 img_catg.push_back(1);
                 img_path.push_back( buf );//图像路径
             }
             else
             {
                 img_catg.push_back(0);
                 img_path.push_back( buf );//图像路径
             }
         }
     }
     svm_data.close();//关闭文件

     Mat data_mat, res_mat;
     int nImgNum = nLine;            //读入样本数量
     样本矩阵，nImgNum：横坐标是样本数量， WIDTH * HEIGHT：样本特征向量，即图像大小
     //data_mat = Mat::zeros( nImgNum, 12996, CV_32FC1 );
     //类型矩阵,存储每个样本的类型标志
     res_mat = Mat::zeros( nImgNum, 1, CV_32FC1 );

     Mat src;
     Mat trainImg = Mat::zeros(ImgHeight, ImgWidht, CV_8UC3);//需要分析的图片

     for( string::size_type i = 0; i != img_path.size(); i++ )
     {
         src = imread(img_path[i].c_str(), 1);

         cout<<" processing "<

         resize(src, trainImg, cv::Size(ImgWidht,ImgHeight), 0, 0, INTER_CUBIC);
         HOGDescriptor *hog=new HOGDescriptor(cvSize(ImgWidht,ImgHeight),cvSize(16,16),cvSize(8,8),cvSize(8,8), 9);  //具体意思见参考文章1,2
         vector<float>descriptors;//结果数组
         hog->compute(trainImg, descriptors, Size(1,1), Size(0,0)); //调用计算函数开始计算
         if (i==0)
         {
              data_mat = Mat::zeros( nImgNum, descriptors.size(), CV_32FC1 ); //根据输入图片大小进行分配空间
         }
         cout<<"HOG dims: "<
         n=0;
         for(vector<float>::iterator iter=descriptors.begin();iter!=descriptors.end();iter++)
         {
             data_mat.at<float>(i,n) = *iter;
             n++;
         }
         //cout<rows<
         res_mat.at<float>(i, 0) =  img_catg[i];
         cout<<" end processing "<" "<
     }

     CvSVM svm = CvSVM();
     CvSVMParams param;
     CvTermCriteria criteria;
     criteria = cvTermCriteria( CV_TERMCRIT_EPS, 1000, FLT_EPSILON );
     param = CvSVMParams( CvSVM::C_SVC, CvSVM::RBF, 10.0, 0.09, 1.0, 10.0, 0.5, 1.0, NULL, criteria );

 /*
     SVM种类：CvSVM::C_SVC
     Kernel的种类：CvSVM::RBF
     degree：10.0（此次不使用）
     gamma：8.0
     coef0：1.0（此次不使用）
     C：10.0
     nu：0.5（此次不使用）
     p：0.1（此次不使用）
     然后对训练数据正规化处理，并放在CvMat型的数组里。
                                                         */
     //☆☆☆☆☆☆☆☆☆(5)SVM学习☆☆☆☆☆☆☆☆☆☆☆☆
     svm.train( data_mat, res_mat, Mat(), Mat(), param );
     //☆☆利用训练数据和确定的学习参数,进行SVM学习☆☆☆☆
     svm.save( "E:/apple/SVM_DATA.xml" );

     //检测样本
     vector img_tst_path;
     ifstream img_tst( "E:/apple/SVM_TEST.txt" );
     while( img_tst )
     {
         if( getline( img_tst, buf ) )
         {
             img_tst_path.push_back( buf );
         }
     }
     img_tst.close();

     Mat test;
     char line[512];
     ofstream predict_txt( "E:/apple/SVM_PREDICT.txt" );
     for( string::size_type j = 0; j != img_tst_path.size(); j++ )
     {
         test = imread( img_tst_path[j].c_str(), 1);//读入图像
         resize(test, trainImg, cv::Size(ImgWidht,ImgHeight), 0, 0, INTER_CUBIC);//要搞成同样的大小才可以检测到
         HOGDescriptor *hog=new HOGDescriptor(cvSize(ImgWidht,ImgHeight),cvSize(16,16),cvSize(8,8),cvSize(8,8),9);  //具体意思见参考文章1,2
         vector<float>descriptors;//结果数组
         hog->compute(trainImg, descriptors,Size(1,1), Size(0,0)); //调用计算函数开始计算
         cout<<"The Detection Result:"<
         cout<<"HOG dims: "<
         Mat SVMtrainMat =  Mat::zeros(1,descriptors.size(),CV_32FC1);
         n=0;
         for(vector<float>::iterator iter=descriptors.begin();iter!=descriptors.end();iter++)
         {
             SVMtrainMat.at<float>(0,n) = *iter;
             n++;
         }

         int ret = svm.predict(SVMtrainMat);
         std::sprintf( line, "%s %d\r\n", img_tst_path[j].c_str(), ret );
         printf("%s %d\r\n", img_tst_path[j].c_str(), ret);
         getchar();
         predict_txt<
     }
     predict_txt.close();

 return 0;
 }

就到这里吧，再整理一下思路。
如果运行的时候出现Link错误，有可能是没有附加依赖项，要添加opencv_objdetect230d.lib，我的OpenCV是2.3版本，所以这里是230.