hog_svm code

3 篇文章 0 订阅

http://blog.csdn.net/zhazhiqiang/article/details/18664417
http://blog.csdn.net/hujingshuang/article/details/47337707/
http://blog.csdn.net/orsinozhu/article/details/40554211
http://blog.csdn.net/qq_14845119/article/details/52187774
http://blog.csdn.net/leifeng_soul/article/details/52608575
http://blog.csdn.net/zhazhiqiang/article/details/20723425
http://blog.csdn.net/alvine008/article/details/9097105
http://blog.csdn.net/love_linney/article/details/25192909

#ifndef MY_HOG_SVM_H
#define MY_HOG_SVM_H


#include <QObject>
#include "opencv2/core/core.hpp"
#include "opencv2/imgproc/imgproc.hpp"
#include "opencv2/highgui/highgui.hpp"
#include "opencv2/calib3d/calib3d.hpp"
#include "opencv2/objdetect/objdetect.hpp"
#include "opencv/cv.h"
#include <QDebug>
#include <QTime>
#include <QDateTime>
#include <QTimer>
#include <QtCore/qmath.h>
#include "opencv/ml.h"
#include <iostream>
#include <fstream>
#include <string>
#include <vector>


using namespace cv;
using namespace std;
class Mysvm : public CvSVM
{
public:
    //获得SVM的决策函数中的alpha数组
    double * get_alpha_vector()
    {
        return this->decision_func->alpha;
    }


    //获得SVM的决策函数中的rho参数,即偏移量
    float get_rho()
    {
        return this->decision_func->rho;
    }
};


class Mysvm;
class My_Hog_Svm : public QObject
{
    Q_OBJECT
public:
    explicit My_Hog_Svm(QObject *parent = 0);


private:
    const int m_iImgHeight = 96;
    const int m_iImgWidht =96;
    const int m_iBlockSizeWidth = 32;
    const int m_iCellSizeWidth =16;
    const int m_iStrideSizeWidth =16;


private:
    void MyTrain();
    void Detection();
    void GetFeatureVector();
    void DrawBox();
};


#endif // MY_HOG_SVM_H
#include "my_hog_svm.h"
//#include "mysvm.h"



My_Hog_Svm::My_Hog_Svm(QObject *parent) : QObject(parent)
{
//    //1:训练
//    this->MyTrain();

//    //2:检测
//    this->Detection();

//    //3:获得特征向量
//    this->GetFeatureVector();

    //4:画框
    this->DrawBox();
}

void My_Hog_Svm::MyTrain()
{

    vector<string> img_path;    //样本路径
    vector<int> img_catg;       //标记正负样本
    int nLine = 0;  //样本总共的个数
    string buf;
    ifstream svm_data_true( "./TRAIN_HEAD/Pos.txt" );   //正样本路径
    ifstream svm_data_false( "./TRAIN_HEAD/Neg.txt" );  //负样本路径
    unsigned long n;

    //获取样本的路径
    while(svm_data_true)    //正样本
    {
        if( getline( svm_data_true, buf ) )
        {
            nLine ++;
            img_catg.push_back(1);
            img_path.push_back( buf );
        }
    }
    while(svm_data_false)   //负样本
    {

        if(getline(svm_data_false, buf))
        {

            nLine ++;
            img_catg.push_back(0);
            img_path.push_back( buf );
        }
    }
    svm_data_true.close();//关闭文件
    svm_data_false.close();


    Mat data_mat;   //存放特征值的矩阵
    Mat res_mat;    //存放正负样本的标识
    int nImgNum = nLine;            //读入样本数量
    //类型矩阵,存储每个样本的类型标志
    res_mat = Mat::zeros( nImgNum, 1, CV_32FC1);

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

    //获取每一个文件的特征值矩阵
    for( string::size_type i = 0; i != img_path.size(); i++ )
    {
        src = imread(img_path[i].c_str(), 0);
        resize(src, trainImg, cv::Size(m_iImgWidht,m_iImgHeight), 0, 0, INTER_CUBIC); //调整训练的图片
        HOGDescriptor *hog=new HOGDescriptor(cvSize(m_iImgWidht,m_iImgHeight) //参数:窗口大小,块的大小,块滑动增量,cell的大小,每个bin的特征值
                                             ,cvSize(m_iBlockSizeWidth,m_iBlockSizeWidth),cvSize(m_iCellSizeWidth,m_iCellSizeWidth),cvSize(m_iStrideSizeWidth,m_iStrideSizeWidth), 9);  //具体意思见参考文章1,2

        vector<float>descriptors;//结果数组,特征值的个数
        hog->compute(trainImg, descriptors, Size(m_iStrideSizeWidth,m_iStrideSizeWidth), Size(0,0)); //调用计算函数开始计算,滑动块增量
        if (i==0)
        {
            //初始化存放所有图片特征值的容器
            data_mat = Mat::zeros( nImgNum, descriptors.size(), CV_32FC1 ); //根据输入图片大小进行分配空间
        }
        n=0;
        for(vector<float>::iterator iter=descriptors.begin();iter!=descriptors.end();iter++)
        {
            //为容器赋值
            data_mat.at<float>(i,n) = *iter;
            n++;
        }
        res_mat.at<float>(i, 0) =  img_catg[i];
        cout<<" end processing "<<img_path[i].c_str()<<"    label:"<<img_catg[i]<<" HOG dims: "<<descriptors.size()<<endl;
    }

    //svm训练
    Mysvm* svm = new Mysvm();
    //训练SVM分类器
    //迭代终止条件,当迭代满1000次或误差小于FLT_EPSILON时停止迭代
    CvTermCriteria criteria = cvTermCriteria(CV_TERMCRIT_ITER+CV_TERMCRIT_EPS, 1000, FLT_EPSILON);
    //SVM参数:SVM类型为C_SVC;线性核函数;松弛因子C=0.01
    CvSVMParams param(CvSVM::C_SVC, CvSVM::LINEAR, 0, 1, 0, 0.01, 0, 0, 0, criteria);

    //☆☆☆☆☆☆☆☆☆(5)  SVM学习 ☆☆☆☆☆☆☆☆☆☆☆☆
    svm->train( data_mat, res_mat, Mat(), Mat(), param );
    //☆☆利用训练数据和确定的学习参数,进行SVM学习☆☆☆☆

    svm->save( "./TRAIN_HEAD/SVM_DATA.xml" );
    qDebug() << "Finish!";

}


