1、前言

本次训练图为opencv自带的数字图，在opencv目录下的路径：opencv\sources\samples\data\digits.png;

2、最近邻居/k-近邻算法 (K-Nearest Neighbors,KNN)

KNN算法是一种基于实例的学习，或者是局部近似和将所有计算推迟到分类之后的惰性学习。用最近的邻居（k）来预测未知数据点。k 值是预测精度的一个关键因素，无论是分类还是回归，衡量邻居的权重都非常有用，较近邻居的权重比较远邻居的权重大。

KNN 算法的缺点是对数据的局部结构非常敏感。计算量大，需要对数据进行规范化处理，使每个数据点都在相同的范围。

新建文件：KNN.h

//
// Created by W9033927 on 2024/7/10.
//
#ifndef FACE_RECOGNITION_KNN_H
#define FACE_RECOGNITION_KNN_H
#include <iostream>
#include<opencv2/opencv.hpp>
#include <random>
#include <dirent.h>
#include <sys/stat.h>
using namespace std;
using namespace cv;
/**
 * 训练CNN(K最近邻)模型， 代码来源： https://www.cnblogs.com/denny402/p/5033898.html
 * @param numberPng  图片路径
 * @param kNNModelXmlPath  模型保存路径
 */
void trainKNNModel(const string & numberPng,const string & kNNModelXmlPath) {
    Mat img = imread(numberPng);
    Mat gray;
    // 转为灰度图（黑白图）
    cvtColor(img, gray, CV_BGR2GRAY);
    int b = 20;
    int m = gray.rows / b;   //原图为1000*2000
    int n = gray.cols / b;   //裁剪为5000个20*20的小图块
    Mat data, labels;   //特征矩阵
    for (int i = 0; i < n; i++) {
        // 按列截取
        int offsetCol = i * b; //列上的偏移量
        for (int j = 0; j < m; j++) {
            int offsetRow = j * b;  //行上的偏移量
            //截取20*20的小块
            Mat tmp;
            gray(Range(offsetRow, offsetRow + b), Range(offsetCol, offsetCol + b)).copyTo(tmp);
//            imshow("转换前",tmp);
//            waitKey(0);
            //序列化，改变行数，将20*20的居中转为 1 * 400， 序列化后放入特征矩阵
            const Mat &reshapeMat = tmp.reshape(0, 1);
//            imshow("转换后",reshapeMat);
//            cout << "原行数：" << tmp.rows<< ", 原列数："<<tmp.cols<<", 原通道数："<< tmp.channels()<<endl;
//            cout << "转换后行数：" << reshapeMat.rows<< ", 转换后列数："<<reshapeMat.cols<<", 转换后通道数："<< reshapeMat.channels()<<endl;
//            waitKey(0);
            data.push_back(reshapeMat);
            labels.push_back((int) j / 5);  //对应的标注, 就是图片中的数字对应的值
//            cout << "label :" << (int) j / 5 << endl;
        }
    }
    data.convertTo(data, CV_32F); //uchar型转换为cv_32f
    int samplesNum = data.rows;
    //前3000个样本为训练数据
    int trainNum = 3000;
    Mat trainData, trainLabels;
    // 将前3000个样本提取出来
    trainData = data(Range(0, trainNum), Range::all());
    // 标注，就是数字值
    trainLabels = labels(Range(0, trainNum), Range::all());
    //使用KNN算法训练
    int K = 5;
    Ptr<cv::ml::TrainData> tData = cv::ml::TrainData::create(trainData, cv::ml::ROW_SAMPLE, trainLabels);
    Ptr<cv::ml::KNearest> model = cv::ml::KNearest::create();
    model->setDefaultK(K);
    model->setIsClassifier(true);
    cout << trainData.size<<endl;
    cout << trainLabels.size<<endl;
    imshow("1",trainData);
    waitKey(0);
    // 开始训练
    model->train(tData);
    // 保存模型
    model->save(kNNModelXmlPath);
    //预测分类
    double train_hr = 0, test_hr = 0;
    Mat response;
    //计算训练和测试数据的预测误差
    for (int i = 0; i < samplesNum; i++) {
        Mat sample = data.row(i);
        float r = model->predict(sample);   //对所有行进行预测
        //预测结果与原结果相比，相等为1，不等为0
//        cout << "predict result: " << r << ", " << std::abs(r - labels.at<int>(i)) << " <= " << FLT_EPSILON << endl;
        r = std::abs(r - labels.at<int>(i)) <= FLT_EPSILON ? 1.f : 0.f;
        if (i < trainNum)
            train_hr += r;  //累积正确数
        else
            test_hr += r;
    }
    test_hr /= samplesNum - trainNum;
    train_hr = trainNum > 0 ? train_hr / trainNum : 1.;
    printf("accuracy: train = %.1f%%, test = %.1f%%\n",
           train_hr * 100., test_hr * 100.);
}
/**
 * 使用训练后的KNN模型进行预测
 * @param numberPng 数字图片路径
 * @param kNNModelXmlPath 模型路径
 */
