【opencv】教程代码 —ml （主成分分析、支持向量机、非线性支持向量机）

 1. introduction_to_pca.cpp  主成分分析

/**
 * @file introduction_to_pca.cpp
 * @brief 这个程序演示了如何使用OpenCV PCA 提取物体的方向
 * @author OpenCV团队
 */


// 包含OpenCV函数库所需要的头文件
#include "opencv2/core.hpp"
#include "opencv2/imgproc.hpp"
#include "opencv2/highgui.hpp"
#include <iostream> // 包含输入输出流的头文件


// 使用std和cv的命名空间，这样我们就可以直接使用它们提供的方法，不用每次都写std::和cv::
using namespace std;
using namespace cv;


// 函数声明
void drawAxis(Mat&, Point, Point, Scalar, const float);
double getOrientation(const vector<Point> &, Mat&);


/**
 * @function drawAxis
 * @brief 绘制轴线的函数
 */
void drawAxis(Mat& img, Point p, Point q, Scalar colour, const float scale = 0.2)
{
    //! [visualization1]
    // 计算以弧度为单位的角度
    double angle = atan2((double)p.y - q.y, (double)p.x - q.x); // p到q的线段角度


    // 计算p和q之间的直线的长度
    double hypotenuse = sqrt((double)(p.y - q.y) * (p.y - q.y) + (p.x - q.x) * (p.x - q.x));


    // 这里通过缩放因子来延长线段的长度
    q.x = (int)(p.x - scale * hypotenuse * cos(angle)); // 计算新的q点的x坐标
    q.y = (int)(p.y - scale * hypotenuse * sin(angle)); // 计算新的q点的y坐标


    // 绘制p点到新q点的直线，这是主线段
    line(img, p, q, colour, 1, LINE_AA);


    // 创建箭头的勾
    // 根据箭头角度计算箭头勾的端点，并绘制箭头勾的第一部分
    p.x = (int)(q.x + 9 * cos(angle + CV_PI / 4)); // 计算箭头勾的一个端点的x坐标
    p.y = (int)(q.y + 9 * sin(angle + CV_PI / 4)); // 计算箭头勾的一个端点的y坐标
    line(img, p, q, colour, 1, LINE_AA); // 绘制箭头勾的第一部分


    // 绘制箭头勾的第二部分
    p.x = (int)(q.x + 9 * cos(angle - CV_PI / 4)); // 计算箭头勾的另一个端点的x坐标
    p.y = (int)(q.y + 9 * sin(angle - CV_PI / 4)); // 计算箭头勾的另一个端点的y坐标
    line(img, p, q, colour, 1, LINE_AA); // 绘制箭头勾的第二部分
    //! [visualization1]
}


/**
 * @function getOrientation
 * @brief 获取方向的函数
 */
