Hog+svm行人检测

最新推荐文章于 2023-11-23 17:23:35 发布

liulina603

最新推荐文章于 2023-11-23 17:23:35 发布

阅读量1w

点赞数

分类专栏： opencv分类器训练

opencv分类器训练专栏收录该内容

29 篇文章 6 订阅

订阅专栏

（1）第一个工程是用来训练分类器和检测正样本检测率的

// PeopleDetectHog.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <opencv2/opencv.hpp>
#include <iostream>
#include <ctype.h>
#include "cv.h"
#include "highgui.h"
#include "stdafx.h"
#include <ml.h>
#include <fstream>
#include <math.h>
#include <string>
#include <vector>
#include <stdio.h>

using namespace cv;
using namespace std;

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 _tmain(int argc, _TCHAR* argv[])
{
int positiveSampleCount = 2416; //正样本数
int negativeSampleCount = 18185; //负样本数
int totalSampleCount = positiveSampleCount + negativeSampleCount;

FILE* fp = fopen("PeopleDetectResult_INRIA2416.txt","w");

if(fp==NULL)
{
int n = GetLastError();
exit(1);
}

CvMat *sampleFeaturesMat = cvCreateMat(totalSampleCount , 3780, CV_32FC1); //这里第二个参数1764是hog维数，即矩阵的列是由下面的featureVec的大小决定的，可以由descriptors.size()得到，
//64*64的训练样本，该矩阵将是totalSample*1764；若是64*128，则对应3780维

cvSetZero(sampleFeaturesMat);
CvMat *sampleLabelMat = cvCreateMat(totalSampleCount, 1, CV_32FC1); //存储样本图片类型，正样本1，负样本-1
cvSetZero(sampleLabelMat);

// fprintf(fp, "%s\n","Hog描述算子:\n SVM参数：");
cout<<"waiting......"<<endl;
cout<<"start to training positive samples..."<<endl;

string buf;
char line[512];
vector<string> img_path;//输入文件名变量
ifstream svm_data( "D:\\program\\matlabprojects\\PeopleSample\\pos1\\train_list.txt");
while (svm_data)
{
if (getline( svm_data, buf ))
{
img_path.push_back( buf );
}
}

svm_data.close();//关闭文件

IplImage* src;
IplImage* img=cvCreateImage(cvSize(64,128),8,3);//需要分析的图片，这里默认设定图片是64*128大小，所以上面定义了3780，如果要更改图片大小，可以先用debug查看一下descriptors是多少，然后设定好再运行

long t1 = GetTickCount();
for(int i=0; i<positiveSampleCount; i++)
{
src=cvLoadImage(img_path[i].c_str(),1);
cvResize(src,img); //读取正样本图片
if( img == NULL )
{
cout<<" can not load the image:"<<img_path[i].c_str()<<endl;
continue;
}
cout<<" processing "<<img_path[i].c_str()<<endl;

cv::HOGDescriptor hog(cv::Size(64,128), cv::Size(16,16), cv::Size(8,8),cv::Size(8,8), 9);
//HOG的描述函数。如果是64*128的训练样本，需要把第一个参数改为cv::Size(64,128)

vector<float> featureVec;
hog.compute(img, featureVec, cv::Size(8,8)); //featureVec--存储每个样本图片的HOG特征向量
for (int j=0; j<featureVec.size(); j++)
{
CV_MAT_ELEM( *sampleFeaturesMat, float, i, j ) = featureVec[j];
}
sampleLabelMat->data.fl[i] = 1;
}

cvReleaseImage( &src);
cvReleaseImage( &img);
cout<<"end of training for positive samples..."<<endl;

long t2 = GetTickCount();
fprintf(fp, "%s%d\n", "training for positive samples timeis:",t2-t1);

cout<<"waiting......"<<endl;
cout<<"start to train negative samples..."<<endl;

string buff;
int m;
vector<string> img_neg_path;//输入文件名变量
ifstream svm_neg_data( "D:\\program\\matlabprojects\\PeopleSample\\neg4\\train_list.txt");
while (svm_neg_data)
{
if (getline( svm_neg_data, buff ))
{
img_neg_path.push_back( buff );
}
}

svm_neg_data.close();//关闭文件
IplImage* neg;
IplImage* neg_img=cvCreateImage(cvSize(64,128),8,3);

for (int i=0; i<negativeSampleCount; i++)
{
neg = cvLoadImage(img_neg_path[i].c_str(),1); //读取负样本图片
cvResize(neg,neg_img); //读取正样本图片
if( neg_img == NULL )
{
cout<<" can not load the image:"<<img_path[i].c_str()<<endl;
continue;
}

cout<<" processing"<<img_neg_path[i].c_str()<<endl;
cv::HOGDescriptor hog(cv::Size(64,128), cv::Size(16,16), cv::Size(8,8),cv::Size(8,8), 9); //若为64*128的样本，需要将第一个参数做出改动（上述）
vector<float> featureVec;
hog.compute(neg_img,featureVec,cv::Size(8,8)); //featureVec.size()，且对于不同大小的输入训练图片，这个值是不同的
//cout<<"The featureVector number of negativeSample is:"<<featureVec.size()<<endl; //查看一下featureVec的大小
for ( int j=0; j<featureVec.size(); j ++)
{
CV_MAT_ELEM( *sampleFeaturesMat, float, i + positiveSampleCount, j ) =featureVec[ j ]; //把HOG存储下来
}

sampleLabelMat->data.fl[ i + positiveSampleCount ] = -1;
m = i+1;
}
cout<<"The count of negativeSample is:"<<m<<endl;//统计处理过的负样本数目
fprintf(fp, "%s%d\n", "The count of negativeSample is:",m);
cout<<"end of training for negative samples..."<<endl;

long t3 = GetTickCount();
cout<<"waiting......"<<endl;
fprintf(fp, "%s%d\n", "training for negative samples timeis:",t3-t1);

//☆☆☆☆☆☆☆☆☆(5)SVM学习☆☆☆☆☆☆☆☆☆☆☆☆

cout<<"start to train for SVM classifier..."<<endl;

// SVM种类：CvSVM::C_SVC
// Kernel的种类：CvSVM::LINEAR
// degree：10.0（此次不使用）
// gamma：8.0
// coef0：1.0（此次不使用）
// C：0.01
// nu：0.5（此次不使用）
// p：0.1（此次不使用）
// 然后对训练数据正规化处理，并放在CvMat型的数组里。

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;
long t4 = GetTickCount();

svm.train( sampleFeaturesMat, sampleLabelMat, NULL, NULL, params ); //用SVM线性分类器训练
//sampleFeaturesMat保存各样本的特征值，sampleLabelMat保存图片类型*/

//保存最终的SVM
long t5 = GetTickCount();
fprintf(fp, "%s%d\n", "Time of train for SVM classifier is:",t5-t4);
svm.save( "SVM_DATA.xml" );
cout<<"SVM_DATA.xml保存完毕！"<<endl;

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

int supportVectorSize = svm.get_support_vector_count();
cout<<"support vector size of SVM："<<supportVectorSize<<endl;
cout<<"SVM completed"<<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] = alphaArr[i];
}
cvMatMul(alp, sv, re);

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

