用c++多个数据点的曲线拟合

横坐标时间t，纵坐标速度km/h，多个点，通过曲线拟合成一条曲线阻力，拟合后函数形式为两种，一种为a+bVV，另一种为a+bV+cV*V，a，b，c为常数，V为速度，通过c++曲线框显示出来

已重编

 
#include<iostream>
#include<cmath>
#include<vector>
using namespace std;
 
struct Point
{
    double x;
    double y;
};
 
// 数据点
vector<Point> data;
 
// 第一种拟合函数：a + b * V * V
double func1(double a, double b, double v)
{
    return a + b * v * v;
}
 
// 第二种拟合函数：a + b * V + c * V * V
double func2(double a, double b, double c, double v)
{
    return a + b * v + c * v * v;
}
 
// 曲线拟合，参数为拟合函数类型，并返回拟合后的常数a，b，c
vector<double> curve_fit(int type)
{
    int n = data.size();
    double sumx = 0, sumy = 0, sumx2 = 0, sumxy = 0, sumx3 = 0, sumx2y = 0, sumx4 = 0, sumx3y = 0;
 
    for (int i = 0; i < n; i++)
    {
        double x = data[i].x;
        double y = data[i].y;
 
        sumx += x;
        sumy += y;
        sumx2 += x * x;
        sumxy += x * y;
        sumx3 += x * x * x;
        sumx2y += x * x * y;
        sumx4 += x * x * x * x;
        sumx3y += x * x * x * y;
    }
 
    double a, b, c;
    if (type == 1)
{
    // 第一种拟合函数的常数求解
    b = (n * sumxy - sumx * sumy) / (n * sumx2 - sumx * sumx);
    a = (sumy - b * sumx) / n;
 
    vector<double> result;
    result.push_back(a);
    result.push_back(b);
    return result;
}
 
    else
    {
        // 第二种拟合函数的常数求解
        double k = n * (sumx2 * sumx2 - sumx * sumx3) - sumx * (sumx * sumx2 - sumx2 * sumx) + (sumx2 * sumx - sumx * sumx2);
        a = (sumx2 * (sumy * sumx2 - sumxy * sumx));
                b = (n * (sumxy * sumx2 - sumx * sumx2y) - sumx * (sumy * sumx2 - sumxy * sumx) + (sumx2y * sumx - sumx2 * sumy)) / k;
        c = (sumy * sumx2 - sumxy * sumx) / (sumx2 * sumx2 - sumx * sumx3);
 
     vector<double> result;
    result.push_back(a);
    result.push_back(b);
    result.push_back(c);
    return result;
    }
}
 
int main()
{
    int n;
    cout << "请输入数据点个数：";
    cin >> n;
 
    cout << "请输入数据点（格式：横坐标t 纵坐标v）：" << endl;
    for (int i = 0; i < n; i++)
{
double x, y;
cin >> x >> y;
x = log(x); // 将横坐标进行对数变换
data.push_back({x, y});
}
 
    int type;
    cout << "请选择拟合函数类型（1代表a + b * V * V，2代表a + b * V + c * V * V）：";
    cin >> type;
 
    vector<double> result = curve_fit(type);
    cout << "拟合结果：" << endl;
    if (type == 1)
    {
        cout << "a = " << result[0] << endl;
        cout << "b = " << result[1] << endl;
        cout << "拟合函数：y = " << result[0] << " + " << result[1] << " * V * V" << endl;
    }
    else
    {
        cout << "a = " << result[0] << endl;
        cout << "b = " << result[1] << endl;
        cout << "c = " << result[2] << endl;
        cout << "拟合函数：y = " << result[0] << " + " << result[1] << " * V + " << result[2] << " * V * V" << endl;
    }
 
    return 0;
}

曲线拟合是一种数学方法，用来估算离散的数据点的连续函数模型。通过曲线拟合，可以得到一条函数模型，用来描述给定的数据点的模式。

在您给定的例子中，横坐标是时间t，纵坐标是速度，使用曲线拟合，可以得到阻力的函数形式。拟合后的函数可能有两种形式，一种是 a + bV * V，另一种是 a + bV + cV * V，其中a，b，c是常数，V是速度。

通过C++曲线拟合库，您可以得到拟合后的曲线，并使用图形化界面将其显示出来。这可以帮助您更好地理解数据并发现任何潜在模式。
对于上面的问题，可以使用C++实现多项式曲线拟合。下面是一个简单的实现代码：
代码如下：