void predictionKNN(const string & numberPng,const string &kNNModelXmlPath) {
    Mat img = imread(numberPng);
    Mat gray;
    // 转为灰度图（黑白图）
    cvtColor(img, gray, CV_BGR2GRAY);
    int b = 20;
    int m = gray.rows / b;   //原图为1000*2000
    int n = gray.cols / b;   //裁剪为5000个20*20的小图块
    Mat data;   //特征矩阵
    for (int i = 0; i < n; i++) {
        // 按列截取
        int offsetCol = i * b; //列上的偏移量
        for (int j = 0; j < m; j++) {
            int offsetRow = j * b;  //行上的偏移量
            //截取20*20的小块
            Mat tmp;
            gray(Range(offsetRow, offsetRow + b), Range(offsetCol, offsetCol + b)).copyTo(tmp);
            //序列化，改变行数，将20*20的图片转为 1 * 400， 序列化后放入特征矩阵
            const Mat &reshapeMat = tmp.reshape(0, 1);
            data.push_back(reshapeMat);
        }
    }
    data.convertTo(data, CV_32F); //uchar型转换为cv_32f
    // 上面是使用knn算法进行训练的，预测也用knn
    int k = 5;
    cv::Ptr<cv::ml::KNearest> model = Algorithm::load<cv::ml::KNearest>(kNNModelXmlPath);
    // data.total()返回的总像素长度， 因为每张图片是20 * 20 像素， 就是400像素，
    for (int i = 0; i < data.rows; ++i) {
        const Mat &mat = data.row(i);
//        cout << "width: "<< mat.cols << "height: "<< mat.rows<<endl;
        Mat result;
//        float d = model->predict(mat,result);
        float d = model->findNearest(mat,k,result);
        cout << "检测到的数字数量: " << d << endl;
    }
}
#endif //FACE_RECOGNITION_KNN_H

2、支持向量机算法(Support Vector Machine,SVM)

支持向量机是一种有监督学习算法，通过找到能够将不同类别的数据点最大化分隔的决策边界来实现分类。在图像分类中，SVM可以用于训练分类器，将图像分为不同的类别。

支持向量机/网络算法(SVM)属于分类型算法。SVM模型将实例表示为空间中的点，将使用一条直线分隔数据点。需要注意的是，支持向量机需要对输入数据进行完全标记，仅直接适用于两类任务，应用将多类任务需要减少到几个二元问题。

新建文件SVM.h

//
// Created by W9033927 on 2024/7/10.
//
#ifndef TRAIN_CLASS_SVM_H
#define TRAIN_CLASS_SVM_H
#include <iostream>
#include<opencv2/opencv.hpp>
#include <random>
#include <dirent.h>
#include <sys/stat.h>
using namespace std;
using namespace cv;
/**
 * 训练svm(支持向量机)
 * @param numberPng  数字图片路径
 * @param SVMModelXmlPath  保存的模型路径
 */
