OpenCV中的HOG+SVM物体分类

http://blog.csdn.net/yongshengsilingsa/article/details/7535496

 

这里总结网上自己找到的资料，搞一个简单的框架供大家参考一下。

OpenCV官方的SVM代码在http://www.opencv.org.cn/opencvdoc/2.3.2/html/doc/tutorials/ml/introduction_to_svm/introduction_to_svm.html

在http://blog.csdn.net/sangni007/article/details/7471222看到一段还不错的代码，结构清楚，虽然注释比较少，但很有参考价值，于是我添加了一些注释，看着更舒服。废话少说，直接上代码：

[cpp] view plain copy print ?

1. [cpp] view plaincopyprint  
2. #include "cv.h"     
3. #include "highgui.h"     
4. #include "stdafx.h"     
5. #include <ml.h>     
6. #include <iostream>     
7. #include <fstream>     
8. #include <string>     
9. #include <vector>     
10. using namespace cv;    
11. using namespace std;    
12.     
13.     
14. int main(int argc, char** argv)      
15. {      
16.     vector<string> img_path;//输入文件名变量    
17.     vector<int> img_catg;    
18.     int nLine = 0;    
19.     string buf;    
20.     ifstream svm_data( "E:/SVM_DATA.txt" );//首先，这里搞一个文件列表，把训练样本图片的路径都写在这个txt文件中，使用bat批处理文件可以得到这个txt文件     
21.     unsigned long n;    
22.     
23.     while( svm_data )//将训练样本文件依次读取进来    
24.     {    
25.         if( getline( svm_data, buf ) )    
26.         {    
27.             nLine ++;    
28.             if( nLine % 2 == 0 )//这里的分类比较有意思，看得出来上面的SVM_DATA.txt文本中应该是一行是文件路径，接着下一行就是该图片的类别，可以设置为0或者1，当然多个也无所谓   
29.             {    
30.                  img_catg.push_back( atoi( buf.c_str() ) );//atoi将字符串转换成整型，标志（0,1），注意这里至少要有两个类别，否则会出错    
31.             }    
32.             else    
33.             {    
34.                 img_path.push_back( buf );//图像路径    
35.             }    
36.         }    
37.     }    
38.     svm_data.close();//关闭文件     
39.     
40.     CvMat *data_mat, *res_mat;    
41.     int nImgNum = nLine / 2; //读入样本数量 ，因为是每隔一行才是图片路径，所以要除以2   
42.     样本矩阵，nImgNum：横坐标是样本数量， WIDTH * HEIGHT：样本特征向量，即图像大小    
43.     data_mat = cvCreateMat( nImgNum, 1764, CV_32FC1 );  //这里第二个参数，即矩阵的列是由下面的descriptors的大小决定的，可以由descriptors.size()得到，且对于不同大小的输入训练图片，这个值是不同的  
44.     cvSetZero( data_mat );    
45.     //类型矩阵,存储每个样本的类型标志     
46.     res_mat = cvCreateMat( nImgNum, 1, CV_32FC1 );    
47.     cvSetZero( res_mat );    
48.     
49.     IplImage* src;    
50.     IplImage* trainImg=cvCreateImage(cvSize(64,64),8,3);//需要分析的图片，这里默认设定图片是64*64大小，所以上面定义了1764，如果要更改图片大小，可以先用debug查看一下descriptors是多少，然后设定好再运行    
51.     
52.     //开始搞HOG特征   
53.     for( string::size_type i = 0; i != img_path.size(); i++ )    
54.     {    
55.             src=cvLoadImage(img_path[i].c_str(),1);    
56.             if( src == NULL )    
57.             {    
58.                 cout<<" can not load the image: "<<img_path[i].c_str()<<endl;    
59.                 continue;    
60.             }    
61.     
62.             cout<<" processing "<<img_path[i].c_str()<<endl;    
63.                    
64.             cvResize(src,trainImg);   //读取图片       
65.             HOGDescriptor *hog=new HOGDescriptor(cvSize(64,64),cvSize(16,16),cvSize(8,8),cvSize(8,8),9);  //具体意思见参考文章1,2       
66.             vector<float>descriptors;//结果数组       
67.             hog->compute(trainImg, descriptors,Size(1,1), Size(0,0)); //调用计算函数开始计算       
68.             cout<<"HOG dims: "<<descriptors.size()<<endl;    
69.             //CvMat* SVMtrainMat=cvCreateMat(descriptors.size(),1,CV_32FC1);    
70.             n=0;    
71.             for(vector<float>::iterator iter=descriptors.begin();iter!=descriptors.end();iter++)    
72.             {    
73.                 cvmSet(data_mat,i,n,*iter);//把HOG存储下来    
74.                 n++;    
75.             }    
76.                 //cout<<SVMtrainMat->rows<<endl;    
77.             cvmSet( res_mat, i, 0, img_catg[i] );    
78.             cout<<" end processing "<<img_path[i].c_str()<<" "<<img_catg[i]<<endl;    
79.     }    
80.         
81.                  
82.     CvSVM svm = CvSVM();//新建一个SVM       
83.     CvSVMParams param;//这里是参数   
84.     CvTermCriteria criteria;      
85.     criteria = cvTermCriteria( CV_TERMCRIT_EPS, 1000, FLT_EPSILON );      
86.     param = CvSVMParams( CvSVM::C_SVC, CvSVM::RBF, 10.0, 0.09, 1.0, 10.0, 0.5, 1.0, NULL, criteria );      
87. /*     
88.     SVM种类：CvSVM::C_SVC     
89.     Kernel的种类：CvSVM::RBF     
90.     degree：10.0（此次不使用）     
91.     gamma：8.0     
92.     coef0：1.0（此次不使用）     
93.     C：10.0     
94.     nu：0.5（此次不使用）     
95.     p：0.1（此次不使用）     
96.     然后对训练数据正规化处理，并放在CvMat型的数组里。     
97.                                                         */         
98.     //☆☆☆☆☆☆☆☆☆(5)SVM学习☆☆☆☆☆☆☆☆☆☆☆☆           
99.     svm.train( data_mat, res_mat, NULL, NULL, param );//训练啦      
100.     //☆☆利用训练数据和确定的学习参数,进行SVM学习☆☆☆☆        
101.     svm.save( "SVM_DATA.xml" );  
102.     
103.     //检测样本     
104.     IplImage *test;    
105.     vector<string> img_tst_path;    
106.     ifstream img_tst( "E:/SVM_TEST.txt" );//同输入训练样本，这里也是一样的，只不过不需要标注图片属于哪一类了  
107.     while( img_tst )    
108.     {    
109.         if( getline( img_tst, buf ) )    
110.         {    
111.             img_tst_path.push_back( buf );    
112.         }    
113.     }    
114.     img_tst.close();    
115.     
116.     
117.     
118.     CvMat *test_hog = cvCreateMat( 1, 1764, CV_32FC1 );//注意这里的1764，同上面一样    
119.     char line[512];    
120.     ofstream predict_txt( "SVM_PREDICT.txt" );//把预测结果存储在这个文本中    
121.     for( string::size_type j = 0; j != img_tst_path.size(); j++ )//依次遍历所有的待检测图片    
122.     {    
123.         test = cvLoadImage( img_tst_path[j].c_str(), 1);    
124.         if( test == NULL )    
125.         {    
126.              cout<<" can not load the image: "<<img_tst_path[j].c_str()<<endl;    
127.                continue;    
128.          }    
129.             
130.         cvZero(trainImg);    
131.         cvResize(test,trainImg);   //读取图片       
132.         HOGDescriptor *hog=new HOGDescriptor(cvSize(64,64),cvSize(16,16),cvSize(8,8),cvSize(8,8),9);  //具体意思见参考文章1,2       
133.         vector<float>descriptors;//结果数组       
134.         hog->compute(trainImg, descriptors,Size(1,1), Size(0,0)); //调用计算函数开始计算       
135.         cout<<"HOG dims: "<<descriptors.size()<<endl;    
136.         CvMat* SVMtrainMat=cvCreateMat(1,descriptors.size(),CV_32FC1);    
137.         n=0;    
138.         for(vector<float>::iterator iter=descriptors.begin();iter!=descriptors.end();iter++)    
139.             {    
140.                 cvmSet(SVMtrainMat,0,n,*iter);    
141.                 n++;    
142.             }    
143.     
144.         int ret = svm.predict(SVMtrainMat);//获取最终检测结果，这个predict的用法见 OpenCV的文档   
145.         std::sprintf( line, "%s %d\r\n", img_tst_path[j].c_str(), ret );    
146.         predict_txt<<line;    
147.     }    
148.     predict_txt.close();    
149.     
150. //cvReleaseImage( &src);     
151. //cvReleaseImage( &sampleImg );    
152. //cvReleaseImage( &tst );     
153. //cvReleaseImage( &tst_tmp );    
154. cvReleaseMat( &data_mat );    
155. cvReleaseMat( &res_mat );    
156.     
157. return 0;    
158. }    

