opencv行人检测里遇到的setSVMDetector()问题

参考了博客http://blog.csdn.net/carson2005/article/details/7841443 后，自己动手后发现了一些问题，博客里提到的一些问题没有解决

，是关于为什么图像的HOG特征向量debug后是15876的问题。答案是因为原作者的窗口是64*64的，所以维数为9*4*7*7=1764（图像的大小也是64*64，所以图像的特征维数与一个窗口的维数是相同的，compute()里的窗口步进（8,8）也是无效的）。而我的图像时64*128大小的，我把窗口也换成

64*128，所以维数就是3780了，与setSVMDetector默认的getDefaultPeopleDetector大小一样（大概小于getDefaultPeopleDetector（）大小为（3781*1））的vector传到setSVMDetector（）里都没关系吧，不会出现断言错误。

上代码：

/*
 * =====================================================================================
 *
 *       Filename:  people_detector.cpp
 *      Environment:    
 *    Description:  行人检测程序，程序里窗口大小和图片大小一样大，都是64*128
 *
 *
 *
 *        Version:  1.0
 *        Created:  2013/10/20 10:45:02
 *         Author:  yuliyang
I*
 *             Mail:  wzyuliyang911@gmail.com
 *             Blog:  http://www.cnblogs.com/yuliyang
 *
 * =====================================================================================
 */

#include "opencv2/opencv.hpp"
#include "windows.h"
#include "fstream"
#include <iostream>
using namespace std;
using namespace cv;
class Mysvm: public CvSVM
{
public:
    int get_alpha_count()
    {
        return this->sv_total;
    }

    int get_sv_dim()
    {
        return this->var_all;
    }

    int get_sv_count()
    {
        return this->decision_func->sv_count;
    }

    double* get_alpha()
    {
        return this->decision_func->alpha;
    }

    float** get_sv()
    {
        return this->sv;
    }

    float get_rho()
    {
        return this->decision_func->rho;
    }
};