double getOrientation(const vector<Point> &pts, Mat &img)
{
    //! [pca]
    // 构造PCA分析使用的数据缓冲区, 每个点的x和y坐标为一行
    int sz = static_cast<int>(pts.size()); // 获取点集的大小
    Mat data_pts = Mat(sz, 2, CV_64F); // 创建Mat对象用于存储点坐标
    for (int i = 0; i < data_pts.rows; i++) // 遍历所有点
    {
        data_pts.at<double>(i, 0) = pts[i].x; // 将点的x坐标放入Mat对象
        data_pts.at<double>(i, 1) = pts[i].y; // 将点的y坐标放入Mat对象
    }


    // 执行PCA分析
    PCA pca_analysis(data_pts, Mat(), PCA::DATA_AS_ROW); // 使用点集进行PCA分析


    // 获取物体的中心点
    Point cntr = Point(static_cast<int>(pca_analysis.mean.at<double>(0, 0)), // 计算平均值点的x坐标
                      static_cast<int>(pca_analysis.mean.at<double>(0, 1))); // 计算平均值点的y坐标


    // 储存特征值和特征向量
    vector<Point2d> eigen_vecs(2); // 创建存储特征向量的向量
    vector<double> eigen_val(2); // 创建存储特征值的向量
    for (int i = 0; i < 2; i++) // 只考虑x和y坐标，因此遍历两个维度
    {
        eigen_vecs[i] = Point2d(pca_analysis.eigenvectors.at<double>(i, 0), // 获取第i个特征向量的x分量
                                pca_analysis.eigenvectors.at<double>(i, 1)); // 获取第i个特征向量的y分量


        eigen_val[i] = pca_analysis.eigenvalues.at<double>(i); // 获取第i个特征值
    }
    //! [pca]


    //! [visualization]
    // 画出主成分，也即特征向量方向
    circle(img, cntr, 3, Scalar(255, 0, 255), 2); // 在中心点画个小圆标记
    // 根据特征值和特征向量计算两个特征点的位置
    Point p1 = cntr + 0.02 * Point(static_cast<int>(eigen_vecs[0].x * eigen_val[0]), static_cast<int>(eigen_vecs[0].y * eigen_val[0]));
    Point p2 = cntr - 0.02 * Point(static_cast<int>(eigen_vecs[1].x * eigen_val[1]), static_cast<int>(eigen_vecs[1].y * eigen_val[1]));
    // 画出两个特征向量构成的轴
    drawAxis(img, cntr, p1, Scalar(0, 255, 0), 1); // 第一个主成分用绿色表示
    drawAxis(img, cntr, p2, Scalar(255, 255, 0), 5); // 第二个主成分用黄色表示


    // 计算并返回第一个主成分的方向角度（弧度值）
    double angle = atan2(eigen_vecs[0].y, eigen_vecs[0].x); // orientation in radians
    //! [visualization]


    return angle; // 返回物体的定向角度
}


/**
 * @function main
 * @brief 主函数
 */
int main(int argc, char** argv)
{
    //! [pre-process]
    // 加载图像
    CommandLineParser parser(argc, argv, "{@input | pca_test1.jpg | input image}");
    parser.about( "This program demonstrates how to use OpenCV PCA to extract the orientation of an object.\n" );
    parser.printMessage();


    // 从文件中读取图像
    Mat src = imread( samples::findFile( parser.get<String>("@input") ) );


    // 检查图像是否成功加载
    if(src.empty())
    {
        cout << "Problem loading image!!!" << endl;
        return EXIT_FAILURE;
    }


    // 显示原始图像
    imshow("src", src);


    // 将图像转换为灰度图
    Mat gray;
    cvtColor(src, gray, COLOR_BGR2GRAY);


    // 将图像转换为二值图
    Mat bw;
    threshold(gray, bw, 50, 255, THRESH_BINARY | THRESH_OTSU);
    //! [pre-process]


    //! [contours]
    // 在阈值处理后的图像中查找所有轮廓
    vector<vector<Point> > contours;
    findContours(bw, contours, RETR_LIST, CHAIN_APPROX_NONE);


    for (size_t i = 0; i < contours.size(); i++)
    {
        // 计算每个轮廓的面积
        double area = contourArea(contours[i]);
        // 忽略面积太小或太大的轮廓
        if (area < 1e2 || 1e5 < area) continue;


        // 仅用于可视化目的绘制每个轮廓
        drawContours(src, contours, static_cast<int>(i), Scalar(0, 0, 255), 2);
        // 获取每个形状的方向
        getOrientation(contours[i], src);
    }
    //! [contours]


    // 显示处理结果图像
    imshow("output", src);


    // 等待用户操作
    waitKey();
    // 正常退出程序
    return EXIT_SUCCESS;
}

该段代码主要演示了如何使用OpenCV里的PCA方法来提取物体的方向。它包括以下几个部分：

1. 获取轮廓并绘制。

2. 使用PCA计算轮廓的方向。

3. 在图像上以直观的方式绘制轴线和方向。

主要的应用场景是，当你有一些形状，并且你想要定量地分析它们的方向时，可以使用这段代码来帮助你提取每个形状的主要方向。