void trainSVM(const string &numberPng,const string &SVMModelXmlPath) {
    Mat img = imread(numberPng);
    Mat gray;
    // 转为灰度图（黑白图）
    cvtColor(img, gray, CV_BGR2GRAY);
    int b = 20;
    int m = gray.rows / b;   //原图为1000*2000
    int n = gray.cols / b;   //裁剪为5000个20*20的小图块
    Mat data, labels;   //特征矩阵
    for (int i = 0; i < n; i++) {
        // 按列截取
        int offsetCol = i * b; //列上的偏移量
        for (int j = 0; j < m; j++) {
            int offsetRow = j * b;  //行上的偏移量
            //截取20*20的小块
            Mat tmp;
            gray(Range(offsetRow, offsetRow + b), Range(offsetCol, offsetCol + b)).copyTo(tmp);
            //序列化，改变行数，将20*20的居中转为 1 * 400， 序列化后放入特征矩阵
            const Mat &reshapeMat = tmp.reshape(0, 1);
            data.push_back(reshapeMat);
            labels.push_back((int) j / 5);  //对应的标注, 就是图片中的数字对应的值
            cout << "label :" << (int) j / 5 << endl;
        }
    }
    data.convertTo(data, CV_32F); //uchar型转换为cv_32f
    int samplesNum = data.rows;
    //前3000个样本为训练数据
    int trainNum = 3000;
    Mat trainData, trainLabels;
    // 将前3000个样本提取出来
    trainData = data(Range(0, trainNum), Range::all());
    // 标注，就是数字值
    trainLabels = labels(Range(0, trainNum), Range::all());
    Ptr<cv::ml::SVM> model = cv::ml::SVM::create();
    // 设置 SVM 的类型为 C-Support Vector Classification (C-SVC)。这是一种常用的 SVM 算法,用于处理二分类问题。
    model->setType(cv::ml::SVM::C_SVC);
    // 设置 SVM 使用线性核函数
    model->setKernel(cv::ml::SVM::LINEAR);
    /**
     * 设置 SVM 的迭代停止条件:
        - 最大迭代次数为 10000
        - 精度阈值为 0.001
       当满足这两个条件之一时,SVM 的训练过程将会停止。
     */
    model->setTermCriteria(TermCriteria(TermCriteria::MAX_ITER + TermCriteria::EPS, 10000, 0.001));
    // 开始训练
    // cv::ml::ROW_SAMPLE: 这是一个常量,表示训练数据集中的每一行代表一个样本；trainData中每个元素就表示一行
    model->train(trainData, cv::ml::ROW_SAMPLE, trainLabels);
    // 保存模型
    model->save(SVMModelXmlPath);
    //预测分类
    double train_hr = 0, test_hr = 0;
    Mat response;
    //计算训练和测试数据的预测误差
    for (int i = 0; i < samplesNum; i++) {
        Mat sample = data.row(i);
        float r = model->predict(sample);   //对所有行进行预测
        //预测结果与原结果相比，相等为1，不等为0
        cout << "predict result: " << r << ", " << std::abs(r - labels.at<int>(i)) << " <= " << FLT_EPSILON << endl;
        r = std::abs(r - labels.at<int>(i)) <= FLT_EPSILON ? 1.f : 0.f;
        if (i < trainNum)
            train_hr += r;  //累积正确数
        else
            test_hr += r;
    }
    test_hr /= samplesNum - trainNum;
    train_hr = trainNum > 0 ? train_hr / trainNum : 1.;
    printf("accuracy: train = %.1f%%, test = %.1f%%\n",
           train_hr * 100., test_hr * 100.);
}
/**
 * 使用训练后的SVM模型进行预测
 * @param numberPng 数字图片路径
 * @param kNNModelXmlPath 模型路径
 */
