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

 1. introduction_to_pca.cpp  主成分分析

f413a9b3dcae27dd0c4b4a9ae2bc7e13.png

a8c24e187bf9bdc621952a8f113a27ea.png

811132a96e6e9d6b190226f44e70dd2b.png

/**
 * @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);

e23ade3347998dd29b7ac2fec93afb3a.png

findContours(bw, contours, RETR_LIST, CHAIN_APPROX_NONE);

295a1b26c4872ac92fdc34eca22c5a78.png

2. introduction_to_svm.cpp

57aa078e9b7992dbba8d30148d9850c8.png

0d991dc47fd45002ab70c0c86cfd388d.png

该代码的主要功能是使用支持向量机 (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;
}

7aa460acb9344afd65fa1c032c4aa568.png

97eab6acd3192ee8360eaec3d9778f92.png

3.  non_linear_svms.cpp

bfa0ddde9d845aa8f886ef89b5d37d63.png

d1beb52a10993a50b38a8da3e0531b1c.png

#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. 在图像上显示支持向量。

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

53754b59c43c29850485e4c44ba4099a.png

16f88db0ea512ca9a0f3eb42c6f88a83.png

95fbf2b70055fa384efe64ae0951e391.png

90796e788ecbee799d67c7ca58e05197.png

c35fc34a86a0716435cde128fab3b626.png

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

fedcf01d0f9f2915b0aff89e316b2a7f.png

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:/a/519325.html

如若内容造成侵权/违法违规/事实不符,请联系我们进行投诉反馈qq邮箱809451989@qq.com,一经查实,立即删除!

相关文章

人工智能数据分析Python常用库 04 matplotlib库

文章目录 一、matplotlib库的作用与环境配置1、环境配置示例2、改变绘图风格3、保存图片 二、绘制二维图形1、折线图&#xff08;1&#xff09;示例&#xff08;2&#xff09;调整线条颜色&#xff1a;&#xff08;3&#xff09;调整线条风格&#xff08;4&#xff09;调整线宽…

深入浅出 -- 系统架构之分布式CAP理论和BASE理论

科技进步离不开理论支撑&#xff0c;而当下大行其道的分布式架构&#xff0c;透过繁荣昌盛表象&#xff0c;底层同样离不开诸多分布式理论撑持。当然&#xff0c;相信诸位在学习分布式相关技术时&#xff0c;必然学到过两个分布式领域中的基础理论&#xff0c;即&#xff1a;CA…

设置Chrome打开链接在新标签页显示

Chrome版本 版本 123.0.6312.106&#xff08;正式版本&#xff09; &#xff08;64 位&#xff09; 下面这两个页面都有设置按钮&#xff1a; https://www.google.com/?pli1或者https://www.google.com/?hlzh-CN 要先退出账号&#xff0c;要不然看不到右下角的 “设置” 。…

SpamSieve mac垃圾邮件过滤器 直装激活版

SpamSieve通过强大的垃圾邮件过滤技术&#xff0c;帮助用户有效管理和消除不想要的电子邮件。它能与多种电子邮件客户端无缝集成&#xff0c;如Apple Mail、Microsoft Outlook、Airmail等。 软件下载&#xff1a;SpamSieve mac直装激活版下载 该软件利用先进的算法和机器学习技…

Vue知识点(学习笔记)

Vue知识点学习 一、Vue快速上手1. 脚本引用 二、Vue小知识1. 简写v-bindv-modelel和data的两种写法&#xff1a;eldata 2. MVVM模型3. Object.defineproperty方法4. Vue的数据代理5. 事件处理6. 阻止默认事件7. Vue中事件修饰符&#xff1a;8. 引入Element-Ui 一、Vue快速上手 …

虚幻UE5数字孪生蓝图开发教程

一、背景 这几年&#xff0c;智慧城市/智慧交通/智慧水利等飞速发展&#xff0c;骑士特意为大家做了一个这块的学习路线。 二、这是学习大纲 1.给虚幻UE5初学者准备的智慧城市/数字孪生蓝图开发教程 https://www.bilibili.com/video/BV1894y1u78G 2.UE5数字孪生蓝图开发教学…

BPMNJS 在原生HTML中的引入与使用

BPMNJS 在HTML中的引入与使用 在网上看到的大多是基于vue使用BPMN的示例或者教程&#xff0c;竟然没有在HTML使用的示例&#xff0c;有也是很简单的介绍核心库的引入和使用&#xff0c;并没有涉及到扩展库。于是简单看了下&#xff0c;真的是一波三折&#xff0c;坎坎坷坷。不…

FreeRtos入门-5 任务通知

在FreeRTOS中&#xff0c;任务通知、队列、信号量和事件组都是用于任务间通信和同步的机制&#xff0c;但它们各自具有不同的特性和适用场景。 任务通知的主要优势在于其高效性和明确性。使用任务通知发送事件或数据给某个任务时&#xff0c;效率更高&#xff0c;且可以明确指定…

Tuxera2023 NTFS for Mac下载,安装和序列号激活

对于必须在Windows电脑和Mac电脑之间来回切换的Mac朋友来说&#xff0c;跨平台不兼容一直是一个巨大的障碍&#xff0c;尤其是当我们需要使用NTFS格式的硬盘在Windows和macOS之间共享文件时。因为Mac默认不支持写入NTFS磁盘。 为了解决这一问题&#xff0c;很多朋友会选择很便捷…

linux操作系统安装及命令初识,上岸蚂蚁金服

310 包&#xff09; desktop 1800个包左右 内容必须大于 768M 系统设置 分区设置 挂载点 /boot / swap 交换分区–占用磁盘容量 网络配置 网卡配置 设置为ON 主机名配置 Begin installation 设置 root 用户密码 命令初识 命令 选项 参数&#xff1a; 命令选项参数…

Restful Web Service

Restful 1.特点 RESTful是一种架构风格&#xff0c;强调简单、轻量级和对资源的状态less操作。RESTful是通过HTTP协议进行通信的。RESTful的应用程序可以调用运行在不同服务器上的服务或函数。RESTful的接口通常使用JSON&#xff0c;但实际上它们都支持多种数据格式。RESTful…

Trace链异常检测汇总

微服务应用与单块应用完全不同&#xff0c;一个微服务系统少则有几十个微服务组成&#xff0c;多则可能有上百个服务。比如BAT级别的互联网公司&#xff0c;一般都超过上百个服务&#xff0c;服务之间的依赖关系错综复杂&#xff0c;如果没有有效的监控手段&#xff0c;那么出现…

风控系统之普通规则条件,使用LiteFlow实现

个人博客&#xff1a;无奈何杨&#xff08;wnhyang&#xff09; 个人语雀&#xff1a;wnhyang 共享语雀&#xff1a;在线知识共享 Github&#xff1a;wnhyang - Overview 提要 参考&#xff1a;智能风控筑基手册&#xff1a;全面了解风控决策引擎 前面有可配置输入参数的接…

Gson的用法

1. 导入依赖 <dependency><groupId>com.google.code.gson</groupId><artifactId>gson</artifactId><version>2.8.6</version> </dependency> 2. 使用Gson进行解析 2.1 Gson解析普通对象 package com.jiang.partnetbackend.…

六、企业级架构缓存篇之memcached

一、memcached概述 1、网站架构优化流程&#xff1a; LNMP架构中网站应用访问流程&#xff1a; 浏览器 (app) → web 服务器 → 后端服务 (php) → 数据库 (mysql) 访问流程越多&#xff0c;访问速度越慢&#xff0c;出现问题的几率也越大。 网站访问流程优化思路&#xff1…

软件测试(测试用例详解)(三)

1. 测试用例的概念 测试用例&#xff08;Test Case&#xff09;是为了实施测试而向被测试的系统提供的一组集合。 测试环境操作步骤测试数据预取结果 测试用例的评价标准&#xff1a; 用例表达清楚&#xff0c;无二义性。。用例可操作性强。用例的输入与输出明确。一条用例只有…

c语言之向main函数传递参数

在c语言中&#xff0c;main函数也是可以传递传递参数的&#xff0c;业内向main函数传递参数的格式是 main(int argc,char *argv[]) 向main函数传递参数不是通过代码传递的&#xff0c;一般是通过dos命令传递 举个例子 #include<stdio.h> void main(int argc,char *ar…

算法刷题应用知识补充--基础算法、数据结构篇

这里写目录标题 位运算&#xff08;均是拷贝运算&#xff0c;不会影响原数据&#xff0c;这点要注意&#xff09;&、|、^位运算特性细节知识补充对于n-1的理解异或来实现数字交换找到只出现一次的数据&#xff0c;其余数据出现偶数次 >> 、<<二进制中相邻的位的…

算法设计与分析实验报告c++实现(排序算法、三壶谜题、交替放置的碟子、带锁的门)

一、实验目的 1&#xff0e;加深学生对分治法算法设计方法的基本思想、基本步骤、基本方法的理解与掌握&#xff1b; 2&#xff0e;提高学生利用课堂所学知识解决实际问题的能力&#xff1b; 3&#xff0e;提高学生综合应用所学知识解决实际问题的能力。 二、实验任务 1、 编…

为什么mac文件拖拽不了 mac文件拖不进硬盘里 macbookpro文件无法拖进移动硬盘 Tuxera NTFS for Mac 2023绿色

如果你是一位Mac用户&#xff0c;你可能会遇到这样的问题&#xff1a;你想把Mac上的文件拖拽到其他位置&#xff0c;比如桌面、文件夹或者外接硬盘&#xff0c;但是却发现无法操作&#xff0c;这是为什么呢&#xff1f;这篇文章将为你解答为什么mac文件拖拽不了&#xff0c;以及…