opencv3.2 hog训练

本次是在一格长条上面训练"通过"关键词,我只准备了100多张样本,然后用起来的效果不是很好,没有耐心搞好多样本,不知道是不是样本量过少,还是其他问题,先把能跑的代码粘这里:

注意一开始运行是报错的,因为pro里面木有添加相关库 pro如下:

OPENCV_ROOT_PATH = /home/yhl/software
INCLUDEPATH += $${OPENCV_ROOT_PATH}/include \
               $${OPENCV_ROOT_PATH}/include/opencv \
               $${OPENCV_ROOT_PATH}/include/opencv2
LIBS += -L$${OPENCV_ROOT_PATH}/lib
LIBS += -lopencv_core \
        -lopencv_highgui \
        -lopencv_imgproc \
        -lopencv_imgcodecs \
        -lopencv_videoio \
        -lopencv_ml

LIBS += -L/usr/local/libs \
         -lopencv_objdetect

源代码如下:

#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;
using namespace  cv::ml;

#define PosSamNO 100
#define NegSamNO 51

#define TRAIN 0
#define CENTRAL_CROP true


#define HardExampleNO 0



void svm_hog_detect()
{
    //HOG检测器，用来计算HOG描述子的
    //检测窗口(48,48),块尺寸(16,16),块步长(8,8),cell尺寸(8,8),直方图bin个数9
    //  cv::HOGDescriptor hog(cv::Size(48, 48), cv::Size(16, 16), cv::Size(8, 8), cv::Size(8, 8), 9);
    HOGDescriptor hog(Size(64,32),Size(8,8),Size(4,4),Size(2,2),9);

    //HOG描述子的维数，由图片大小、检测窗口大小、块大小、细胞单元中直方图bin个数决定
    int DescriptorDim;

    //从XML文件读取训练好的SVM模型
    cv::Ptr<cv::ml::SVM> svm = cv::ml::SVM::load("SVM_HOG.xml");

    if (svm->empty())
    {
        std::cout << "load svm detector failed!!!" << std::endl;
        return;
    }

    //特征向量的维数，即HOG描述子的维数
    DescriptorDim = svm->getVarCount();

    //获取svecsmat，元素类型为float
    cv::Mat svecsmat = svm->getSupportVectors();
    //特征向量维数
    int svdim = svm->getVarCount();
    int numofsv = svecsmat.rows;

    //alphamat和svindex必须初始化，否则getDecisionFunction()函数会报错
    cv::Mat alphamat = cv::Mat::zeros(numofsv, svdim, CV_32F);
    cv::Mat svindex = cv::Mat::zeros(1, numofsv, CV_64F);

    cv::Mat Result;
    double rho = svm->getDecisionFunction(0, alphamat, svindex);
    //将alphamat元素的数据类型重新转成CV_32F
    alphamat.convertTo(alphamat, CV_32F);
    Result = -1 * alphamat * svecsmat;

    std::vector<float> vec;
    for (int i = 0; i < svdim; ++i)
    {
        vec.push_back(Result.at<float>(0, i));
    }
    vec.push_back(rho);

    //saving HOGDetectorForOpenCV.txt
    std::ofstream fout("HOGDetectorForOpenCV.txt");
    for (int i = 0; i < vec.size(); ++i)
    {
        fout << vec[i] << std::endl;
    }

    hog.setSVMDetector(vec);

    fstream infile("/media/d_2/everyday/0402/m_aim_part.txt");
    string str;
    while(infile>>str)
    {
        Mat frame=imread(str);
        std::vector<cv::Rect> found, found_1, found_filtered;
        //对图片进行多尺度检测
        hog.detectMultiScale(frame, found, 0, cv::Size(2, 2), cv::Size(8,8), 1.01, 2); //hog.detectMultiScale(frame, found, 0, cv::Size(4, 4), cv::Size(4,4), 1.2, 2);

        for (int i = 0; i<found.size(); i++)
        {
            if (found[i].x > 0 && found[i].y > 0 && (found[i].x + found[i].width)< frame.cols
                    && (found[i].y + found[i].height)< frame.rows)
                found_1.push_back(found[i]);
        }

        //找出所有没有嵌套的矩形框r,并放入found_filtered中,如果有嵌套的话,
        //则取外面最大的那个矩形框放入found_filtered中
        for (int i = 0; i < found_1.size(); i++)
        {
            cv::Rect r = found_1[i];
            int j = 0;
            for (; j < found_1.size(); j++)
                if (j != i && (r & found_1[j]) == found_1[j])
                    break;
            if (j == found_1.size())
                found_filtered.push_back(r);
        }

        //画矩形框，因为hog检测出的矩形框比实际目标框要稍微大些,所以这里需要做一些调整，可根据实际情况调整
        for (int i = 0; i<found_filtered.size(); i++)
        {
            cv::Rect r = found_filtered[i];
            //将检测矩形框缩小后绘制，根据实际情况调整
            r.x += cvRound(r.width*0.1);
            r.width = cvRound(r.width*0.8);
            r.y += cvRound(r.height*0.1);
            r.height = cvRound(r.height*0.8);
        }

        for (int i = 0; i<found_filtered.size(); i++)
        {
            cv::Rect r = found_filtered[i];

            cv::rectangle(frame, r.tl(), r.br(), cv::Scalar(0, 0, 255), 2);

        }
        cv::imshow("detect result", frame);
        waitKey(0);

    }
    //cv::resize(frame, frame, cv::Size(width / 2, height / 2));

    //目标矩形框数组

    return;
}