#include <iostream>
#include <vector>
#include <cmath>
#include <opencv2/opencv.hpp>

using namespace std;
using namespace cv;

int main() {
    // 输入横坐标时间和纵坐标速度的数据
    vector<double> t, v;
    cout << "请输入时间t和速度v的数据对：" << endl;
    while (true) {
        double x, y;
        cin >> x >> y;
        if (x < 0 || y < 0) {
            break;
        }
        t.push_back(x);
        v.push_back(y);
    }
    int n = t.size();
    Mat X(n, 3, CV_64F), Y(n, 1, CV_64F);
    for (int i = 0; i < n; i++) {
        X.at<double>(i, 0) = 1;
        X.at<double>(i, 1) = v[i];
        X.at<double>(i, 2) = v[i] * v[i];
        Y.at<double>(i, 0) = t[i];
    }
    Mat theta;
    solve(X, Y, theta, DECOMP_QR);
    double a = theta.at<double>(0, 0);
    double b = theta.at<double>(1, 0);
    double c = theta.at<double>(2, 0);
    cout << "拟合出的阻力函数为：" << endl;
    cout << "f(V) = " << a << " + " << b << "V + " << c << "V^2" << endl;
    return 0;
}

该代码使用了OpenCV的矩阵求解功能，使用了QR分解法进行曲线拟合。代码会读入时间t和速度v的数据对，计算出拟合出的阻力函数。

该回答引用ChatGPT
通过曲线拟合多个点可以得到一条曲线，代表速度随时间变化的关系。如果拟合出来的函数形式为a + bV + cV * V，那么a代表常数项，b代表一次项，c代表二次项，V代表速度。另一种形式a + bV * V，代表的是阻力是速度的平方的函数。

使用c++可以实现曲线拟合的过程，并通过曲线框显示出来。可以通过使用数学库，如Eigen等，实现矩阵运算，以及使用图形库，如OpenCV等，进行图形的绘制。

以下是一个简单的c++曲线拟合的例子，使用的是Eigen库，需要您自行安装该库：

#include <iostream>
#include <Eigen/Dense>

using namespace std;
using namespace Eigen;

int main()
{
    // 设置点的数量
    int n = 100;
    // 创建输入矩阵
    MatrixXd X = MatrixXd::Random(n, 2);
    X.col(0) = X.col(0).array() * 10;
    // 创建输出矩阵
    MatrixXd Y = MatrixXd::Random(n, 1);
    Y = X * Vector2d(2, 3) + Y.array() * 0.1;

    // 计算线性回归参数
    Vector2d w = (X.transpose() * X).inverse() * X.transpose() * Y;
    cout << "The coefficients are: " << endl << w << endl;

    return 0;
}

曲线拟合可以使用Eigen库来实现，首先需要安装Eigen库，然后在代码中包含Eigen头文件，下面是代码的实现示例，其中需要设置的曲线函数形式可以通过更改矩阵A的初始化来实现：

#include <iostream>
#include <vector>
#include <Eigen/Dense>

using namespace Eigen;
using namespace std;

struct DataPoint
{
    double t; // 横坐标，时间
    double v; // 纵坐标，速度
};

std::vector<DataPoint> dataPoints = {{0, 0}, {1, 1}, {2, 2}, {3, 3}};

int main()
{
    int n = dataPoints.size();

    MatrixXd A(n, 3);
    VectorXd b(n);

    // 填充矩阵A和向量b
    for (int i = 0; i < n; i++)
    {
        A(i, 0) = 1.0;
        A(i, 1) = dataPoints[i].t;
        A(i, 2) = dataPoints[i].t * dataPoints[i].t;
        b(i) = dataPoints[i].v;
    }

    // 求解线性方程组
    VectorXd x = A.colPivHouseholderQr().solve(b);

    // 输出拟合后的曲线函数
    std::cout << "The fitted curve is: y = " << x(0) << " + " << x(1) << " * x + " << x(2) << " * x^2" << std::endl;

    return 0;
}

在这段代码中，我们使用了Eigen库中的QR分解来求解线性方程组，并输出了拟合后的曲线函数。

如果要更改拟合的曲线函数，例如改成第二种函数形式a + b * V + c * V * V，可以通过修改矩阵A的初始化代码实现：

MatrixXd A(n, 3);