[cpp] view plaincopyprint
#include "cv.h"  
#include "highgui.h"  
#include "stdafx.h"  
#include <ml.h>  
#include <iostream>  
#include <fstream>  
#include <string>  
#include <vector>  
using namespace cv;  
using namespace std;  
  
  
int main(int argc, char** argv)    
{    
    vector<string> img_path;//输入文件名变量 
    vector<int> img_catg;  
    int nLine = 0;  
    string buf;  
    ifstream svm_data( "E:/SVM_DATA.txt" );//首先，这里搞一个文件列表，把训练样本图片的路径都写在这个txt文件中，使用bat批处理文件可以得到这个txt文件   
    unsigned long n;  
  
    while( svm_data )//将训练样本文件依次读取进来  
    {  
        if( getline( svm_data, buf ) )  
        {  
            nLine ++;  
            if( nLine % 2 == 0 )//这里的分类比较有意思，看得出来上面的SVM_DATA.txt文本中应该是一行是文件路径，接着下一行就是该图片的类别，可以设置为0或者1，当然多个也无所谓 
            {  
                 img_catg.push_back( atoi( buf.c_str() ) );//atoi将字符串转换成整型，标志（0,1），注意这里至少要有两个类别，否则会出错  
            }  
            else  
            {  
                img_path.push_back( buf );//图像路径  
            }  
        }  
    }  
    svm_data.close();//关闭文件  
  
    CvMat *data_mat, *res_mat;  
    int nImgNum = nLine / 2; //读入样本数量 ，因为是每隔一行才是图片路径，所以要除以2 
    样本矩阵，nImgNum：横坐标是样本数量， WIDTH * HEIGHT：样本特征向量，即图像大小  
    data_mat = cvCreateMat( nImgNum, 1764, CV_32FC1 );  //这里第二个参数，即矩阵的列是由下面的descriptors的大小决定的，可以由descriptors.size()得到，且对于不同大小的输入训练图片，这个值是不同的
    cvSetZero( data_mat );  
    //类型矩阵,存储每个样本的类型标志  
    res_mat = cvCreateMat( nImgNum, 1, CV_32FC1 );  
    cvSetZero( res_mat );  
  
    IplImage* src;  
    IplImage* trainImg=cvCreateImage(cvSize(64,64),8,3);//需要分析的图片，这里默认设定图片是64*64大小，所以上面定义了1764，如果要更改图片大小，可以先用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: "<<img_path[i].c_str()<<endl;  
                continue;  
            }  
  
            cout<<" processing "<<img_path[i].c_str()<<endl;  
                 
            cvResize(src,trainImg);   //读取图片     
            HOGDescriptor *hog=new HOGDescriptor(cvSize(64,64),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<<"HOG dims: "<<descriptors.size()<<endl;  
            //CvMat* SVMtrainMat=cvCreateMat(descriptors.size(),1,CV_32FC1);  
            n=0;  
            for(vector<float>::iterator iter=descriptors.begin();iter!=descriptors.end();iter++)  
            {  
                cvmSet(data_mat,i,n,*iter);//把HOG存储下来  
                n++;  
            }  
                //cout<<SVMtrainMat->rows<<endl;  
            cvmSet( res_mat, i, 0, img_catg[i] );  
            cout<<" end processing "<<img_path[i].c_str()<<" "<<img_catg[i]<<endl;  
    }  
      
               
    CvSVM svm = CvSVM();//新建一个SVM    
    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, NULL, NULL, param );//训练啦    
    //☆☆利用训练数据和确定的学习参数,进行SVM学习☆☆☆☆     
    svm.save( "SVM_DATA.xml" );
  
    //检测样本  
    IplImage *test;  
    vector<string> img_tst_path;  
    ifstream img_tst( "E:/SVM_TEST.txt" );//同输入训练样本，这里也是一样的，只不过不需要标注图片属于哪一类了
    while( img_tst )  
    {  
        if( getline( img_tst, buf ) )  
        {  
            img_tst_path.push_back( buf );  
        }  
    }  
    img_tst.close();  
  
  
  
    CvMat *test_hog = cvCreateMat( 1, 1764, CV_32FC1 );//注意这里的1764，同上面一样  
    char line[512];  
    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: "<<img_tst_path[j].c_str()<<endl;  
               continue;  
         }  
          
        cvZero(trainImg);  
        cvResize(test,trainImg);   //读取图片     
        HOGDescriptor *hog=new HOGDescriptor(cvSize(64,64),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<<"HOG dims: "<<descriptors.size()<<endl;  
        CvMat* SVMtrainMat=cvCreateMat(1,descriptors.size(),CV_32FC1);  
        n=0;  
        for(vector<float>::iterator iter=descriptors.begin();iter!=descriptors.end();iter++)  
            {  
                cvmSet(SVMtrainMat,0,n,*iter);  
                n++;  
            }  
  
        int ret = svm.predict(SVMtrainMat);//获取最终检测结果，这个predict的用法见 OpenCV的文档 
		std::sprintf( line, "%s %d\r\n", img_tst_path[j].c_str(), ret );  
        predict_txt<<line;  
    }  
    predict_txt.close();  
  