threshold(gray, bw, 50, 255, THRESH_BINARY | THRESH_OTSU);

findContours(bw, contours, RETR_LIST, CHAIN_APPROX_NONE);

2. introduction_to_svm.cpp

该代码的主要功能是使用支持向量机 (SVM) 对简单的2D数据进行分类，并把结果可视化展示出来。它首先设定了一个简单的二维训练数据集和对应的标签，然后创建了一个SVM分类器，并用线性核函数来训练这些数据。之后创建了一个512x512大小的图像，该图像的每个像素代表一个数据点，通过SVM模型对每个点进行分类，并据此为点涂色（绿色为正类，蓝色为负类）。代码还显示了训练数据点，并用不同的颜色标注支持向量。最终，结果图像会被保存并显示给用户。

# 包含OpenCV库相关头文件
#include <opencv2/core.hpp> // 包含OpenCV内核模块的定义
#include <opencv2/imgproc.hpp> // 包含图像处理功能
#include <opencv2/imgcodecs.hpp> // 包含图像编码解码相关功能
#include <opencv2/highgui.hpp> // 包含图形用户界面相关功能
#include <opencv2/ml.hpp> // 包含机器学习模块的功能


// 使用命名空间，简化代码
using namespace cv;
using namespace cv::ml;


int main(int, char**)
{
    // 设置训练数据
    // [setup1]
    int labels[4] = {1, -1, -1, -1}; // 定义标签数组，一类用1表示，另一类用-1表示
    float trainingData[4][2] = { {501, 10}, {255, 10}, {501, 255}, {10, 501} }; // 定义训练数据数组
    // [setup1]
    // [setup2]
    Mat trainingDataMat(4, 2, CV_32F, trainingData); // 将训练数据转换为OpenCV矩阵
    Mat labelsMat(4, 1, CV_32SC1, labels); // 将标签数据转换为OpenCV矩阵
    // [setup2]


    // 训练SVM分类器
    // [init]
    Ptr<SVM> svm = SVM::create(); // 创建一个SVM对象
    svm->setType(SVM::C_SVC); // 设置SVM类型为C-Support Vector Classification
    svm->setKernel(SVM::LINEAR); // 设置SVM核函数为线性核
    svm->setTermCriteria(TermCriteria(TermCriteria::MAX_ITER, 100, 1e-6)); // 设置终止条件
    // [init]
    // [train]
    svm->train(trainingDataMat, ROW_SAMPLE, labelsMat); // 用训练数据和标签训练SVM
    // [train]


    // 为了可视化，定义图像尺寸和图像矩阵
    int width = 512, height = 512;
    Mat image = Mat::zeros(height, width, CV_8UC3);


    // 展示SVM给出的决策区域
    // [show]
    Vec3b green(0,255,0), blue(255,0,0);
    for (int i = 0; i < image.rows; i++)
    {
        for (int j = 0; j < image.cols; j++)
        {
            Mat sampleMat = (Mat_<float>(1,2) << j,i); // 创建一个样本点
            float response = svm->predict(sampleMat); // 预测样本点的响应


            if (response == 1)
                image.at<Vec3b>(i,j)  = green; // 如果预测结果为1，将该点标记为绿色
            else if (response == -1)
                image.at<Vec3b>(i,j)  = blue; // 如果预测结果为-1，将该点标记为蓝色
        }
    }
    // [show]


    // 展示训练数据
    // [show_data]
    int thickness = -1; // 设置圆点的厚度为-1，即实心圆点
    // 在图像中绘制训练数据点
    circle( image, Point(501,  10), 5, Scalar(  0,   0,   0), thickness );
    circle( image, Point(255,  10), 5, Scalar(255, 255, 255), thickness );
    circle( image, Point(501, 255), 5, Scalar(255, 255, 255), thickness );
    circle( image, Point( 10, 501), 5, Scalar(255, 255, 255), thickness );
    // [show_data]


    // 展示支持向量
    // [show_vectors]
    thickness = 2; // 设置支持向量圆点的厚度为2
    Mat sv = svm->getUncompressedSupportVectors(); // 获取未压缩的支持向量


    // 在图像上绘制支持向量点
    for (int i = 0; i < sv.rows; i++)
    {
        const float* v = sv.ptr<float>(i); // 获取每个支持向量的指针
        circle(image,  Point( (int) v[0], (int) v[1]), 6, Scalar(128, 128, 128), thickness); // 绘制支持向量点
    }
    // [show_vectors]


    imwrite("result.png", image);        // 将图像保存为result.png文件


    imshow("SVM Simple Example", image); // 将图像显示给用户
    waitKey(); // 等待用户按键
    return 0;
}

