各机器学习方法代码（OpenCV2）

 #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 ;
 }

图像分类结果：