int my_train()
{

    /*-----------------------------------------------------------------------------
     *  e:/pedestrianDetect-peopleFlow.txt是用来保存所有样本的特征，大小为样本数*3780(每个样本的特征数)
     *
     *
     *
     *
     *-----------------------------------------------------------------------------*/
    char classifierSavePath[256] = "e:/pedestrianDetect-peopleFlow.txt";
    string buf;
    vector<string> pos_img_path;
    vector<string> neg_img_path;
    ifstream svm_pos_data("pos.txt");           /* 批处理程序生成 */
    ifstream svm_neg_data("neg.txt");           /* 批处理生成 */
    while( svm_pos_data )//将训练样本文件依次读取进来    
    {    
        if( getline( svm_pos_data, buf ) )
            pos_img_path.push_back( buf );

    }
    while( svm_neg_data )//将训练样本文件依次读取进来    
    {    
        if( getline( svm_neg_data, buf ) )
            neg_img_path.push_back( buf );

    }
    cout<<pos_img_path.size()<<"个正样本"<<endl;
    cout<<neg_img_path.size()<<"个负样本"<<endl;
    int totalSampleCount=pos_img_path.size()+neg_img_path.size();
    CvMat *sampleFeaturesMat = cvCreateMat(totalSampleCount , 3780, CV_32FC1);
    //64*128窗口大小的训练样本，该矩阵将是totalSample*3780
    //64*64的窗口大小的训练样本，该矩阵将是totalSample*1764
    cvSetZero(sampleFeaturesMat);  
    CvMat *sampleLabelMat = cvCreateMat(totalSampleCount, 1, CV_32FC1);//样本标识  
    cvSetZero(sampleLabelMat);  

    cout<<"************************************************************"<<endl;
    cout<<"start to training positive samples..."<<endl;

    
    
    for(int i=0; i<pos_img_path.size(); i++)  
    {  
        cv::Mat img = cv::imread(pos_img_path.at(i));
    
        if( img.data == NULL )
        {
            cout<<"positive image sample load error: "<<i<<endl;
            system("pause");
            continue;
        }

        cv::HOGDescriptor hog(cv::Size(64,128), cv::Size(16,16), cv::Size(8,8), cv::Size(8,8), 9);
        vector<float> featureVec; 

        hog.compute(img, featureVec, cv::Size(8,8));  
        unsigned int featureVecSize = featureVec.size();

        for (int j=0; j<featureVecSize; j++)  
        {          
            CV_MAT_ELEM( *sampleFeaturesMat, float, i, j ) = featureVec[j]; 
        }  
        sampleLabelMat->data.fl[i] = 1;
    }
    cout<<"end of training for positive samples..."<<endl;

    cout<<"*********************************************************"<<endl;
    cout<<"start to train negative samples..."<<endl;
    
    for (int i=0; i<neg_img_path.size(); i++)
    {  
        
        cv::Mat img = cv::imread(neg_img_path.at(i));
        if(img.data == NULL)
        {
            cout<<"negative image sample load error: "<<endl;
            continue;
        }

        cv::HOGDescriptor hog(cv::Size(64,128), cv::Size(16,16), cv::Size(8,8), cv::Size(8,8), 9);  
        vector<float> featureVec; 

        hog.compute(img,featureVec,cv::Size(8,8));//计算HOG特征
        int featureVecSize = featureVec.size();  

        for ( int j=0; j<featureVecSize; j ++)  
        {  
            CV_MAT_ELEM( *sampleFeaturesMat, float, i + pos_img_path.size(), j ) = featureVec[ j ];
        }  

        sampleLabelMat->data.fl[ i + pos_img_path.size() ] = -1;
    }  

    cout<<"end of training for negative samples..."<<endl;
    cout<<"********************************************************"<<endl;
    cout<<"start to train for SVM classifier..."<<endl;

    CvSVMParams params;  
    params.svm_type = CvSVM::C_SVC;  
    params.kernel_type = CvSVM::LINEAR;  
    params.term_crit = cvTermCriteria(CV_TERMCRIT_ITER, 1000, FLT_EPSILON);
    params.C = 0.01;

    Mysvm svm;
    svm.train( sampleFeaturesMat, sampleLabelMat, NULL, NULL, params ); //用SVM线性分类器训练
    svm.save(classifierSavePath);

    cvReleaseMat(&sampleFeaturesMat);
    cvReleaseMat(&sampleLabelMat);

    int supportVectorSize = svm.get_support_vector_count();
    cout<<"support vector size of SVM："<<supportVectorSize<<endl;
    cout<<"************************ end of training for SVM ******************"<<endl;

    CvMat *sv,*alp,*re;//所有样本特征向量 
    sv  = cvCreateMat(supportVectorSize , 3780, CV_32FC1);
    alp = cvCreateMat(1 , supportVectorSize, CV_32FC1);
    re  = cvCreateMat(1 , 3780, CV_32FC1);
    CvMat *res  = cvCreateMat(1 , 1, CV_32FC1);

    cvSetZero(sv);
    cvSetZero(re);

    for(int i=0; i<supportVectorSize; i++)
    {
        memcpy( (float*)(sv->data.fl+i*3780), svm.get_support_vector(i), 3780*sizeof(float));    
    }

    double* alphaArr = svm.get_alpha();
    int alphaCount = svm.get_alpha_count();

    for(int i=0; i<supportVectorSize; i++)
    {
        alp->data.fl[i] = (float)alphaArr[i];
    }
    cvMatMul(alp, sv, re);

    int posCount = 0;
    for (int i=0; i<3780; i++)
    {
        re->data.fl[i] *= -1;
    }

    /*-----------------------------------------------------------------------------
     *  e:/hogSVMDetector-peopleFlow.txt文件中保存的是支持向量，共有3781个值，是一个3781*1的列向量
     *
     *
     *-----------------------------------------------------------------------------*/
    FILE* fp = fopen("e:/hogSVMDetector-peopleFlow.txt","wb");
    if( NULL == fp )
    {
        return 1;
    }
    for(int i=0; i<3780; i++)
    {
        fprintf(fp,"%f 
",re->data.fl[i]);
    }
    float rho = svm.get_rho();
    fprintf(fp, "%f", rho);
    cout<<"e:/hogSVMDetector.txt 保存完毕"<<endl;//保存HOG能识别的分类器
    fclose(fp);

    return 1;
}
void my_detect()
{
    CvCapture* cap = cvCreateFileCapture("E:\test.avi");
    if (!cap)
    {
        cout<<"avi file load error..."<<endl;
        system("pause");
        exit(-1);
    }

    vector<float> x;
    ifstream fileIn("e:/hogSVMDetector-peopleFlow.txt", ios::in);
    float val = 0.0f;
    while(!fileIn.eof())
    {
        fileIn>>val;
        x.push_back(val);
    }
    fileIn.close();

    vector<cv::Rect>  found;
    cv::HOGDescriptor hog(cv::Size(64,128), cv::Size(16,16), cv::Size(8,8), cv::Size(8,8), 9);
    
    /*-----------------------------------------------------------------------------
     *
     *
     *  如果setSVMDetector出现问题的话，可能是这个原因：因为默认hog.getDefaultPeopleDetector（）
     *  获取的检测器的大小是3781*1的列向量，所以如果生成的e:/hogSVMDetector-peopleFlow.txt里的大小不等的话
     *  ，读入
     *  就会出现错误，可能这个函数考虑了运行的速度问题，所以限制了大小为3781*1
     *  
     *  特别注意：有些童鞋可能生成的特征向量是15876（所以setSVMDetector里的列向量就是15877了与默认的大小不一，assetion就出错了）
     *  ，只要调整下图像的大小和检测窗口的大小，使生成的特征向量为3780就行了，怎么计算，可以参考
     *  网上其他博客
     *
     *-----------------------------------------------------------------------------*/
    hog.setSVMDetector(x);

    IplImage* img = NULL;
    cvNamedWindow("img", 0);
    while(img=cvQueryFrame(cap))
    {
        hog.detectMultiScale(img, found, 0, cv::Size(8,8), cv::Size(32,32), 1.05, 2);
        if (found.size() > 0)
        {
            for (int i=0; i<found.size(); i++)
            {
                CvRect tempRect = cvRect(found[i].x, found[i].y, found[i].width, found[i].height);

                cvRectangle(img, cvPoint(tempRect.x,tempRect.y),
                    cvPoint(tempRect.x+tempRect.width,tempRect.y+tempRect.height),CV_RGB(255,0,0), 2);
            }
        }
    }
    cvReleaseCapture(&cap);
}

int main(int argc, char** argv){

    //my_train();
    //my_detect();
    vector<float> x;
    ifstream fileIn("e:/hogSVMDetector-peopleFlow.txt", ios::in); /* 读入支持向量，没必要读入样本的向量 */
    float val = 0.0f;
    while(!fileIn.eof())
    {
        fileIn>>val;
        x.push_back(val);
    }
    fileIn.close();

    vector<Rect> found, found_filtered;
    cv::HOGDescriptor hog(cv::Size(64,128), cv::Size(16,16), cv::Size(8,8), cv::Size(8,8), 9);
    hog.setSVMDetector(x);

    Mat img;
    img=imread("1.jpg",0);
    hog.detectMultiScale(img, found, 0, cv::Size(8,8), cv::Size(32,32), 1.05, 2);
    size_t i, j;
    for( i = 0; i < found.size(); i++ )
    {
        Rect r = found[i];
        for( j = 0; j < found.size(); j++ )
            if( j != i && (r & found[j]) == r)
                break;
        if( j == found.size() )
            found_filtered.push_back(r);
    }
    for( i = 0; i < found_filtered.size(); i++ )
    {
        Rect r = found_filtered[i];
        // the HOG detector returns slightly larger rectangles than the real objects.
        // so we slightly shrink the rectangles to get a nicer output.
        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(img, r.tl(), r.br(), cv::Scalar(0,255,0), 3);
    }
    imshow("people detector", img);
    waitKey();

    /*cvNamedWindow("img", 0);
    string testimage="E:databasepicture_resize_pos
esize000r.bmp";
    Mat img=cv::imread(testimage);
    hog.detectMultiScale(img, found, 0, cv::Size(8,8), cv::Size(32,32), 1.05, 2);
    if (found.size() > 0)
    {
    printf("found!");
    }*/
        
    return 0;

}

运行效果：

正样本1500多个，负样本400多个，所以效果不咋地，只能呵呵了。

再上一张效果图：（ps:运行的太慢了）