3.  non_linear_svms.cpp

#include <iostream> // 引入IO流库
#include <opencv2/core.hpp> // 引入OpenCV核心功能库
#include <opencv2/imgproc.hpp> // 引入图像处理库
#include "opencv2/imgcodecs.hpp" // 引入图像编解码库
#include <opencv2/highgui.hpp> // 引入GUI库
#include <opencv2/ml.hpp> // 引入机器学习库


using namespace cv; // 使用cv命名空间
using namespace cv::ml; // 使用cv的机器学习命名空间
using namespace std; // 使用标准命名空间


// 声明一个帮助函数，用于显示程序信息
static void help()
{
    cout<< "\n--------------------------------------------------------------------------" << endl
        << "This program shows Support Vector Machines for Non-Linearly Separable Data. " << endl
        << "--------------------------------------------------------------------------"   << endl
        << endl;
}


// 主函数入口
int main()
{
    help(); // 调用帮助函数展示信息


    // 定义一些SVM训练时使用的常量
    const int NTRAINING_SAMPLES = 100;         // 每个类的训练样本数
    const float FRAC_LINEAR_SEP = 0.9f;        // 线性可分部分的样本比例


    // 用于可视化的数据
    const int WIDTH = 512, HEIGHT = 512; // 定义可视化图像的宽和高
    Mat I = Mat::zeros(HEIGHT, WIDTH, CV_8UC3); // 创建一个黑色的可视化图像


    //--------------------- 1. 随机设置训练数据 ---------------------------------------
    Mat trainData(2*NTRAINING_SAMPLES, 2, CV_32F); // 创建训练数据矩阵
    Mat labels   (2*NTRAINING_SAMPLES, 1, CV_32S); // 创建对应的标签矩阵


    RNG rng(100); // 随机数生成器


    // 设置线性可分部分的训练数据
    int nLinearSamples = (int) (FRAC_LINEAR_SEP * NTRAINING_SAMPLES);


    // 类别1的随机点生成
    Mat trainClass = trainData.rowRange(0, nLinearSamples);
    // x坐标的范围是[0, 0.4)
    Mat c = trainClass.colRange(0, 1);
    rng.fill(c, RNG::UNIFORM, Scalar(0), Scalar(0.4 * WIDTH));
    // y坐标的范围是[0, 1)
    c = trainClass.colRange(1,2);
    rng.fill(c, RNG::UNIFORM, Scalar(0), Scalar(HEIGHT));


    // 类别2的随机点生成
    trainClass = trainData.rowRange(2*NTRAINING_SAMPLES-nLinearSamples, 2*NTRAINING_SAMPLES);
    // x坐标的范围是[0.6, 1]
    c = trainClass.colRange(0 , 1);
    rng.fill(c, RNG::UNIFORM, Scalar(0.6*WIDTH), Scalar(WIDTH));
    // y坐标的范围是[0, 1)
    c = trainClass.colRange(1,2);
    rng.fill(c, RNG::UNIFORM, Scalar(0), Scalar(HEIGHT));


    //------------------ 生成非线性可分部分的训练数据 ---------------
    // 为类别1和2的生成随机点
    trainClass = trainData.rowRange(nLinearSamples, 2*NTRAINING_SAMPLES-nLinearSamples);
    // x坐标的范围是[0.4, 0.6)
    c = trainClass.colRange(0,1);
    rng.fill(c, RNG::UNIFORM, Scalar(0.4*WIDTH), Scalar(0.6*WIDTH));
    // y坐标的范围是[0, 1)
    c = trainClass.colRange(1,2);
    rng.fill(c, RNG::UNIFORM, Scalar(0), Scalar(HEIGHT));


    //------------------------ 生成类别的标签 ---------------------------------
    labels.rowRange(                0,   NTRAINING_SAMPLES).setTo(1);  // 类别1
    labels.rowRange(NTRAINING_SAMPLES, 2*NTRAINING_SAMPLES).setTo(2);  // 类别2


    //------------------------ 2. 设置支持向量机的参数 -------------------------
    cout << "Starting training process" << endl;
    Ptr<SVM> svm = SVM::create(); // 创建一个SVM对象
    svm->setType(SVM::C_SVC); // 设置SVM类型为C-SVC
    svm->setC(0.1); // 设置C参数
    svm->setKernel(SVM::LINEAR); // 设置核函数为线性核
    svm->setTermCriteria(TermCriteria(TermCriteria::MAX_ITER, (int)1e7, 1e-6)); // 设置终止条件


    //------------------------ 3. 训练svm --------------------------------------
    svm->train(trainData, ROW_SAMPLE, labels); // 使用训练数据和标签训练SVM
    cout << "Finished training process" << endl;


    //------------------------ 4. 显示决策区域-----------------------------------
    Vec3b green(0,100,0), blue(100,0,0);
    for (int i = 0; i < I.rows; i++)
    {
        for (int j = 0; j < I.cols; j++)
        {
            // 对于图像中的每个点，使用SVM进行预测
            Mat sampleMat = (Mat_<float>(1,2) << j, i);
            float response = svm->predict(sampleMat);


            // 根据预测结果把点对应的颜色涂上
            if      (response == 1) I.at<Vec3b>(i,j) = green;
            else if (response == 2) I.at<Vec3b>(i,j) = blue;
        }
    }


    //----------------------- 5. 显示训练数据 -----------------------------------
    int thick = -1;
    float px, py;
    // 类别1的数据
    for (int i = 0; i < NTRAINING_SAMPLES; i++)
    {
        px = trainData.at<float>(i,0);
        py = trainData.at<float>(i,1);
        // 在图像上画圆来代表数据点
        circle(I, Point( (int) px,  (int) py ), 3, Scalar(0, 255, 0), thick);
    }
    // 类别2的数据
    for (int i = NTRAINING_SAMPLES; i <2*NTRAINING_SAMPLES; i++)
    {
        px = trainData.at<float>(i,0);
        py = trainData.at<float>(i,1);
        circle(I, Point( (int) px, (int) py ), 3, Scalar(255, 0, 0), thick);
    }


    //------------------------- 6. 显示支持向量 ---------------------------------
    thick = 2;
    Mat sv = svm->getUncompressedSupportVectors(); // 获取支持向量


    for (int i = 0; i < sv.rows; i++)
    {
        const float* v = sv.ptr<float>(i);
        // 画出支持向量
        circle(I,  Point( (int) v[0], (int) v[1]), 6, Scalar(128, 128, 128), thick);
    }


    imwrite("result.png", I);                      // 保存生成的图像
    imshow("SVM for Non-Linear Training Data", I); // 展示图像
    waitKey(); // 等待键盘输入
    return 0;
}

本段代码演示了如何使用支持向量机(SVM)对非线性可分数据进行分类。具体包括以下步骤：

1. 随机生成两个类的训练数据和对应的标签；

2. 设置支持向量机的参数并进行训练；

3. 显示SVM的决策区域；

4. 在图像上用不同颜色显示两个类的数据点；

5. 在图像上显示支持向量。

代码运行完成后将会产生一张图像，展示了决策区域和支持向量机如何区分两个类的数据点。

circle(I, Point((int)px, (int)py), 3, Scalar(255, 0, 0), thick);