#include <iostream>

 #include <math.h>

 #include <string>

 #include "cv.h"

 #include "ml.h"

 #include "highgui.h"

 using namespace cv;

 using namespace std;

 bool plotSupportVectors=true;

 int numTrainingPoints=;

 int numTestPoints=;

 int size=;

 int eq=;

 // accuracy

 float evaluate(cv::Mat& predicted, cv::Mat& actual) {

     assert(predicted.rows == actual.rows);

     int t = ;

     int f = ;

     for(int i = ; i < actual.rows; i++) {

         float p = predicted.at<float>(i,);

         float a = actual.at<float>(i,);

         if((p >= 0.0 && a >= 0.0) || (p <= 0.0 &&  a <= 0.0)) {

             t++;

         } else {

             f++;

         }

     }

     return (t * 1.0) / (t + f);

 }

 // plot data and class

 void plot_binary(cv::Mat& data, cv::Mat& classes, string name) {

     cv::Mat plot(size, size, CV_8UC3);

     plot.setTo(cv::Scalar(255.0,255.0,255.0));

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

         float x = data.at<float>(i,) * size;

         float y = data.at<float>(i,) * size;

         if(classes.at<float>(i, ) > ) {

             cv::circle(plot, Point(x,y), , CV_RGB(,,),);

         } else {

             cv::circle(plot, Point(x,y), , CV_RGB(,,),);

         }

     }

     cv::imshow(name, plot);

 }

 // function to learn

 int f(float x, float y, int equation) {

     switch(equation) {

     case :

         return y > sin(x*) ? - : ;

         break;

     case :

         return y > cos(x * ) ? - : ;

         break;

     case :

         return y > *x ? - : ;

         break;

     case :

         return y > tan(x*) ? - : ;

         break;

     default:

         return y > cos(x*) ? - : ;

     }

 }

 // label data with equation

 cv::Mat labelData(cv::Mat points, int equation) {

     cv::Mat labels(points.rows, , CV_32FC1);

     for(int i = ; i < points.rows; i++) {

              float x = points.at<float>(i,);

              float y = points.at<float>(i,);

              labels.at<float>(i, ) = f(x, y, equation);

         }

     return labels;

 }

 void svm(cv::Mat& trainingData, cv::Mat& trainingClasses, cv::Mat& testData, cv::Mat& testClasses) {

     CvSVMParams param = CvSVMParams();

     param.svm_type = CvSVM::C_SVC;

     param.kernel_type = CvSVM::RBF; //CvSVM::RBF, CvSVM::LINEAR ...

     param.degree = ; // for poly

     param.gamma = ; // for poly/rbf/sigmoid

     param.coef0 = ; // for poly/sigmoid

     param.C = ; // for CV_SVM_C_SVC, CV_SVM_EPS_SVR and CV_SVM_NU_SVR

     param.nu = 0.0; // for CV_SVM_NU_SVC, CV_SVM_ONE_CLASS, and CV_SVM_NU_SVR

     param.p = 0.0; // for CV_SVM_EPS_SVR

     param.class_weights = NULL; // for CV_SVM_C_SVC

     param.term_crit.type = CV_TERMCRIT_ITER +CV_TERMCRIT_EPS;

     param.term_crit.max_iter = ;

     param.term_crit.epsilon = 1e-;

     // SVM training (use train auto for OpenCV>=2.0)

     CvSVM svm(trainingData, trainingClasses, cv::Mat(), cv::Mat(), param);

     cv::Mat predicted(testClasses.rows, , CV_32F);

     for(int i = ; i < testData.rows; i++) {

         cv::Mat sample = testData.row(i);

         float x = sample.at<float>(,);

         float y = sample.at<float>(,);

         predicted.at<float>(i, ) = svm.predict(sample);

     }

     cout << "Accuracy_{SVM} = " << evaluate(predicted, testClasses) << endl;

     plot_binary(testData, predicted, "Predictions SVM");

     // plot support vectors

     if(plotSupportVectors) {

         cv::Mat plot_sv(size, size, CV_8UC3);

         plot_sv.setTo(cv::Scalar(255.0,255.0,255.0));

         int svec_count = svm.get_support_vector_count();

         for(int vecNum = ; vecNum < svec_count; vecNum++) {

             const float* vec = svm.get_support_vector(vecNum);

             cv::circle(plot_sv, Point(vec[]*size, vec[]*size),  , CV_RGB(, , ));

         }

     cv::imshow("Support Vectors", plot_sv);

     }

 }

 void mlp(cv::Mat& trainingData, cv::Mat& trainingClasses, cv::Mat& testData, cv::Mat& testClasses) {

     cv::Mat layers = cv::Mat(, , CV_32SC1);

     layers.row() = cv::Scalar();

     layers.row() = cv::Scalar();

     layers.row() = cv::Scalar();

     layers.row() = cv::Scalar();

     CvANN_MLP mlp;

     CvANN_MLP_TrainParams params;

     CvTermCriteria criteria;

     criteria.max_iter = ;

     criteria.epsilon = 0.00001f;

     criteria.type = CV_TERMCRIT_ITER | CV_TERMCRIT_EPS;

     params.train_method = CvANN_MLP_TrainParams::BACKPROP;

     params.bp_dw_scale = 0.05f;

     params.bp_moment_scale = 0.05f;

     params.term_crit = criteria;

     mlp.create(layers);

     // train

     mlp.train(trainingData, trainingClasses, cv::Mat(), cv::Mat(), params);

     cv::Mat response(, , CV_32FC1);

     cv::Mat predicted(testClasses.rows, , CV_32F);

     for(int i = ; i < testData.rows; i++) {

         cv::Mat response(, , CV_32FC1);

         cv::Mat sample = testData.row(i);

         mlp.predict(sample, response);

         predicted.at<float>(i,) = response.at<float>(,);

     }

     cout << "Accuracy_{MLP} = " << evaluate(predicted, testClasses) << endl;

     plot_binary(testData, predicted, "Predictions Backpropagation");

 }

 void knn(cv::Mat& trainingData, cv::Mat& trainingClasses, cv::Mat& testData, cv::Mat& testClasses, int K) {

     CvKNearest knn(trainingData, trainingClasses, cv::Mat(), false, K);

     cv::Mat predicted(testClasses.rows, , CV_32F);

     for(int i = ; i < testData.rows; i++) {

             const cv::Mat sample = testData.row(i);

             predicted.at<float>(i,) = knn.find_nearest(sample, K);

     }

     cout << "Accuracy_{KNN} = " << evaluate(predicted, testClasses) << endl;

     plot_binary(testData, predicted, "Predictions KNN");

 }

 void bayes(cv::Mat& trainingData, cv::Mat& trainingClasses, cv::Mat& testData, cv::Mat& testClasses) {

     CvNormalBayesClassifier bayes(trainingData, trainingClasses);

     cv::Mat predicted(testClasses.rows, , CV_32F);

     for (int i = ; i < testData.rows; i++) {

         const cv::Mat sample = testData.row(i);

         predicted.at<float> (i, ) = bayes.predict(sample);

     }

     cout << "Accuracy_{BAYES} = " << evaluate(predicted, testClasses) << endl;

     plot_binary(testData, predicted, "Predictions Bayes");

 }

 void decisiontree(cv::Mat& trainingData, cv::Mat& trainingClasses, cv::Mat& testData, cv::Mat& testClasses) {

     CvDTree dtree;

     cv::Mat var_type(, , CV_8U);

     // define attributes as numerical

     var_type.at<unsigned int>(,) = CV_VAR_NUMERICAL;

     var_type.at<unsigned int>(,) = CV_VAR_NUMERICAL;

     // define output node as numerical

     var_type.at<unsigned int>(,) = CV_VAR_NUMERICAL;

     dtree.train(trainingData,CV_ROW_SAMPLE, trainingClasses, cv::Mat(), cv::Mat(), var_type, cv::Mat(), CvDTreeParams());

     cv::Mat predicted(testClasses.rows, , CV_32F);

     for (int i = ; i < testData.rows; i++) {

         const cv::Mat sample = testData.row(i);

         CvDTreeNode* prediction = dtree.predict(sample);

         predicted.at<float> (i, ) = prediction->value;

     }

     cout << "Accuracy_{TREE} = " << evaluate(predicted, testClasses) << endl;

     plot_binary(testData, predicted, "Predictions tree");

 }

 int main() {

     cv::Mat trainingData(numTrainingPoints, , CV_32FC1);

     cv::Mat testData(numTestPoints, , CV_32FC1);

     cv::randu(trainingData,,);

     cv::randu(testData,,);

     cv::Mat trainingClasses = labelData(trainingData, eq);

     cv::Mat testClasses = labelData(testData, eq);

     plot_binary(trainingData, trainingClasses, "Training Data");

     plot_binary(testData, testClasses, "Test Data");

     svm(trainingData, trainingClasses, testData, testClasses);

     mlp(trainingData, trainingClasses, testData, testClasses);

     knn(trainingData, trainingClasses, testData, testClasses, );

     bayes(trainingData, trainingClasses, testData, testClasses);

     decisiontree(trainingData, trainingClasses, testData, testClasses);

     cv::waitKey();

     return ;

 }