void predictionSVM(const string & numberPng,const string & SVMModelXmlPath) {
    Mat img = imread(numberPng);
    Mat gray;
    // 转为灰度图（黑白图）
    cvtColor(img, gray, CV_BGR2GRAY);
    int b = 20;
    int m = gray.rows / b;   //原图为1000*2000
    int n = gray.cols / b;   //裁剪为5000个20*20的小图块
    Mat data;   //特征矩阵
    for (int i = 0; i < n; i++) {
        // 按列截取
        int offsetCol = i * b; //列上的偏移量
        for (int j = 0; j < m; j++) {
            int offsetRow = j * b;  //行上的偏移量
            //截取20*20的小块
            Mat tmp;
            gray(Range(offsetRow, offsetRow + b), Range(offsetCol, offsetCol + b)).copyTo(tmp);
            //序列化，改变行数，将20*20的图片转为 1 * 400， 序列化后放入特征矩阵
            const Mat &reshapeMat = tmp.reshape(0, 1);
            data.push_back(reshapeMat);
        }
    }
    data.convertTo(data, CV_32F); //uchar型转换为cv_32f
    // 上面是使用SVM算法进行训练的，预测也用SVM
    cv::Ptr<cv::ml::SVM> model = Algorithm::load<cv::ml::SVM>(SVMModelXmlPath);
    // 遍历数组
    for (int i = 0; i < data.rows; ++i) {
        const Mat &mat = data.row(i);
        Mat result;
        float d = model->predict(mat,result);
        cout << result<<endl;
        cout << "检测到的数字数量: " << d << endl;
    }
}
#endif //TRAIN_CLASS_SVM_H

3、BP(反向传播)

反向传播（BP）

反向传播是一种有监督学习算法，通过不断调整神经网络的权重和偏置项来最小化输出层和目标值之间的误差。在图像分类中，BP神经网络可以用于训练分类器，将图像分为不同的类别。

新建文件：BP.h

//
// Created by W9033927 on 2024/7/10.
//
#ifndef TRAIN_CLASS_BP_H
#define TRAIN_CLASS_BP_H
#include <iostream>
#include<opencv2/opencv.hpp>
#include <random>
#include <dirent.h>
#include <sys/stat.h>
#include "Common.h"
using namespace std;
using namespace cv;
/**
 *  BP神经网络，训练部分
 * @param numberPng 数字图
 * @param BPModelXmlPath 模型保存地址
 */