// 填充矩阵A和向量b
for (int i = 0; i < n; i++)
{
    A(i, 0) = 1

您可以使用一些数学库，如 OpenCV，Eigen 等来实现曲线拟合。以下是一个简单的 C++ 代码，用来实现第一种速度阻力曲线拟合（a+bVV）：

#include <iostream>
#include <vector>
#include <opencv2/opencv.hpp>

using namespace std;
using namespace cv;

int main()
{
    vector<Point2f> data;
    // 以下为模拟数据，请自行替换
    data.push_back(Point2f(0, 0));
    data.push_back(Point2f(1, 10));
    data.push_back(Point2f(2, 20));
    data.push_back(Point2f(3, 30));
    data.push_back(Point2f(4, 40));

    Mat A = Mat::zeros(data.size(), 2, CV_32F);
    Mat B = Mat::zeros(data.size(), 1, CV_32F);
    for (int i = 0; i < data.size(); i++)
    {
        A.at<float>(i, 0) = 1;
        A.at<float>(i, 1) = data[i].y * data[i].y;
        B.at<float>(i, 0) = data[i].x;
    }

    Mat x;
    solve(A, B, x, DECOMP_QR);

    float a = x.at<float>(0, 0);
    float b = x.at<float>(1, 0);

    cout << "a = " << a << ", b = " << b << endl;

    return 0;
}

曲线拟合是数学中的一种常用技术，可以将数据点通过函数拟合成一条曲线。

对于多个数据点，横坐标为时间t，纵坐标为速度V，拟合为a + bV + cV * V或a + bVV的函数，可以使用最小二乘法拟合。最小二乘法是通过最小化误差的平方和来确定函数的参数的常用方法。

下面是一个简单的代码示例，该代码使用了Eigen库，用于矩阵计算：

#include
#include <Eigen/Dense>

using namespace std;
using namespace Eigen;

int main() {
// 定义数据点
MatrixXd data(n, 2);
data << t1, V1,
t2, V2,
...
tn, Vn;

// 定义系数矩阵
MatrixXd coeff(3, 1);

// 最小二乘法拟合
MatrixXd X(n, 3);
X.col(0) = VectorXd::Ones(n);
X.col(1) = data.col(1);
X.col(2) = data.col(1).array() * data.col(1).array();
coeff = (X.transpose() * X).inverse() * X.transpose() * data.col(0);

// 输出拟合的函数
cout << "Fitted function: y = " << coeff(0, 0) << " + " << coeff(1, 0) << " * V + " << coeff(2, 0) << " * V * V" << endl;

return 0;
}

最后，您可以使用任何图形库（例如Matplotlib，QCustomPlot等）绘制拟合后的曲线。望采纳

下面是一个示例，说明如何使用流行的图形库 Qt 在 C++ 中显示曲线拟合结果。 您需要先安装该库，然后在您的代码中包含必要的标头。

#include <QtWidgets/QApplication>
#include <QtWidgets/QMainWindow>
#include <QtCharts/QChartView>
#include <QtCharts/QLineSeries>

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);

    // Define the x and y data for the curve
    QVector<double> x(100), y(100);
    for (int i = 0; i < 100; i++) {
        x[i] = i;
        // Compute the y values using either a+bVV or a+bV+cV *V, with some arbitrary values for a, b, and c
        y[i] = a + b * pow(x[i], 2) + c * pow(x[i], 3);
    }

    // Create a line series to represent the curve
    QLineSeries *series = new QLineSeries();
    for (int i = 0; i < x.size(); i++) {
        series->append(x[i], y[i]);
    }

    // Create a chart and set the line series as the data
    QChart *chart = new QChart();
    chart->addSeries(series);
    chart->createDefaultAxes();

    // Display the chart in a chart view
    QChartView *chartView = new QChartView(chart);
    chartView->setRenderHint(QPainter::Antialiasing);

    // Show the chart view in a main window
    QMainWindow window;
    window.setCentralWidget(chartView);
    window.resize(800, 600);
    window.show();

    return a.exec();
}

在此示例中，x 和 y 数组用于存储曲线的 x 和 y 值。 y 的值是基于 a + b * pow(x[i], 2) 或 a + b * x[i] + c * pow(x[i], 2) 计算的，a 的一些任意值 、b 和 c。 曲线由 QLineSeries 表示，数据添加到 QChart 对象。 图表显示在嵌入在 QMainWindow 中的 QChartView 中。

// Initialize the matrices
vector<vector<double>> A(n, vector<double>(degree + 1, 0));
vector<double> B(n, 0);

// Fill the matrices
for (int i = 0; i < n; i++)
{
    B[i] = points[i].y;
    for (int j = 0; j <= degree; j++)
        A[i][j] = pow(points[i].x, j);
}