int main()
{

    HOGDescriptor hog(Size(64,32),Size(8,8),Size(4,4),Size(2,2),9);
    int DescriptorDim;
    // MySVM svm;

    cv::Ptr<cv::ml::SVM> svm = cv::ml::SVM::create();
    svm->setType(cv::ml::SVM::Types::C_SVC);
    svm->setKernel(cv::ml::SVM::KernelTypes::LINEAR);
    svm->setTermCriteria(cv::TermCriteria(cv::TermCriteria::MAX_ITER, 10000000, 1e-6));


    if(TRAIN)
    {
        string ImgName;
        ifstream finPos("/media/d_2/everyday/0402/sample_pos/pos.txt");
        //ifstream finPos("/media/d_2/everyday/0402/sample_neg/neg_list.txt");
        ifstream finNeg("/media/d_2/everyday/0402/sample_neg/neg_list.txt");
        Mat sampleFeatureMat;
        Mat sampleLabelMat;

        for(int num=0; num<PosSamNO && getline(finPos,ImgName); num++)
        {
            cout<<"process:::"<<ImgName<<endl;
            Mat src = imread(ImgName);

            //			if(CENTRAL_CROP)
            //				src = src(Rect(16,16,64,128));
            resize(src,src,Size(64,32));

            vector<float> descriptors;
            hog.compute(src,descriptors,Size(4,4));
            //
            cout<<"dim=："<<descriptors.size()<<endl;

            if( 0 == num )
            {
                DescriptorDim = descriptors.size();
                sampleFeatureMat = Mat::zeros(PosSamNO+NegSamNO+HardExampleNO, DescriptorDim, CV_32FC1);
                sampleLabelMat = Mat::zeros(PosSamNO+NegSamNO+HardExampleNO, 1, CV_32SC1);
            }

            for(int i=0; i<DescriptorDim; i++)
                sampleFeatureMat.at<float>(num,i) = descriptors[i];
            sampleLabelMat.at<float>(num,0) = 1;
        }

        for(int num=0; num<NegSamNO && getline(finNeg,ImgName); num++)
        {
            cout<<"process:::"<<ImgName<<endl;
            Mat src = imread(ImgName);
            resize(src,src,Size(64,32));

            vector<float> descriptors;
            hog.compute(src,descriptors,Size(4,4));
            //cout<<"deal："<<descriptors.size()<<endl;

            for(int i=0; i<DescriptorDim; i++)
                sampleFeatureMat.at<float>(num+PosSamNO,i) = descriptors[i];
            sampleLabelMat.at<float>(num+PosSamNO,0) = -1;

        }

        if(HardExampleNO > 0)
        {
            ifstream finHardExample("HardExample_2400PosINRIA_12000NegList.txt");
            for(int num=0; num<HardExampleNO && getline(finHardExample,ImgName); num++)
            {
                cout<<"deal："<<ImgName<<endl;
                ImgName = "D:\\DataSet\\HardExample_2400PosINRIA_12000Neg\\" + ImgName;
                Mat src = imread(ImgName);
                //resize(src,img,Size(64,128));

                vector<float> descriptors;
                hog.compute(src,descriptors,Size(8,8));
                //cout<<"deal："<<descriptors.size()<<endl;


                for(int i=0; i<DescriptorDim; i++)
                    sampleFeatureMat.at<float>(num+PosSamNO+NegSamNO,i) = descriptors[i];
                sampleLabelMat.at<float>(num+PosSamNO+NegSamNO,0) = -1;
            }
        }

        //训练SVM分类器
        //迭代终止条件，当迭代满1000次或误差小于FLT_EPSILON时停止迭代
        std::cout << "开始训练SVM分类器" << std::endl;
        cv::Ptr<cv::ml::TrainData> td = cv::ml::TrainData::create(sampleFeatureMat, cv::ml::SampleTypes::ROW_SAMPLE, sampleLabelMat);
        //训练分类器
        svm->train(td);
        std::cout << "训练完成" << std::endl;
        //将训练好的SVM模型保存为xml文件
        svm->save("SVM_HOG.xml");

    }else
    {
        svm_hog_detect();
    }

    return true;
}