void trainBPModel(const string &numberPng, const string &BPModelXmlPath) {
    Mat sampleTmp;// = Mat::zeros(5000, 400, CV_32FC1);
    Mat     labelTmp;// = Mat::zeros(5000, 1, CV_32FC1);
    getImgs(numberPng, sampleTmp, labelTmp);
    sampleTmp.convertTo(sampleTmp, CV_32FC1); //uchar型转换为 CV_32FC1
    // 单张图的尺寸为20 * 20 ，所以输入神经元个数为400
    int samcol = 20 * 20;
    // 将标签数据改为one-hot型，因为总归训练的数字0-9之间有10个数字，所以第二个参数为10
    labelTmp = one_hot(labelTmp, 10);
    // ANN_MLP 是 OpenCV 中的一个机器学习类, 称为：（人工神经网络-多层感知机）,它实现了前馈神经网络的训练和预测功能
    Ptr<ml::ANN_MLP> bp = ml::ANN_MLP::create();
    // 以下表示神经网络的层数为3，输入层神经元个数为 samcol个，隐含层为64，输出层为10（因为有10个数字）
    Mat layers_size = (Mat_<int>(1, 3) << samcol, 64, 10); // samcol维点，10维输出
    // 设置神经网络的层数和神经元数量
    bp->setLayerSizes(layers_size);
    // ml::ANN_MLP::BACKPROP 是 ANN_MLP 类中的一个常量, 它表示采用反向传播算法(Back-Propagation)来训练前馈神经网络。
    // 第一个 0.1 表示学习速率，学习速率通常取值在 0 到 1 之间,较小的值能够确保算法稳定收敛,但收敛速度会较慢。较大的值可以加快收敛,但可能会导致算法发散。
    // 第二个 0.1 表示动量系数, 动量系数用于改善标准反向传播算法的收敛特性。动量系数控制了当前梯度与上一次梯度的相对权重,取值范围也在 0 到 1 之间, 适当的动量系数可以加快算法收敛,平滑权重更新,并防止算法陷入局部极小值。
    bp->setTrainMethod(ml::ANN_MLP::BACKPROP, 0.001, 0.1);
    // 设置激活函数为SIGMOID（逻辑斯蒂）
    bp->setActivationFunction(ml::ANN_MLP::SIGMOID_SYM, 1.0, 1.0);
    // 设置训练终止条件为最大迭代次数 1000 次，或误差小于 1e-6,即 0.000001
    // TermCriteria::MAX_ITER 表示使用最大迭代次数作为终止条件。
    bp->setTermCriteria(TermCriteria(TermCriteria::MAX_ITER | TermCriteria::EPS, 100, 0.0001));
    // 使用训练样本 sample 和标签 labelsMat 进行 BP 神经网络的训练
//    cout << sampleTmp.size<<endl;
//    cout << labelTmp.size<<endl;
    bp->train(sampleTmp, ml::ROW_SAMPLE, labelTmp);
    std::cout << "训练完成" << std::endl;
    bp->save(BPModelXmlPath);
    std::cout << "保存完毕" << std::endl;
}
//BP神经网络，测试部分
void testBP(const string &numberPng, const string &BPModelXmlPath) {
    Mat sampleTmp;// = Mat::zeros(5000, 400, CV_32FC1);
    Mat labelTmp;// = Mat::zeros(5000, 1, CV_32FC1);
//    imshow("q", sampleTmp);
//    waitKey(0);
    getImgs(numberPng, sampleTmp, labelTmp);
//    imshow("q1", sampleTmp);
//    waitKey(0);
    sampleTmp.convertTo(sampleTmp, CV_32FC1);
//    labelTmp.convertTo(labelTmp, CV_32FC1);
// 将标签数据改为one-hot型，因为总归训练的数字0-9之间有10个数字，所以第二个参数为10
//    labelTmp = one_hot(labelTmp,10);
//    imshow("q1", sampleTmp);
//    waitKey(0);
//    imshow("q2", labelTmp);
//    waitKey(0);
    Mat responseMat;
    Ptr<ml::ANN_MLP> bp = ml::ANN_MLP::load(BPModelXmlPath);
//    double foldAccuracy0, foldAccuracy1, True0 = 0.0, True1 = 0.0;
    int testResNum = 0;
    // *******************单个识别*******************
    for (int i = 0; i < sampleTmp.rows; ++i) {
        const Mat &e = sampleTmp.row(i);
        bp->predict(e, responseMat);
        double maxVal = 0;
        cv::Point maxPoint;
        cv::minMaxLoc(responseMat, NULL, &maxVal, NULL, &maxPoint);
        int max_index = maxPoint.x;
        int test_index = labelTmp.row(i).at<int32_t>(0, 0);
        cout << "识别结果：" << max_index << "， 真实值：" << test_index << endl;
        if(max_index == test_index) testResNum ++;
    }
    cout << "测试成功的数量："<< testResNum <<", 成功率："<< ((double)testResNum/(double)sampleTmp.rows*100)<<endl;
    // *******************批量识别*****************
//    bp->predict(sampleTmp, responseMat);
//    for (int i = 0; i < responseMat.rows; i++) {
//        // 获取每一个结果的最大值所在下标
//        Mat temp = responseMat.rowRange(i, i + 1);
//        double maxVal = 0;
//        cv::Point maxPoint;
//        cv::minMaxLoc(temp, NULL, &maxVal, NULL, &maxPoint);
//        int max_index = maxPoint.x;
//        int test_index = labelTmp.at<int32_t>(i, 0);
//        cout << "识别结果：" << max_index <<"， 真实值："<<test_index<< endl;
//
//    }
}
#endif //TRAIN_CLASS_BP_H

4、Bayes(正态贝叶斯)

贝叶斯分类器是一种概率模型，利用贝叶斯公式来解决分类问题。假设样本的特征向量服从一定的概率分布，我们就可以计算出该特征向量属于各个类的条件概率。分类结果是条件概率最大的分类结果。如果假设特征向量的每个分量彼此独立，则它是朴素贝叶斯分类器。如果假设特征向量服从多维正态分布，则它是正态贝叶斯分类器。

