OpenCV中的HOG+SVM物体分类

OpenCV中的HOG+SVM物体分类

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

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
plaincopyprint?

[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
plaincopyprint?

#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.