void My_Hog_Svm::Detection()
{
    Mysvm* svm = new Mysvm();
    svm->load("./TRAIN_HEAD/SVM_DATA.xml");

    Mat trainImg = Mat::zeros(m_iImgHeight, m_iImgWidht, CV_8UC3);//需要分析的图片
    string buf;
    //检测样本
    vector<string> img_tst_path;
    ifstream img_tstNeg( "./TRAIN_HEAD/testNeg.txt" );
    ifstream img_tstPos( "./TRAIN_HEAD/testPos.txt" );
    while( img_tstNeg )
    {
        if( getline( img_tstNeg, buf ) )
        {
            img_tst_path.push_back( buf );
        }
    }
    img_tstNeg.close();
    while( img_tstPos )
    {
        if( getline( img_tstPos, buf ) )
        {
            img_tst_path.push_back( buf );
        }
    }
    img_tstPos.close();

    Mat test;
    char line[512];
    ofstream predict_txt( "./TRAIN_HEAD/SVM_PREDICT.txt" );
    for( string::size_type j = 0; j != img_tst_path.size(); j++ )
    {
        test = imread( img_tst_path[j].c_str(), 0);//读入图像
        resize(test, trainImg, cv::Size(m_iImgWidht,m_iImgHeight), 0, 0, INTER_CUBIC);//要搞成同样的大小才可以检测到
        HOGDescriptor *hog=new HOGDescriptor(cvSize(m_iImgWidht,m_iImgHeight)
                                             ,cvSize(m_iBlockSizeWidth,m_iBlockSizeWidth),cvSize(m_iCellSizeWidth,m_iCellSizeWidth),cvSize(m_iStrideSizeWidth,m_iStrideSizeWidth), 9);
        vector<float>descriptors;//结果数组
        hog->compute(trainImg, descriptors,Size(m_iStrideSizeWidth,m_iStrideSizeWidth), Size(0,0)); //调用计算函数开始计算
        cout<<"The Detection Result:"<<endl;
        Mat SVMtrainMat =  Mat::zeros(1,descriptors.size(),CV_32FC1);
        int 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);
        predict_txt<<line;
    }
    predict_txt.close();

    cout << "Finish" <<endl;
    return ;

}