// Solve the linear system
vector<double> coefficients = gaussianElimination(A, B);

return coefficients;



// Perform Gaussian Elimination
for (int i = 0; i < n - 1; i++)
{
    // Find the row with maximum value of A[i][i]
    int maxRow = i;
    for (int k = i + 1; k < n; k++)
    {
        if (abs(A[k][i]) > abs(A[maxRow][i]))
            maxRow = k;
    }

    // Swap the max row with the current row (row i)
    for (int k = i; k < n; k++)
        swap(A[maxRow][k], A[i][k]);
    swap(B[maxRow], B[i]);

    // Make all the rows below this one 0 in current column
    for (int k = i + 1; k < n; k++)
    {
        double c = -A[k][i] / A[i][i];
        for (int j = i; j < n; j++)
        {
            if (i == j)
                A[k][j] = 0;
            else
                A[k][j] += c * A[i][j];
        }
        B[k] += c * B[i];
    }
}

// Solve the equation Ax=B for an upper triangular matrix A
vector<double> x(n, 0);
for (int i = n - 1; i >= 0; i--)
{
    x[i] = B[i];
    for (int k = i + 1; k < n; k++)
        x[i] -= A[i][k] * x[k];
    x[i] /= A[i][i];
}

return x;


// Calculate the coefficients of the polynomial
vector<double> coefficients = polyfit(points, 2);

// Print the coefficients
cout << "Coefficients: ";
for (double c : coefficients)
    cout << c << " ";
cout << endl;

return 0;

你这个结果太大，我们从50公里往下走，b的系数应该很小，你的有1.多，导致阻力过大，实际是很小的

首先，您需要准备好您的数据点。在这种情况下，您的数据点是时间t和速度V。然后，您需要选择一个合适的数学模型，这里是您给出的两种：

a + bVV

a + bV + cV * V

在这两种情况下，a，b和c是常数。

接下来，您需要使用c++代码来计算拟合曲线的参数，这通常可以通过最小二乘法实现。最后，您可以通过画图程序将拟合曲线与原始数据点显示在一起。
第一种情况的曲线拟合：

#include <iostream>
#include <cmath>
#include <Eigen/Dense>
using namespace std;
using namespace Eigen;

// 计算最小二乘法的系数
void leastSquares(double x[], double y[], int n, double &a, double &b)
{
    MatrixXd X(n, 2);
    VectorXd Y(n), beta(2);
    for (int i = 0; i < n; i++)
    {
        X(i, 0) = 1;
        X(i, 1) = x[i] * x[i];
        Y(i) = y[i];
    }
    beta = (X.transpose() * X).inverse() * X.transpose() * Y;
    a = beta(0);
    b = beta(1);
}

int main()
{
    double x[] = {...}; // 横坐标数据
    double y[] = {...}; // 纵坐标数据
    int n = sizeof(x) / sizeof(x[0]);
    double a, b;
    leastSquares(x, y, n, a, b);

    cout << "a = " << a << endl;
    cout << "b = " << b << endl;

    return 0;
}

第二种情况的曲线拟合：

#include <iostream>
#include <cmath>
#include <Eigen/Dense>
using namespace std;
using namespace Eigen;

// 计算最小二乘法的系数
void leastSquares(double x[], double y[], int n, double &a, double &b, double &c)
{
    MatrixXd X(n, 3);
    VectorXd Y(n), beta(3);
    for (int i = 0; i < n; i++)
    {
        X(i, 0) = 1;
        X(i, 1) = x[i];
        X(i, 2) = x[i] * x[i];
        Y(i) = y[i];
    }
    beta = (X.transpose() * X).inverse() * X.transpose() * Y;
    a = beta(0);
    b = beta(1);
    c = beta(2);
}

int main()
{
    double x[] = {...}; // 横坐标数据
    double y[] = {...}; // 纵坐标数据
    int n = sizeof(x) / sizeof(x[0]);
    double a, b, c;
    leastSquares(x, y, n, a, b, c);

    cout << "a = " << a << endl;
    cout << "b = " << b << endl;
    cout << "c = " << c << endl;

    return 0;
}

在上面的代码中，我们使用了Eigen库来计算最小二乘法的系数。您可以使用其他数值计算库，例如GSL，也可以自行实现最小二乘法的计算。

不知道你这个问题是否已经解决, 如果还没有解决的话:

• 这篇博客也许可以解决你的问题👉 ：c++曲线拟合：贝塞尔曲线的控制点计算