新建文件Bayes.h

//
// Created by W9033927 on 2024/7/10.
//
#ifndef TRAIN_CLASS_BAYES_H
#define TRAIN_CLASS_BAYES_H
#include <iostream>
#include<opencv2/opencv.hpp>
#include <random>
#include <dirent.h>
#include <sys/stat.h>
#include "Common.h"
using namespace std;
using namespace cv;
//正态贝叶斯分类器，训练部分
void trainBayes(const string &imgPath,const  string &modelXmlPath) {
    Mat samples;
    Mat labels;
    getImgs(imgPath, samples, labels);
    samples.convertTo(samples, CV_32FC1); //uchar型转换为 CV_32FC1
    labels.convertTo(labels, CV_32SC1); //uchar型转换为 CV_32FC1
    Ptr<cv::ml::NormalBayesClassifier> model = cv::ml::NormalBayesClassifier::create();
    //创建TrainData并进行分类器的训练
    Ptr<cv::ml::TrainData> tData = cv::ml::TrainData::create(samples, cv::ml::ROW_SAMPLE, labels);
    cout << "开始训练"<<endl;
    model->train(tData);
    std::cout << "训练完成" << std::endl;
    model->save(modelXmlPath);
    std::cout << "保存完毕" << std::endl;
}
//正态贝叶斯分类器，测试部分
void testBayes(const string &imgPath,const  string &modelXmlPath) {
    Mat samples; Mat labels;
    getImgs(imgPath,samples,labels);
    samples.convertTo(samples, CV_32FC1); //uchar型转换为 CV_32FC1
    labels.convertTo(labels, CV_32SC1);
    Mat responseMat;
    Ptr<ml::NormalBayesClassifier> model = ml::NormalBayesClassifier::load(modelXmlPath);
    double foldAccuracy0, foldAccuracy1, True0 = 0.0, True1 = 0.0;
    for (int i = 0; i < samples.rows; ++i) {
        Mat e = samples.row(i);
        float r = model->predict(e);
        cout << "预测结果："<<r<<", 实际结果："<<labels.at<int>(i, 0)<<endl;
        if (r == labels.at<int>(i, 0)) {
            True0++;
        }
    }
    foldAccuracy0 = True0 / samples.rows;
    std::cout << "训练数据正确率: " << foldAccuracy0 * 100<<"%"<< std::endl;
}
#endif //TRAIN_CLASS_BAYES_H

5、公共头文件 Common.h

//
// Created by W9033927 on 2024/7/12.
//
#ifndef TRAIN_CLASS_COMMON_H
#define TRAIN_CLASS_COMMON_H
#include <iostream>
#include<opencv2/opencv.hpp>
#include <random>
#include <dirent.h>
#include <sys/stat.h>
using namespace std;
using namespace cv;
/**
 * 获取训练数据
 * @param numberPng  数字图地址
 * @param data 训练样本数据矩阵 ，每一行对应一个训练样本
 * @param labels 训练样本的标签矩阵 ，每一行对应一个样本的标签信息
 */
