//g++ -Wall -Wextra `pkg-config --cflags --libs opencv` -o testSVM testSVM.cpp

#include <iostream>

#include <cassert>

#include <fstream>

#include <opencv2/core/core.hpp>

#include <opencv2/highgui/highgui.hpp>

#include <opencv2/ml/ml.hpp>

static

void

readData(const std::string &inputDataFilename, cv::Mat &data, cv::Mat &responses)

{

  /*

    inputDataFilename must contain (in binary form) [x86-64]

    2 ints : rows & cols

    rows*cols floats for first class

    rows*cols floats for second class

   */

  std::ifstream in(inputDataFilename.c_str(), std::ios::in|std::ios::binary);

  if (! in) {

    std::cerr<<"Error: unable to open file: "<<inputDataFilename<<"\n";

    exit(EXIT_FAILURE);

  }

  int rows=0, cols=0;

  in.read((char *)&rows, sizeof(rows));

  in.read((char *)&cols, sizeof(cols));

  if (rows <= 0 || cols <= 0) {

    std::cerr<<"Error: invalid data from file: "<<inputDataFilename<<"\n";

    exit(EXIT_FAILURE);

  }

  data = cv::Mat(rows*2, cols, CV_32FC1);

  const size_t size = data.rows*data.cols*sizeof(float);

  in.read((char *)data.ptr<float>(0), size);

  if (! in) {

    std::cerr<<"Error: unable to read "<<size<<" Bytes from file: "<<inputDataFilename<<"\n";

    exit(EXIT_FAILURE);

  }

  responses = cv::Mat::zeros(data.rows, 1, CV_32SC1);

  for (int i=data.rows/2; i<data.rows; ++i) {

    *(responses.ptr<int>(i)) = 1;

  }

}

int

main(int argc, char *argv[])

{

  if (argc != 2) {

    std::cerr<<"Usage: "<<argv[0]<<" dataFilename\n";

    exit(EXIT_FAILURE);

  }

  const char *dataFilename = argv[1];

  cv::Mat data, responses;

  readData(dataFilename, data, responses);

  const double degree = 0.5;

  const double gamma = 1;

  const double coef0 = 1;

  const double Cvalue = 1;

  const double nu = 0.5;

  const double p = 0;

  const int term_iter = 1000;

  const double term_eps = 0.01;

#if CV_MAJOR_VERSION*100+CV_MINOR_VERSION*10+CV_SUBMINOR_VERSION < 300

  int svm_type = CvSVM::NU_SVC;

  int kernel_type = CvSVM::RBF;

  CvSVMParams params;

  params.svm_type = svm_type;

  params.kernel_type = kernel_type;

  params.degree = degree;

  params.gamma = gamma;

  params.coef0 = coef0;

  params.C = Cvalue;

  params.nu = nu;

  params.p = p;

  params.term_crit = cvTermCriteria(CV_TERMCRIT_ITER, term_iter, term_eps);

  CvSVM svmClassifier;

  svmClassifier.train(data, responses, cv::Mat(), cv::Mat(), params);

#else

  int svm_type = cv::ml::SVM::NU_SVC;

  int kernel_type = cv::ml::SVM::RBF;

  cv::Ptr<cv::ml::SVM> svmClassifier = cv::ml::SVM::create();

  svmClassifier->setType(svm_type);

  svmClassifier->setKernel(kernel_type);

  svmClassifier->setDegree(degree);

  svmClassifier->setGamma(gamma);

  svmClassifier->setCoef0(coef0);

  svmClassifier->setC(Cvalue);

  svmClassifier->setNu(nu);

  svmClassifier->setP(p);

  svmClassifier->setTermCriteria(cv::TermCriteria(cv::TermCriteria::COUNT, term_iter, term_eps));

  svmClassifier->train(data, cv::ml::ROW_SAMPLE, responses);

#endif 

  std::cout<<"classif done.\n";

  return 0;

}