如果你已经解决了该问题, 非常希望你能够分享一下解决方案, 写成博客, 将相关链接放在评论区, 以帮助更多的人 ^-^

#include <iostream>
#include <Eigen/Dense>

using namespace std;
using namespace Eigen;

int main()
{
    int n = 100;
    MatrixXd A(n, 3);
    VectorXd t(n), v(n), x(3);

    // 随机生成时间和速度数据
    for (int i = 0; i < n; i++)
    {
        t(i) = i;
        v(i) = sin(0.1 * t(i)) + 0.1 * t(i);
        A(i, 0) = 1;
        A(i, 1) = v(i);
        A(i, 2) = v(i) * v(i);
    }

    // 最小二乘拟合
    x = (A.transpose() * A).inverse() * A.transpose() * v;

    cout << "The parameters are: " << endl;
    cout << x << endl;

    return 0;
}

这些曲线是通过一种称为多项式曲线拟合的算法得到的。该算法的目的是根据已知的数据点（横坐标为时间t，纵坐标为速度），找到一条函数曲线，使该曲线与这些数据点有最低的误差。

拟合后的曲线形式分别为：

a + bVV：这是一个线性曲线，其中a和b是常数，V是速度。

a + bV + cVV：这是一个二次曲线，其中a，b，c是常数，V是速度。

这些曲线的形式取决于所使用的拟合算法，以及所需要的拟合精度。

如果出现倾斜的情况，可能是因为误差过大，拟合的曲线不能很好地描述数据。在这种情况下，可以尝试使用更高阶的曲线，或者使用更多的数据点来提高拟合的精度。

要在 C++ 中实现曲线拟合和显示，可以使用一些常用的数学库和图形库，例如 Eigen、GSL、OpenCV 等。以下是一个简单的示例代码，用于根据给定的速度和阻力数据点进行曲线拟合，并使用 OpenCV 显示拟合后的曲线：

#include <iostream>
#include <vector>
#include <opencv2/opencv.hpp>
#include <Eigen/Dense>

using namespace std;
using namespace cv;
using namespace Eigen;

// 定义拟合函数形式，此处选择二次函数形式
double func(double v, double a, double b, double c) {
    return a + b*v + c*v*v;
}

int main() {
    // 读入速度和阻力数据点
    vector<double> v = {10, 20, 30, 40, 50, 60, 70, 80, 90, 100};
    vector<double> f = {0.1, 0.3, 0.6, 1.0, 1.5, 2.2, 3.0, 4.0, 5.0, 6.5};
    int n = v.size();

    // 使用 Eigen 库进行曲线拟合
    MatrixXd A(n, 3);
    VectorXd b(n);
    for (int i = 0; i < n; i++) {
        A(i, 0) = 1;
        A(i, 1) = v[i];
        A(i, 2) = v[i] * v[i];
        b(i) = f[i];
    }
    Vector3d x = A.colPivHouseholderQr().solve(b);

    // 在 OpenCV 中显示拟合后的曲线
    Mat img(600, 800, CV_8UC3, Scalar(255, 255, 255));
    double a = x(0);
    double b = x(1);
    double c = x(2);
    for (double v = 0; v <= 120; v += 0.1) {
        double f = func(v, a, b, c);
        int y = 600 - f * 10;
        int x = v * 8;
        circle(img, Point(x, y), 2, Scalar(0, 0, 255), -1);
    }
    imshow("Curve Fitting", img);
    waitKey(0);
    return 0;
}

C++实现曲线拟合的算法有很多，如最小二乘法、最小均方差、最小角度回归、最小偏差拟合等。
这个可以用最小二乘法

对于多个数据点的曲线拟合，常见的方法有最小二乘法和样条插值法。

最小二乘法可以通过拟合一条线性方程或者二次方程来得到拟合曲线，其中线性方程为y = ax + b，二次方程为y = ax^2 + bx + c。这里可以使用Eigen库提供的Least Squares method，对数据点进行线性或二次拟合，得到拟合系数a、b、c。

样条插值法则是通过将数据点连接起来，将每个小区间内的函数表示为一个低次多项式，并满足该函数在各个数据点上的取值和导数都相等，通过连接这些小多项式，得到一条光滑的曲线。这里可以使用第三方库进行实现，例如Cubic Spline Interpolation。

假设有多组数据 $(x_i, y_i)$，要通过拟合得到一个二次曲线 $y = ax^2 + bx + c$。可以使用最小二乘法来实现：