/*************************************************************************************************
    线性SVM训练完成后得到的XML文件里面,有一个数组,叫做support vector,还有一个数组,叫做alpha,有一个浮点数,叫做rho;
    将alpha矩阵同support vector相乘,注意,alpha*supportVector,将得到一个列向量。之后,再该列向量的最后添加一个元素rho。
    如此,变得到了一个分类器,利用该分类器,直接替换opencv中行人检测默认的那个分类器(cv::HOGDescriptor::setSVMDetector()),
    就可以利用你的训练样本训练出来的分类器进行行人检测了。
***************************************************************************************************/
void My_Hog_Svm::GetFeatureVector()
{
    Mysvm* svm = new Mysvm();
    svm->load("./TRAIN_HEAD/SVM_DATA.xml");                                   //获取特征值的个数
    int l_iFeatureNum = svm->get_var_count();//特征向量的维数,即HOG描述子的维数
    int supportVectorNum = svm->get_support_vector_count();//支持向量的个数
    qDebug()<<"支持向量个数:"<<supportVectorNum;

    Mat alphaMat = Mat::zeros(1, supportVectorNum, CV_32FC1);//alpha向量,长度等于支持向量个数
    Mat supportVectorMat = Mat::zeros(supportVectorNum, l_iFeatureNum, CV_32FC1);//支持向量矩阵
    Mat resultMat = Mat::zeros(1, l_iFeatureNum, CV_32FC1);//alpha向量乘以支持向量矩阵的结果


    //将支持向量的数据复制到supportVectorMat矩阵中
    for(int i=0; i<supportVectorNum; i++)
    {
        const float * pSVData = svm->get_support_vector(i);//返回第i个支持向量的数据指针
        for(int j=0; j<l_iFeatureNum; j++)
        {
            supportVectorMat.at<float>(i,j) = pSVData[j];
        }
    }

    //将alpha向量的数据复制到alphaMat中
    double * pAlphaData = svm->get_alpha_vector();//返回SVM的决策函数中的alpha向量
    for(int i=0; i<supportVectorNum; i++)
    {
        alphaMat.at<float>(0,i) = pAlphaData[i];
    }

    //gemm(alphaMat, supportVectorMat, -1, 0, 1, resultMat);//不知道为什么加负号?
    resultMat = -1 * alphaMat * supportVectorMat;

    //得到最终的setSVMDetector(const vector<float>& detector)参数中可用的检测子
    vector<float> myDetector;
    //将resultMat中的数据复制到数组myDetector中
    for(int i=0; i<l_iFeatureNum; i++)
    {
        myDetector.push_back(resultMat.at<float>(0,i));
    }
    //最后添加偏移量rho,得到检测子
//    myDetector.push_back(svm->get_rho());
    qDebug()<<"检测子维数:"<<myDetector.size() +1;

    //保存检测子参数到文件
    FILE* fp = fopen("./TRAIN_HEAD/hogSVMDetector-peopleFlow.txt","wb");
    if( NULL == fp )
    {
        return ;
    }
    for(int i=0; i<myDetector.size(); i++)
    {
        fprintf(fp, "%f \n", myDetector[i]);
    }
    fprintf(fp, "%f", svm->get_rho());
    fclose(fp);
    qDebug() << "Finish!";
    return;

}


void My_Hog_Svm::DrawBox()
{

        vector<Rect> found;
        Mat img = imread("./11.jpg");

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

        HOGDescriptor defaultHog(cvSize(m_iImgWidht,m_iImgHeight) //参数:窗口大小,块的大小,块滑动增量,cell的大小,每个bin的特征值
                                  ,cvSize(m_iBlockSizeWidth,m_iBlockSizeWidth),cvSize(m_iCellSizeWidth,m_iCellSizeWidth),cvSize(m_iStrideSizeWidth,m_iStrideSizeWidth), 9);
        defaultHog.setSVMDetector(myDetector);
        //进行检测
        defaultHog.detectMultiScale(img, found);
        //画长方形,框出行人
        for(int i = 0; i < found.size(); i++)
        {
            Rect r = found[i];
            rectangle(img, r.tl(), r.br(), Scalar(255, 255, 255), 3);
        }
        namedWindow("检测行人", CV_WINDOW_AUTOSIZE);
        imshow("检测行人", img);
        waitKey(0);

//        Mat l_pImageEle;
//        namedWindow("Video");
//        VideoCapture capture("./a.avi");
//        while(1)    //循环每一帧
//        {
//            static int l_iNum = 0;
//            if(!capture.read(l_pImageEle))
//            {
//                return;
//            }

//            if(l_iNum%34 ==0)
//            {
//                //进行检测
//                defaultHog.detectMultiScale(l_pImageEle, found);
//                //画长方形,框出行人
//                for(int i = 0; i < found.size(); i++)
//                {
//                    Rect r = found[i];
//                    rectangle(l_pImageEle, r.tl(), r.br(), Scalar(255, 255, 255), 3);
//                }
//            }

//            imshow("Video", l_pImageEle);
//            cvWaitKey(34);

//        }
}
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值