//cvReleaseImage( &src);  
//cvReleaseImage( &sampleImg );  
//cvReleaseImage( &tst );  
//cvReleaseImage( &tst_tmp );  
cvReleaseMat( &data_mat );  
cvReleaseMat( &res_mat );  
  
return 0;  
}  

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

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

[cpp] view plain copy print ?

1. #include "stdafx.h"   
2.   
3. #include "cv.h"     
4. #include "highgui.h"     
5. #include "stdafx.h"     
6. #include <ml.h>     
7. #include <iostream>     
8. #include <fstream>     
9. #include <string>     
10. #include <vector>     
11. using namespace cv;    
12. using namespace std;    
13.     
14.     
15. int main(int argc, char** argv)      
16. {      
17.     int ImgWidht = 120;  
18.     int ImgHeight = 120;  
19.     vector<string> img_path;    
20.     vector<int> img_catg;    
21.     int nLine = 0;    
22.     string buf;    
23.     ifstream svm_data( "E:/apple/SVM_DATA.txt" );    
24.     unsigned long n;    
25.     
26.     while( svm_data )    
27.     {    
28.         if( getline( svm_data, buf ) )    
29.         {    
30.             nLine ++;    
31.             if( nLine < 5 )    
32.             {    
33.                 img_catg.push_back(1);  
34.                 img_path.push_back( buf );//图像路径   
35.             }    
36.             else    
37.             {    
38.                 img_catg.push_back(0);  
39.                 img_path.push_back( buf );//图像路径   
40.             }    
41.         }    
42.     }    
43.     svm_data.close();//关闭文件     
44.     
45.     Mat data_mat, res_mat;    
46.     int nImgNum = nLine;            //读入样本数量    
47.     样本矩阵，nImgNum：横坐标是样本数量， WIDTH * HEIGHT：样本特征向量，即图像大小    
48.     //data_mat = Mat::zeros( nImgNum, 12996, CV_32FC1 );      
49.     //类型矩阵,存储每个样本的类型标志     
50.     res_mat = Mat::zeros( nImgNum, 1, CV_32FC1 );    
51.     
52.     Mat src;    
53.     Mat trainImg = Mat::zeros(ImgHeight, ImgWidht, CV_8UC3);//需要分析的图片    
54.     
55.     for( string::size_type i = 0; i != img_path.size(); i++ )    
56.     {    
57.         src = imread(img_path[i].c_str(), 1);     
58.     
59.         cout<<" processing "<<img_path[i].c_str()<<endl;    
60.            
61.         resize(src, trainImg, cv::Size(ImgWidht,ImgHeight), 0, 0, INTER_CUBIC);  
62.         HOGDescriptor *hog=new HOGDescriptor(cvSize(ImgWidht,ImgHeight),cvSize(16,16),cvSize(8,8),cvSize(8,8), 9);  //具体意思见参考文章1,2       
63.         vector<float>descriptors;//结果数组       
64.         hog->compute(trainImg, descriptors, Size(1,1), Size(0,0)); //调用计算函数开始计算  
65.         if (i==0)  
66.         {  
67.              data_mat = Mat::zeros( nImgNum, descriptors.size(), CV_32FC1 ); //根据输入图片大小进行分配空间   
68.         }  
69.         cout<<"HOG dims: "<<descriptors.size()<<endl;     
70.         n=0;    
71.         for(vector<float>::iterator iter=descriptors.begin();iter!=descriptors.end();iter++)    
72.         {    
73.             data_mat.at<float>(i,n) = *iter;    
74.             n++;    
75.         }    
76.         //cout<<SVMtrainMat->rows<<endl;    
77.         res_mat.at<float>(i, 0) =  img_catg[i];    
78.         cout<<" end processing "<<img_path[i].c_str()<<" "<<img_catg[i]<<endl;    
79.     }    
80.                  
81.     CvSVM svm = CvSVM();  
82.     CvSVMParams param;    
83.     CvTermCriteria criteria;      
84.     criteria = cvTermCriteria( CV_TERMCRIT_EPS, 1000, FLT_EPSILON );      
85.     param = CvSVMParams( CvSVM::C_SVC, CvSVM::RBF, 10.0, 0.09, 1.0, 10.0, 0.5, 1.0, NULL, criteria );     
86.       
87. /*     
88.     SVM种类：CvSVM::C_SVC     
89.     Kernel的种类：CvSVM::RBF     
90.     degree：10.0（此次不使用）     
91.     gamma：8.0     
92.     coef0：1.0（此次不使用）     
93.     C：10.0     
94.     nu：0.5（此次不使用）     
95.     p：0.1（此次不使用）     
96.     然后对训练数据正规化处理，并放在CvMat型的数组里。     
97.                                                         */         
98.     //☆☆☆☆☆☆☆☆☆(5)SVM学习☆☆☆☆☆☆☆☆☆☆☆☆           
99.     svm.train( data_mat, res_mat, Mat(), Mat(), param );      
100.     //☆☆利用训练数据和确定的学习参数,进行SVM学习☆☆☆☆        
101.     svm.save( "E:/apple/SVM_DATA.xml" );   
102.     
103.     //检测样本     
104.     vector<string> img_tst_path;    
105.     ifstream img_tst( "E:/apple/SVM_TEST.txt" );    
106.     while( img_tst )    
107.     {    
108.         if( getline( img_tst, buf ) )    
109.         {    
110.             img_tst_path.push_back( buf );    
111.         }    
112.     }    
113.     img_tst.close();    
114.     
115.     Mat test;  
116.     char line[512];    
117.     ofstream predict_txt( "E:/apple/SVM_PREDICT.txt" );    
118.     for( string::size_type j = 0; j != img_tst_path.size(); j++ )    
119.     {    
120.         test = imread( img_tst_path[j].c_str(), 1);//读入图像     
121.         resize(test, trainImg, cv::Size(ImgWidht,ImgHeight), 0, 0, INTER_CUBIC);//要搞成同样的大小才可以检测到         
122.         HOGDescriptor *hog=new HOGDescriptor(cvSize(ImgWidht,ImgHeight),cvSize(16,16),cvSize(8,8),cvSize(8,8),9);  //具体意思见参考文章1,2       
123.         vector<float>descriptors;//结果数组       
124.         hog->compute(trainImg, descriptors,Size(1,1), Size(0,0)); //调用计算函数开始计算   
125.         cout<<"The Detection Result:"<<endl;  
126.         cout<<"HOG dims: "<<descriptors.size()<<endl;    
127.         Mat SVMtrainMat =  Mat::zeros(1,descriptors.size(),CV_32FC1);    
128.         n=0;    
129.         for(vector<float>::iterator iter=descriptors.begin();iter!=descriptors.end();iter++)    
130.         {    
131.             SVMtrainMat.at<float>(0,n) = *iter;    
132.             n++;    
133.         }    
134.     
135.         int ret = svm.predict(SVMtrainMat);    
136.         std::sprintf( line, "%s %d\r\n", img_tst_path[j].c_str(), ret );   
137.         printf("%s %d\r\n", img_tst_path[j].c_str(), ret);  
138.         getchar();  
139.         predict_txt<<line;    
140.     }    
141.     predict_txt.close();    
142.     
143. return 0;    
144. }    

