vc实现b样条曲线鼠标交互的代码

这里提供一个简单的B样条曲线鼠标交互的VC++代码，仅供参考：

#include <afxwin.h>
#include <afxext.h>
#include <math.h>

#define MAX_DEGREE 20
#define MAX_KNOTS 200
#define MAX_POINTS 200

// 定义控制点结构体
struct ControlPoint
{
    double x, y;
};

// 定义B样条曲线类
class BSplineCurve
{
public:
    BSplineCurve(int k, int n, int m, double* knots, ControlPoint* control_points);

    // 插值函数
    double Interpolate(double u);

    // 绘制函数
    void Draw(CDC& dc, CRect rect);

    // 鼠标事件处理函数
    void OnMouseMove(CPoint point);
    void OnLButtonDown(CPoint point);
    void OnLButtonUp(CPoint point);

private:
    int k; // B样条曲线次数
    int n; // 控制点个数
    int m; // 节点个数
    double* knots; // 节点数组
    ControlPoint* control_points; // 控制点数组
    double* coef; // 系数数组

    // 计算系数
    void CalcCoef();
};

BSplineCurve::BSplineCurve(int k, int n, int m, double* knots, ControlPoint* control_points)
{
    this->k = k;
    this->n = n;
    this->m = m;

    // 分配存储空间
    this->knots = new double[m];
    this->control_points = new ControlPoint[n];
    this->coef = new double[n];

    // 复制数组
    memcpy(this->knots, knots, m * sizeof(double));
    memcpy(this->control_points, control_points, n * sizeof(ControlPoint));

    // 计算系数
    CalcCoef();
}

double BSplineCurve::Interpolate(double u)
{
    // 查找u所在的区间
    int i;
    for (i = k - 1; i < m - k; i++)
    {
        if (u >= knots[i] && u < knots[i + 1])
            break;
    }

    // 计算基函数值
    double* N = new double[n];
    for (int j = 0; j < n; j++)
        N[j] = 0;

    N[i] = 1;
    for (int d = 1; d <= k; d++)
    {
        for (int j = i - d + 1; j <= i; j++)
        {
            double alpha = (u - knots[j]) / (knots[j + d] - knots[j]);
            double beta = 1 - alpha;

            double N1 = N[j];
            double N2 = (j + 1 <= i + k - d) ? N[j + 1] : 0;

            N[j] = beta * N1 + alpha * N2;
        }
    }

    // 计算插值结果
    double result = 0;
    for (int j = 0; j < n; j++)
        result += coef[j] * N[j];

    delete[] N;

    return result;
}

void BSplineCurve::Draw(CDC& dc, CRect rect)
{
    CPen pen(PS_SOLID, 1, RGB(0, 0, 0));
    dc.SelectObject(&pen);

    double step = (knots[m - 1] - knots[k - 1]) / rect.Width();
    double u = knots[k - 1];

    while (u <= knots[m - k])
    {
        double x = u;
        double y = Interpolate(u);

        int ix = (int)((x - knots[k - 1]) / step);
        int iy = (int)((y - knots[k - 1]) / step);

        dc.SetPixel(ix, iy, RGB(255, 0, 0));

        u += step;
    }

    for (int i = 0; i < n; i++)
    {
        int ix = (int)((control_points[i].x - knots[k - 1]) / step);
        int iy = (int)((control_points[i].y - knots[k - 1]) / step);

        dc.SetPixel(ix, iy, RGB(0, 0, 255));
    }
}

void BSplineCurve::OnMouseMove(CPoint point)
{
    control_points[n - 1].x = (double)point.x;
    control_points[n - 1].y = (double)point.y;

    CalcCoef();
}

void BSplineCurve::OnLButtonDown(CPoint point)
{
    if (n < MAX_POINTS)
    {
        control_points[n].x = (double)point.x;
        control_points[n].y = (double)point.y;

        n++;

        CalcCoef();
    }
}

void BSplineCurve::OnLButtonUp(CPoint point)
{
}

void BSplineCurve::CalcCoef()
{
    // 初始化系数数组
    for (int i = 0; i < n; i++)
        coef[i] = 0;

    // 计算系数
    for (int i = 0; i < n; i++)
    {
        double* N = new double[m];
        for (int j = 0; j < m; j++)
            N[j] = 0;

        N[knots[i] <= knots[m - k] ? m - 1 : k - 1] = 1;
        for (int d = 1; d <= k; d++)
        {
            for (int j = m - k + d - 1; j >= k - d; j--)
            {
                double alpha = (knots[j + k - d] - knots[i]) / (knots[j + k - d] - knots[j]);
                double beta = 1 - alpha;

                double N1 = N[j + 1];
                double N2 = (j + k <= m - 1) ? N[j] : 0;

                N[j] = alpha * N1 + beta * N2;
            }
        }

        // 累加系数
        for (int j = 0; j < n; j++)
        {
            coef[j] += N[j] * control_points[i].y;
        }

        delete[] N;
    }
}

// 定义主窗口类
class CMainFrame : public CFrameWnd
{
public:
    CMainFrame();

protected:
    afx_msg void OnPaint();
    afx_msg void OnMouseMove(UINT nFlags, CPoint point);
    afx_msg void OnLButtonDown(UINT nFlags, CPoint point);
    afx_msg void OnLButtonUp(UINT nFlags, CPoint point);
    DECLARE_MESSAGE_MAP()

private:
    BSplineCurve* curve;
};

CMainFrame::CMainFrame()
{
    Create(NULL, _T("B-Spline Curve"), WS_OVERLAPPEDWINDOW, CRect(0, 0, 640, 480));

    // 初始化控制点数组
    ControlPoint* control_points = new ControlPoint[MAX_POINTS];
    control_points[0].x = 100;
    control_points[0].y = 200;
    control_points[1].x = 200;
    control_points[1].y = 300;
    control_points[2].x = 300;
    control_points[2].y = 200;

    // 初始化节点数组
    int k = 3;
    int n = 3;
    int m = n + k;
    double* knots = new double[m];
    knots[0] = knots[1] = knots[2] = 0;
    knots[3] = knots[4] = knots[5] = 1;

    curve = new BSplineCurve(k, n, m, knots, control_points);
}

void CMainFrame::OnPaint()
{
    CPaintDC dc(this);
    CRect rect;
    GetClientRect(&rect);

    curve->Draw(dc, rect);
}

void CMainFrame::OnMouseMove(UINT nFlags, CPoint point)
{
    curve->OnMouseMove(point);
    Invalidate();
}

void CMainFrame::OnLButtonDown(UINT nFlags, CPoint point)
{
    curve->OnLButtonDown(point);
    Invalidate();
}

void CMainFrame::OnLButtonUp(UINT nFlags, CPoint point)
{
    curve->OnLButtonUp(point);
    Invalidate();
}

BEGIN_MESSAGE_MAP(CMainFrame, CFrameWnd)
    ON_WM_PAINT()
    ON_WM_MOUSEMOVE()
    ON_WM_LBUTTONDOWN()
    ON_WM_LBUTTONUP()
END_MESSAGE_MAP()

// 定义应用程序类
class CMyApp : public CWinApp
{
public:
    virtual BOOL InitInstance();
};

BOOL CMyApp::InitInstance()
{
    CMainFrame* frame = new CMainFrame();
    m_pMainWnd = frame;
    frame->ShowWindow(SW_SHOW);
    frame->UpdateWindow();

    return TRUE;
}

CMyApp myApp;

在这个例子中，我们使用了MFC框架，自定义了一个B-Spline Curve类，实现了插值和鼠标交互功能，并在主窗口类中调用该类的方法进行绘制和事件处理。