LBP/HOG/SIFT/SURF特征SVM的trainAuto范例

在开源的车牌识别系统EasyPR中，用SVM（支持向量机）模型甄选出候选车牌中真正的车牌。目前EasyPR1.4的SVM模型输入的是LBP特征，本代码将EasyPR的svm_train.cpp独立出来，包含SIFT和SURF结合BOW作为SVM输入，以及LBP和HOG特征作为SVM的输入。

#include “opencv2/opencv_modules.hpp“
#include “opencv2/imgcodecs.hpp“
#include “opencv2/highgui.hpp“
#include “opencv2/imgproc.hpp“
#include “opencv2/features2d.hpp“
#include “opencv2/xfeatures2d.hpp“
#include “opencv2/ml.hpp“
#include “util.h“
#include “BagOfWords.h“

#include 
#include 
#include 
#include 

#if defined WIN32 || defined _WIN32
#define WIN32_LEAN_AND_MEAN
#include 
#undef min
#undef max
#include “sys/types.h“
#endif
#include 

#define DEBUG_DESC_PROGRESS

using namespace cv;
using namespace cv::xfeatures2d;
using namespace cv::ml;
using namespace std;

extern string resPath;
const string paramsFile = “params.xml“;
const string vocabularyFile = “vocabulary.xml.gz“;
const string bowImageDescriptorsDir = “/bowImageDescriptors“;
const string svmsDir = “/svms“;
//const string plotsDir = “/plots“;


class ObdImage
{
public:
	ObdImage（string p_id string p_path） : id（p_id） path（p_path） {}
	string id;
	string path;
};

//
// This part of the code was a little refactor
//
struct DDMParams
{
	DDMParams（） : detectorType（“SURF“） descriptorType（“SURF“） matcherType（“BruteForce“） {}
	DDMParams（const string _detectorType const string _descriptorType const string& _matcherType） :
		detectorType（_detectorType） descriptorType（_descriptorType） matcherType（_matcherType）{}
	void read（const FileNode& fn）
	{
		fn[“detectorType“] >> detectorType;
		fn[“descriptorType“] >> descriptorType;
		fn[“matcherType“] >> matcherType;
	}
	void write（FileStorage& fs） const
	{
		fs << “detectorType“ << detectorType;
		fs << “descriptorType“ << descriptorType;
		fs << “matcherType“ << matcherType;
	}
	void print（） const
	{
		cout << “detectorType: “ << detectorType << endl;
		cout << “descriptorType: “ << descriptorType << endl;
		cout << “matcherType: “ << matcherType << endl;
	}

	string detectorType;
	string descriptorType;
	string matcherType;
};

struct VocabTrainParams
{
	VocabTrainParams（） : vocabSize（1000） memoryUse（200） descProportion（0.3f） {}
	VocabTrainParams（const string _trainObjClass size_t _vocabSize size_t _memoryUse float _descProportion） :
		vocabSize（（int）_vocabSize） memoryUse（（int）_memoryUse） descProportion（_descProportion） {}
	void read（const FileNode& fn）
	{
		fn[“vocabSize“] >> vocabSize;
		fn[“memoryUse“] >> memoryUse;
		fn[“descProportion“] >> descProportion;
	}
	void write（FileStorage& fs） const
	{
		fs << “vocabSize“ << vocabSize;
		fs << “memoryUse“ << memoryUse;
		fs << “descProportion“ << descProportion;
	}
	void print（） const
	{
		cout << “vocabSize: “ << vocabSize << endl;
		cout << “memoryUse: “ << memoryUse << endl;
		cout << “descProportion: “ << descProportion << endl;
	}

	// It shouldn‘t matter which object class is specified here - visual vocab will still be the same.
	int vocabSize; //number of visual words in vocabulary to train
	int memoryUse; //