#include "stdafx.h"

#include "cv.h"  
#include "highgui.h"  
#include "stdafx.h"  
#include <ml.h>  
#include <iostream>  
#include <fstream>  
#include <string>  
#include <vector>  
using namespace cv;  
using namespace std;  
  
  
int main(int argc, char** argv)    
{    
	int ImgWidht = 120;
	int ImgHeight = 120;
    vector<string> 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 "<<img_path[i].c_str()<<endl;  
         
		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: "<<descriptors.size()<<endl;   
        n=0;  
        for(vector<float>::iterator iter=descriptors.begin();iter!=descriptors.end();iter++)  
        {  
			data_mat.at<float>(i,n) = *iter;  
            n++;  
        }  
        //cout<<SVMtrainMat->rows<<endl;  
	    res_mat.at<float>(i, 0) =  img_catg[i];  
        cout<<" end processing "<<img_path[i].c_str()<<" "<<img_catg[i]<<endl;  
    }  
               
    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<string> 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:"<<endl;
        cout<<"HOG dims: "<<descriptors.size()<<endl;  
        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<<line;  
    }  
    predict_txt.close();  
  
return 0;  
}  

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

如下为评论整理（本人）：

1、txt模板中的内容就是d:\img\1.jpg 

2、CvSVMParams params; 
      params.svm_type = CvSVM::C_SVC; 
      params.kernel_type = CvSVM::LINEAR;
    我在做分类的时候用的这个，但是出现： error C2653: “CvSVM”: 不是类或命名空间名称

     解决办法：CvSVM的头文件是ml.h，你要确认你包含了这个文件，你也可以再OpenCV里找到这个文件，我找了一下，看到里面确实有定义这个class，我用的OpenCV版本  是2.3.1，另外，确认你有using namespace cv

