HOG + SVM

#include "stdafx.h"
#include <stdio.h>
#include <string.h>
#include <fstream>
#include <iterator>
#include <vector>
#include <opencv2/core.hpp>
#include <opencv2/imgproc.hpp>
#include "opencv2/imgcodecs.hpp"
#include <opencv2/highgui.hpp>
#include <opencv2/ml.hpp>
#include "opencv2/objdetect.hpp"

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


void load_image(vector < Mat > & storeInput, vector< int > & labels){
    char filename[256];

    for (int i = 1; i <= 6; i++){
        for (int j = 1; j <= 50; j++) {
            Mat img, img_gray;
            sprintf(filename, "./train_data/%02d/%04d.ppm", i, j);
            img = imread(filename);
            resize(img, img, Size(32, 32));
            cvtColor(img, img_gray, CV_BGR2GRAY);
            storeInput.push_back(img_gray);
            labels.push_back(i*1000 + j);
            //show image
            imshow("load image", img_gray);

            waitKey(5);
        }
    }
}

void convert_to_ml(const std::vector< cv::Mat > & train_samples, cv::Mat& trainData)
{
    //--Convert data
    const int rows = (int)train_samples.size();
    const int cols = (int)std::max(train_samples[0].cols, train_samples[0].rows);
    cv::Mat tmp(1, cols, CV_32FC1); //< used for transposition if needed
    trainData = cv::Mat(rows, cols, CV_32FC1);
    vector< Mat >::const_iterator itr = train_samples.begin();
    vector< Mat >::const_iterator end = train_samples.end();
    for (int i = 0; itr != end; ++itr, ++i)
    {
        if (itr->cols == 1)
        {
            transpose(*(itr), tmp);
            tmp.copyTo(trainData.row(i));
        }
        else if (itr->rows == 1)
        {
            itr->copyTo(trainData.row(i));
        }
    }
}

void compute_hog(const vector< Mat > & img_lst, vector< Mat > & gradient_lst)
{
    cout << "Start hog...";
    Size size = Size(32, 32);
    Size block_size = Size(size.width / 4, size.height / 4);
    Size block_stride = Size(size.width / 8, size.height / 8);
    Size cell_size = block_stride;
    int num_bins = 9;
    HOGDescriptor hog(size, block_size, block_stride, cell_size, num_bins);
    Mat inputHOG;
    vector< Point > location;
    vector< float > descriptors;

    for (int i = 0; i < img_lst.size(); i++)
    {
        inputHOG = img_lst[i];
        hog.compute(inputHOG, descriptors, Size(0, 0), Size(0, 0), location);
        //cout << "descriptors size: " << descriptors.size() << endl;

        gradient_lst.push_back(Mat(descriptors).clone());

}
cout << "...[done]" << endl;
}


void train_svm(const vector< Mat > & storeInput, const vector< int > & labels){
    Mat train_data;
    convert_to_ml(storeInput, train_data);
    cout << "Start training...";


    Ptr<SVM> svm = SVM::create();
    svm->setType(SVM::C_SVC);
    svm->setKernel(SVM::LINEAR);
    svm->setC(10);
    svm->setTermCriteria(cvTermCriteria(CV_TERMCRIT_ITER + CV_TERMCRIT_EPS, 1000, 1e-6));

    svm->train(train_data, ROW_SAMPLE, Mat(labels));

    cout << "...[done]" << endl;

    svm->save("./genfiles/trainSVM_Recog_MoreImage.xml");
    cout << "Save XML ..... done!!!" << endl;
}

//test trainning data + HOG
float test_svm(Mat img, string nameSVM){

    //read image file
    Mat img_gray, feature;
    imshow("input", img);


    //resizing
    resize(img, img, Size(32, 32));
    //gray
    cvtColor(img, img_gray, COLOR_BGR2GRAY);

    //Extract HogFeature
    Size size = Size(32, 32);
    Size block_size = Size(size.width / 4, size.height / 4);
    Size block_stride = Size(size.width / 8, size.height / 8);
    Size cell_size = block_stride;
    int num_bins = 9;
    HOGDescriptor hog(size, block_size, block_stride, cell_size, num_bins);
    vector< float> descriptorsValues;
    vector< Point> locations;

    hog.compute(img_gray, descriptorsValues, Size(0, 0), Size(0, 0), locations);
    //vector to Mat
    Mat fm = Mat(descriptorsValues);

    //Classification data
    Ptr<SVM> svm = Algorithm::load<SVM>(nameSVM);
    std::cout << "Model Loaded" << std::endl;

    Mat image1d(1, fm.rows, CV_32FC1);
    imshow("gradient 1", image1d);

    float result = svm->predict(image1d);
    //std::cout << "Predict value: " << result << std::endl;
    return result;
}


int main(){


    //trainning data
    vector < Mat > storeInput;
    vector < int > labels;
    vector < Mat > gradient_lst;

    load_image(storeInput, labels);

    compute_hog(storeInput, gradient_lst);

    train_svm(gradient_lst, labels);

    Mat img = imread("./train_data/01/0001.ppm");
    string fileSVM = "./genfiles/trainSVM_Recog_MoreImage.xml";
    float result = test_svm(img, fileSVM);
    std::cout << "Predict value: " << result << std::endl;

    waitKey(0);
    return 0;
}