void getImgs(const string &numberPng, Mat &sampleTmp, Mat &labelTmp) {
    Mat img = imread(numberPng);
    Mat gray;
    // 转为灰度图（黑白图）
    cvtColor(img, gray, CV_BGR2GRAY);
    int b = 20;
    int m = gray.rows / b;   //原图为1000*2000
    int n = gray.cols / b;   //裁剪为5000个20*20的小图块
    for (int i = 0; i < n; i++) {
        // 按列截取
        int offsetCol = i * b; //列上的偏移量
        for (int j = 0; j < m; j++) {
            int offsetRow = j * b;  //行上的偏移量
            Mat tmp;
            //截取20*20的小块, 放到 tmp中
            gray(Range(offsetRow, offsetRow + b), Range(offsetCol, offsetCol + b)).copyTo(tmp);
            // 二值化
            threshold(tmp, tmp, 50, 255, THRESH_BINARY);
            // 归一化
            tmp = tmp / 255.0;
            //序列化，改变行数，将20*20的居中转为 1 * 400， 序列化后放入特征矩阵
            const Mat &reshapeMat = tmp.reshape(0, 1);
            Mat m = Mat::zeros(1,400,CV_32FC1);
            reshapeMat.row(0).copyTo(m.row(0));
            // 加入特征矩阵
            sampleTmp.push_back(m);
            //对应的标注, 就是图片中的数字对应的值
            labelTmp.push_back((int) (j / 5));
        }
    }
//    imshow("22",sampleTmp);
//    waitKey(0);
}
//将标签数据改为one-hot型
Mat one_hot(Mat label, int classes_num) {
    /**例如
     * [2]->[0 1 0 0 0 0 0 0 0 0]
     * [4]->[0 0 0 1 0 0 0 0 0 0]
     */
    int rows = label.rows;
//    imshow("33",label);
//    waitKey(0);
    Mat one_hot = Mat::zeros(rows, classes_num, CV_32FC1);
    for (int i = 0; i < label.rows; i++) {
        int index = label.at<int32_t>(i);
        // 将第i行的第index列设为1，
        one_hot.at<float>(i, index) = 1.0;
//        cout << "one_hot" << one_hot.at<float>(i, index) << endl;
    }
    return one_hot;
}
#endif //TRAIN_CLASS_COMMON_H

6、启动函数 和 cmake

main.cpp

#include <iostream>
#include "SVM.h"
#include "BP.h"
#include "KNN.h"
#include "Bayes.h"
// 获取分类器路径
string getStaticPath(){
    // 获取当前工程目录
    string path(PRO_ROOT_DIR);
    // 找到上一级目录
    size_t i = path.find_last_of('/');
    path = path.substr(0, i);
    // 拼接static路径
    path.append("/static");
    return path;
}
int main() {
    string staticPath = getStaticPath();
    string numberPng = staticPath + "/img/digits.png";
    // KNN训练后的模型
    const string &kNNModelXmlPath = staticPath + "/train/KNN_number.xml";
    const string &SVMModelXmlPath = staticPath + "/train/SVM_number.xml";
    const string &BPModelXmlPath = staticPath + "/train/BP_number.xml";
    const string &BayesModelXmlPath = staticPath + "/train/Bayes_number.xml";
    // 训练KNN
//    trainKNNModel(numberPng,kNNModelXmlPath);
//    // 使用训练后的KNN模型进行预测
//    predictionKNN(numberPng,kNNModelXmlPath);
    // 训练SVM
//    trainSVM(numberPng,SVMModelXmlPath);
//    // 使用训练后的SVM模型进行预测
//    predictionSVM(numberPng,SVMModelXmlPath);
//    // 训练BP神经网络
//    trainBPModel(numberPng,BPModelXmlPath);
//    // 测试BP神经网络
//    testBP(numberPng,BPModelXmlPath);
//    // 训练正态贝叶斯
    trainBayes(numberPng,BayesModelXmlPath);
    // 测试正态贝叶斯
    testBayes(numberPng,BayesModelXmlPath);
}

因为是cmake项目，需要 CMakeLists.txt

cmake_minimum_required(VERSION 3.27)
project(train_class)
set(CMAKE_CXX_STANDARD 11)
# 设置OpenCV的路径（根据你自己的安装路径进行更改）
set(OpenCV_DIR "D:\\cpp\\opencv3.4.16_vc14\\sources\\build")
# 定义宏，将项目路径传递给 C++ 代码
# c++通过 代码 ：std::cout << PRO_ROOT_DIR << std::endl; 获取
add_definitions(-DPRO_ROOT_DIR="${CMAKE_SOURCE_DIR}")
find_package(OpenCV REQUIRED)
include_directories(${OpenCV_INCLUDE_DIRS})
# 多目录编译，编译根目录和子目录下的文件
file (GLOB files  *.cpp *.h) # 创建变量files
add_executable(${PROJECT_NAME}  ${files})
target_link_libraries(${PROJECT_NAME} ${OpenCV_LIBS})