3、通过批处理bat可以得到txt文档，按照如下

      新建一个txt文档，输入
     dir /b/s/p/w *.jpg>train_list.txt
     @pause
     将文件后缀改为bat

4、提问：样本是怎么取的呢？要是检测人的时候，主把一个人的全身像扣下来？

      回复：样本看你自己取的了，你训练了什么样子的样本，那么测试的时候就只能测试哪个样的。例如，如果你把人抠出来做样本训练，那么当你检测的时候你也必须要先把人从背景中抠出来然后再扔进去做检测。把人从背景中抠出来可以排除背景的干扰，但是抠得不准确反而适得其反。

      提问：和背景一块儿训练背景变了不是就也检测不出来了？

      回复：对啊，如果你的训练样本中有没有把背景剔除掉，做检测的时候换了背景会有影响的，至于最终会有多大的影响就不好说了，如果你的训练样本够大，也许可以抵消掉这种影响。我现在做的东西就是觉得去背景太困难了，就连同背景一起训练了，最终效果也还好。

     提问：你用了GPU了吧？分辨率是多大的，这东东检测的时候速度太慢了吧，如果只用CPU。

     回复：从来没有用过GPU加速这种东西，也不用上，提取纹理的时候也许用的上。分辨率很低，图片最终大小差不多50*50。