FILE* fpp = fopen("Peopledetector_INRIA2416.txt","w");

if(fpp==NULL)
{
int n = GetLastError();
exit(1);
}
for(int i=0; i<3780; i++)
{
fprintf(fpp,"%f \n",re->data.fl[i]);
}
float rho = svm.get_rho();
fprintf(fpp, "%f", rho);

cout<<"D:\hogSVMDetector.txt 保存完毕"<<endl; //保存HOG能识别的分类器

fclose(fpp);

cvReleaseMat(&sv);
cvReleaseMat(&alp);
cvReleaseMat(&re);
cvReleaseMat(&res);

// //***************************************检测正样本************************************
//
IplImage *test;
vector<string> img_tst_path;
// ifstream img_tst("D:\\program\\matlabprojects\\INRIAPerson\\test_my\\pos_bmp\\train_list.txt");//同输入训练样本，这里也是一样的，只不过不需要标注图片属于哪一类了
// ifstream img_tst("D:\\train_list.txt");
ifstream img_tst( "D:\\program\\matlabprojects\\PeopleSample\\pos1\\train_list2.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，同上面一样
IplImage* trainImg=cvCreateImage(cvSize(64,128),8,3);
int right=0;
int wrong=0; //用于计算正确率
int n;
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=newHOGDescriptor(cvSize(64,128),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的文档

if (ret == 1)
{
right += 1;
}
else if (ret == -1)
{
wrong += 1;
}

}
DOUBLE result ;
result= double(right)/double(right+wrong);
cout<<"The Correct rateis:"<<result*100<<"%"<<endl; //检测正样本的正确率
fprintf(fp,"%s%f%s\n","The Correct rateis:",result*100,"%");
fclose(fp);

cvReleaseImage( &test );
cvReleaseImage( &trainImg );

*****************************************开始读入待识别的图像，检测车辆************************************

// IplImage* Img =cvLoadImage("D:\\program\\matlabprojects\\INRIAPerson\\Test\\pos_bmp\\00019.bmp"); //读入图像
// IplImage* DetecImg=cvCreateImage(cvSize(320,240),8,3);

// cvResize(Img,DetecImg);
// long t1 = GetTickCount();
//if (DetecImg == NULL)
//{
// cout<<" can not load the image"<<endl;
// exit(-1);
//} //检测图像有没有被读入

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

//vector<cv::Rect> found; //检测出的车辆数量
//vector<cv::Rect> temp; //用于存放的容器
// vector<vector<cv::Rect>> bigfound;
//vector< vector<cv::Rect>> ::iterator bigit; //功能强大的迭代器

//IplImage* img = NULL;

//cv::HOGDescriptor hog(cv::Size(64,128),cv::Size(16,16), cv::Size(8,8), cv::Size(8,8), 9);
//hog.setSVMDetector(x); //x向量对应的分类器
//long t3 = GetTickCount();

//cout<<"The process time is："<<t3-t1<<endl;
//
//
hog.detectMultiScale(DetecImg, found, 0.7, cv::Size(8,8), cv::Size(5,5),1.06, 1, false); //检测当前图片的HOG特征，found为检测结果向量
// hog.detectMultiScale(DetecImg, found, 0.3, cv::Size(8,8), cv::Size(8,8),1.05, 2, false);
//long t4 = GetTickCount();

//cout<<"The process time is："<<t4-t1<<endl;

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

//cout<<"The number of vehicle is："<<found_filtered.size()<<endl; //检测车辆数
在图片img上画出矩形框,因为hog检测出的矩形框比实际人体框要稍微大些,所以这里需要
做一些调整
//for(i = 0; i <found_filtered.size(); i++)
//{
// 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.07);
// r.height = cvRound(r.height*0.8);
// cvRectangle(DetecImg,cvPoint(r.x,r.y),cvPoint(r.x+r.width,r.y+r.height),CV_RGB(255,0,0),2);
//}
//cvShowImage("img",DetecImg);
//cvWaitKey(0);
//long t5 = GetTickCount();

//cout<<"The process time is："<<t5-t1<<endl;
//system("pause");
//cvWaitKey(0);
//
// cvReleaseImage(&DetecImg);

//**********************************处理视频************************************

CvCapture* cap = cvCreateFileCapture("D:\\项目文档\\智能交通\\行人视频\\20120925\\20120925174702950.avi");//读入视频
if (!cap)
{
cout<<"avi file load error……"<<endl;
system("pause");
exit(-1);
} //检测视频有没有被读入

vector<float> x;

ifstream fileIn("Peopledetector4.txt",ios::in);
float val = 0.0f;
while(!fileIn.eof())
{
fileIn>>val;
x.push_back(val);
}
fileIn.close();

vector<cv::Rect> found; //检测出的车辆数量
vector<cv::Rect> temp; //用于存放的容器
vector<vector<cv::Rect>> bigfound;
vector< vector<cv::Rect>> ::iterator bigit; //功能强大的迭代器
cvNamedWindow("img",CV_WINDOW_AUTOSIZE);

IplImage* img = NULL;
IplImage* SizeImg=cvCreateImage(cvSize(320,240),8,3);

long t1 = GetTickCount();
// cv::HOGDescriptor hog(cv::Size(64,64), cv::Size(16,16), cv::Size(8,8),cv::Size(8,8), 9);
cv::HOGDescriptor hog(cv::Size(64,128), cv::Size(16,16), cv::Size(8,8),cv::Size(8,8), 9);

long t4 = GetTickCount();
cout<<"time:"<<t4-t1<<endl;
hog.setSVMDetector(x); //x向量对应的分类器

while(1)
{
img=cvQueryFrame(cap);
// img = cvLoadImage("D:\\000120.bmp");
cvZero(SizeImg);
cvResize(img,SizeImg);
if(!img) break;
cvWaitKey(1);
//hog.detectMultiScale(img,found,0.9,cv::Size(2,2),cv::Size(64,64),1.06,1,false);
// hog.detectMultiScale(SizeImg, found, 0, Size(8, 8), Size(32, 32), 1.05, 2);
// hog.detectMultiScale(SizeImg, found, 0, cv::Size(11,11), cv::Size(32,32),0.5,2);
// hog.detectMultiScale(SizeImg, found, 1.0, cv::Size(16,16), cv::Size(32,32),1.05, 2, false);
hog.detectMultiScale(SizeImg, found, 0, Size(8, 8), Size(16, 16), 1.0,2,false);

//检测当前帧的HOG特征，found为检测结果向量

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

cout<<"The number of vehicle is："<<found_filtered.size()<<endl; //检测人数
//在图片img上画出矩形框,因为hog检测出的矩形框比实际人体框要稍微大些,所以这里需要
//做一些调整
for(i = 0; i <found_filtered.size(); i++)
{
Rect r = found_filtered[i];
r.x += cvRound(r.width*0.1);
r.width = cvRound(r.width*0.7);
r.y += cvRound(r.height*0.1);
r.height = cvRound(r.height*0.7);
// rectangle(img, r.tl(), r.br(), Scalar(0, 255, 0), 3);
cvRectangle(SizeImg,cvPoint(r.x,r.y),cvPoint(r.x+r.width,r.y+r.height),CV_RGB(255,0,0),1);
}
cvShowImage("img",SizeImg);
cvWaitKey(1);

}
return 0;

}

（1）其中正负样本的选取还是要根据自己具体的问题选取，开始选取的是INRIA、MIT和TUD的样本库，正样本检测效果还可以95%，只是检测自己的视频图像效果就不好了

（2）样本为64×128，样本生成方法见下一篇日志，哈哈

用matlab生成样本

（1）生成正样本

（2）生成负样本

样本生成之后，在文件夹中建立文本：

dir /b/s/p/w *.bmp>train_list.txt

@pause

即可生成目录