#include <iostream>
#include <vector>
#include <cmath>

using namespace std;

// 最小二乘法
void LeastSquareMethod(vector<double> x, vector<double> y, double& a, double& b, double& c)
{
    int n = x.size();
    double sum_x = 0, sum_x2 = 0, sum_x3 = 0, sum_x4 = 0, sum_y = 0, sum_xy = 0, sum_x2y = 0;

    for (int i = 0; i < n; i++)
    {
        double x2 = x[i] * x[i];
        sum_x += x[i];
        sum_x2 += x2;
        sum_x3 += x2 * x[i];
        sum_x4 += x2 * x2;
        sum_y += y[i];
        sum_xy += x[i] * y[i];
        sum_x2y += x2 * y[i];
    }

    double A = sum_x2 * sum_x4 - sum_x3 * sum_x3;
    double B = sum_x * sum_x4 - sum_x2 * sum_x3;
    double C = sum_x * sum_x3 - sum_x2 * sum_x2;
    double D = sum_x * sum_x2y - sum_xy * sum_x2;
    double E = sum_y * sum_x4 - sum_x2 * sum_x2y;
    double F = sum_y * sum_x3 - sum_x * sum_x2y;

    double delta = A * n - B * sum_x;

    a = (D * n - B * F) / delta;
    b = (A * F - D * C) / delta;
    c = (E * sum_x - D * B) / delta;
}

int main()
{
    vector<double> x = { 0, 1, 2, 3, 4, 5 };
    vector<double> y = { 0.5, 4.8, 10.9, 20.2, 30.8, 43.7 };
    double a, b, c;
    LeastSquareMethod(x, y, a, b, c);
    cout << "y = " << a << "x^2 + " << b << "x + " << c << endl;

    return 0;
}

这个程序中，LeastSquareMethod 函数用来实现最小二乘法，根据输入的数据点 x 和 y，通过数学公式计算出拟合曲线的系数 a、b、c。在 main 函数中，先定义输入数据点的横纵坐标分别为 x 和 y，然后调用 LeastSquareMethod 函数计算出拟合曲线的系数，最后输出拟合曲线的方程。

需要注意的是，这里只是一个简单的例子，对于不同的曲线和不同的数据点，最小二乘法的具体实现可能会有所不同。

要在C++中显示曲线，您可以使用第三方库，例如gnuplot或Qt。下面是使用gnuplot的示例代码，该代码使用数据点来生成曲线，并将其保存为PNG文件。您需要在系统上安装gnuplot软件以使此代码工作。

#include <iostream>
#include <fstream>
#include <string>
#include <vector>

using namespace std;

int main() {
    // Generate data points
    vector<double> time = {0.0, 1.0, 2.0, 3.0, 4.0};
    vector<double> velocity = {0.0, 20.0, 40.0, 60.0, 80.0};

    // Open a pipe to gnuplot
    FILE* gnuplotPipe = popen("gnuplot -persist", "w");

    // Plot data points
    fprintf(gnuplotPipe, "set terminal png\n");
    fprintf(gnuplotPipe, "set output 'curve.png'\n");
    fprintf(gnuplotPipe, "plot '-' with lines title 'Velocity'\n");
    for (int i = 0; i < time.size(); i++) {
        fprintf(gnuplotPipe, "%f %f\n", time[i], velocity[i]);
    }
    fprintf(gnuplotPipe, "e\n");

    // Close the pipe
    pclose(gnuplotPipe);

    return 0;
}

该代码使用vector保存时间和速度数据点，然后使用gnuplot打开一个管道，将绘图命令发送到gnuplot中，并绘制曲线。您可以调整绘图命令来使用您的自定义曲线公式。

https://blog.csdn.net/weixin_35755434/article/details/128870221

首先，根据您提供的横座标时间t和宽座标速度km/h，可以使用c++曲线架模拟出一条曲线，模拟出的曲线可以用++两种形式Va，b中型Va： ，b，c为常数，V为速度。具体的代号实际可以参考以下步骤： 1. 定义横座标时间t和宽座标速度km/h，并将其存储在数组中。 2. c++使用替换模拟出一条曲线，模拟出的曲线可以用两种形式表示：a+bVV和Vc，其中a，b，c为常数，V为速度。 3.使用c++曲线框将模拟出的曲线4. 定义一个函数，用于计算模拟出的曲线的值，函数的参数为​​横座标时间t和宽座标速度km/h，函数的返回值的模拟出5。 .使用c++曲线框将模拟出的曲线显示出来。