5、如果正负总共两千样本的话，特征数目我用的是672，训练得到的分类器应该也就是最多几十兆吧，不会超过50M的，我目前用的正负样本总共有十万，特征向量维数是672，也就是160M

 6、程序到 svm.train( data_mat, res_mat, Mat(), Mat(), param ); 就会跳出error：OpenCV Error:Bad arguments： <There is only a single class> in cvPreprocessCategoricalResponse,file..\..\..\src\opencv\modules\ml\src\inner_functions.cpp,line 729是形参啥的传递错误还是怎样 ？

解决：应该是参数传统有问题，你点继续运行，看看调用堆栈哪里出错了，就是图像类型的分类 必须是两种图像的 虽然我不是很懂为啥 但分成多个图像就 OK了。

7、txt中存放的是正负样本，在这个txt文本中一行是图片文件名，接着下一行就是这个图片的类别。例如，第一行是一个图片文件名，然后接着的第二行就是表示一下这个图片属于哪一类，可以设定为0或者1，然后第三行又是图片文件名，然后第四行表示第三行的图片类别，0或者1。你可以规定类别1是正样本，0是负样本，最后测试一张图片，程序会告诉你这个图片属于1还是0。

8、实现：输入一张同样大小的图判断是否为正样本对应的内容。

9、输入的样本（SVM_DATA.txt）不需要一个正样本，一个负样本交替，只需要路径写对即可。

10、提问：关于SVM_DATA.txt 内容问题，我也是按照这样正负样本来写的txt文档：
                    D:\picture\1.bmp
                    0
                    D:\picture\2.bmp
                   1
               但是在运行时出现了问题，提示无法加载图像1\0；但是已经加载的图片生成了xml文件

    回复：文档没有写对吧 路径里的"回车"和“\”写混了

11、用hog提取了特征后，我一共有2000张样本，每张3758个特征，由于特征太大，无法将特征存为矩阵，该怎样解决

回复：特征依然保存为矩阵形式，每一行保存一张图像的N维特征，对你来说就是建立一个3758x2000的矩阵

12、CvSVM::train的时候出现error：命令行显示：OpenCV Error:Bad arguments： <There is only a single class> in cvPreprocessCategoricalResponse,file..\..\..\src\opencv\modules\ml\src\inner_functions.cpp,line 729，train的形参调试下都是正确的

       我的SVM_DATA.txt
       D:\picture\1.bmp
       0
       D:\picture\2.bmp
       1

回复：训练路径文档里的response写的不对 就是对应的类型 而且应该至少包含两种类型~，SVM_DATA.txt无错，0或者1就是response 类别名

 13、出现error C2065: 'HOGDescriptor' : undeclared identifier错误，增加#include "cvaux.h"头文件可顺利编译

14、E:/SVM_TEST.txt的内容

        路径名，类型名，一行一行交替排列~！
D:/img/001.jpg
1
D:/img/002.jpg
1
D:/img/003.jpg
0
...

15、descriptors的作用就是存储结果的特征向量

16、提问：hog特征检测的输入图像src 是什么形式的呢？rgb或者灰度图像都支持吧 ？
        IplImage* trainImg=cvCreateImage(cvSize(64,64),8,3);//需要分析的图片
        cvResize(src,trainImg); //读取图片

回复：文档中hog检测：CV_8UC1 and CV_8UC4 types are supported for now 一到四通道整型都支持。

17、svm.save( "SVM_DATA.xml" ); 这个保存XML文件的函数是OpenCV自带的。。。