vs实现b样条曲面,要求用不同颜色显 示曲面和曲面的控制网格,并且可以取消曲面控制网格的显示,允 许交互式地改变控制网格的定点位置,以观看曲面形状的改变;能 够通过对话框、菜单等方式设置曲面的配置参数（书写代码

实现B样条曲面需要使用OpenGL图形库和GLUT工具包。以下是一个简单的实现代码，其中包括了控制点的交互式修改、曲面的显示和控制网格的显示/隐藏等功能。

#include <GL/glut.h>
#include <vector>

// 控制点结构体
struct Point {
    float x, y, z;
};

// B样条曲面的控制点
std::vector<Point> controlPoints = {
    {-1, -1, 0}, {-1, 0, 1}, {-1, 1, 0},
    {0, -1, -1}, {0, 0, 2}, {0, 1, -1},
    {1, -1, 0}, {1, 0, 1}, {1, 1, 0}
};

// B样条曲面的阶数
const int degree = 3;

// B样条曲面的参数范围
const float uMin = 0, uMax = 1, vMin = 0, vMax = 1;

// 控制网格的颜色
const float gridColor[] = {0.5, 0.5, 0.5};

// 曲面的颜色
const float surfaceColor[] = {1, 0, 0};

// 控制网格是否可见
bool showGrid = true;

// 计算B样条基函数
float basis(int i, int k, float t, const std::vector<float>& knots) {
    if (k == 0) {
        if (t >= knots[i] && t < knots[i+1]) {
            return 1;
        } else {
            return 0;
        }
    } else {
        float w1 = 0, w2 = 0;
        if (knots[i+k] != knots[i]) {
            w1 = (t - knots[i]) / (knots[i+k] - knots[i]) * basis(i, k-1, t, knots);
        }
        if (knots[i+k+1] != knots[i+1]) {
            w2 = (knots[i+k+1] - t) / (knots[i+k+1] - knots[i+1]) * basis(i+1, k-1, t, knots);
        }
        return w1 + w2;
    }
}

// 计算B样条曲面上的点
Point eval(float u, float v, const std::vector<Point>& points,
           const std::vector<float>& uknots, const std::vector<float>& vknots) {
    Point p = {0, 0, 0};
    int n = points.size() - 1;
    int m = n + degree + 1;
    for (int i = 0; i <= n; i++) {
        for (int j = 0; j <= n; j++) {
            float bu = basis(i, degree, u, uknots);
            float bv = basis(j, degree, v, vknots);
            float w = bu * bv;
            p.x += points[i*(n+1)+j].x * w;
            p.y += points[i*(n+1)+j].y * w;
            p.z += points[i*(n+1)+j].z * w;
        }
    }
    return p;
}

// 显示B样条曲面和控制网格
void display() {
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    // 设置投影矩阵和模型视图矩阵
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluPerspective(45, 1, 1, 10);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    gluLookAt(0, 0, 5, 0, 0, 0, 0, 1, 0);

    // 绘制曲面
    glColor3fv(surfaceColor);
    glBegin(GL_QUADS);
    int n = controlPoints.size() - 1;
    std::vector<float> uknots(n+degree+2);
    std::vector<float> vknots(n+degree+2);
    for (int i = 0; i < uknots.size(); i++) {
        uknots[i] = uMin + (uMax - uMin) * i / (uknots.size() - 1);
        vknots[i] = vMin + (vMax - vMin) * i / (vknots.size() - 1);
    }
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            Point p1 = eval(uknots[i+degree], vknots[j+degree], controlPoints, uknots, vknots);
            Point p2 = eval(uknots[i+degree+1], vknots[j+degree], controlPoints, uknots, vknots);
            Point p3 = eval(uknots[i+degree+1], vknots[j+degree+1], controlPoints, uknots, vknots);
            Point p4 = eval(uknots[i+degree], vknots[j+degree+1], controlPoints, uknots, vknots);
            glVertex3f(p1.x, p1.y, p1.z);
            glVertex3f(p2.x, p2.y, p2.z);
            glVertex3f(p3.x, p3.y, p3.z);
            glVertex3f(p4.x, p4.y, p4.z);
        }
    }
    glEnd();

    // 绘制控制网格
    if (showGrid) {
        glColor3fv(gridColor);
        glLineWidth(1);
        glBegin(GL_LINES);
        for (int i = 0; i <= n; i++) {
            for (int j = 0; j <= n; j++) {
                glVertex3f(controlPoints[i*(n+1)+j].x, controlPoints[i*(n+1)+j].y, controlPoints[i*(n+1)+j].z);
                if (i < n) {
                    glVertex3f(controlPoints[(i+1)*(n+1)+j].x, controlPoints[(i+1)*(n+1)+j].y, controlPoints[(i+1)*(n+1)+j].z);
                }
                if (j < n) {
                    glVertex3f(controlPoints[i*(n+1)+j+1].x, controlPoints[i*(n+1)+j+1].y, controlPoints[i*(n+1)+j+1].z);
                }
            }
        }
        glEnd();
    }

    glutSwapBuffers();
}

// 处理鼠标事件
void mouse(int button, int state, int x, int y) {
    if (button == GLUT_LEFT_BUTTON && state == GLUT_DOWN) {
        // 将鼠标坐标从窗口坐标系转换为OpenGL坐标系
        int viewport[4];
        glGetIntegerv(GL_VIEWPORT, viewport);
        float winX = x, winY = viewport[3] - y;
        float winZ;
        glReadPixels(x, (int)winY, 1, 1, GL_DEPTH_COMPONENT, GL_FLOAT, &winZ);
        double objX, objY, objZ;
        gluUnProject(winX, winY, winZ, GL_MODELVIEW_MATRIX, GL_PROJECTION_MATRIX, viewport, &objX, &objY, &objZ);

        // 查找最近的控制点
        int n = controlPoints.size() - 1;
        int nearest = -1;
        float minDist = FLT_MAX;
        for (int i = 0; i <= n; i++) {
            for (int j = 0; j <= n; j++) {
                float dist = sqrt(pow(controlPoints[i*(n+1)+j].x - objX, 2)
                                + pow(controlPoints[i*(n+1)+j].y - objY, 2)
                                + pow(controlPoints[i*(n+1)+j].z - objZ, 2));
                if (dist < minDist) {
                    minDist = dist;
                    nearest = i*(n+1)+j;
                }
            }
        }

        // 如果距离最近的控制点足够近，则将其作为当前控制点
        if (minDist < 0.1) {
            glutSetCursor(GLUT_CURSOR_CROSSHAIR);
            glutMotionFunc([](int x, int y) {
                // 将鼠标坐标从窗口坐标系转换为OpenGL坐标系
                int viewport[4];
                glGetIntegerv(GL_VIEWPORT, viewport);
                float winX = x, winY = viewport[3] - y;
                float winZ;
                glReadPixels(x, (int)winY, 1, 1, GL_DEPTH_COMPONENT, GL_FLOAT, &winZ);
                double objX, objY, objZ;
                gluUnProject(winX, winY, winZ, GL_MODELVIEW_MATRIX, GL_PROJECTION_MATRIX, viewport, &objX, &objY, &objZ);

                // 更新控制点位置
                controlPoints[nearest].x = objX;
                controlPoints[nearest].y = objY;
                controlPoints[nearest].z = objZ;

                glutPostRedisplay();
            });
        }
    } else if (button == GLUT_LEFT_BUTTON && state == GLUT_UP) {
        glutSetCursor(GLUT_CURSOR_LEFT_ARROW);
        glutMotionFunc(nullptr);
    }
}

// 处理菜单事件
void menu(int value) {
    switch (value) {
    case 1:
        showGrid = !showGrid;
        break;
    }
    glutPostRedisplay();
}

int main(int argc, char** argv) {
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH);
    glutInitWindowSize(600, 600);
    glutCreateWindow("B-spline Surface");
    glutDisplayFunc(display);
    glutMouseFunc(mouse);

    // 创建菜单
    glutCreateMenu(menu);
    glutAddMenuEntry("Show/Hide Grid", 1);
    glutAttachMenu(GLUT_RIGHT_BUTTON);

    glEnable(GL_DEPTH_TEST);

    glutMainLoop();

    return 0;
}

在该程序中，B样条曲面的控制点保存在`controlPoints`数组中，可以通过鼠标交互式地修改它们的位置。曲面的阶数保存在`degree`变量中，参数范围保存在`uMin`、`uMax`、`vMin`和`vMax`变量中。

在`display`函数中，首先计算出B样条曲面上的所有点，然后使用OpenGL的`glBegin`和`glVertex`函数绘制出曲面。如果需要显示控制网格，则使用`glBegin`和`glVertex`函数绘制出所有控制点之间的连线。

在`mouse`函数中，处理鼠标事件并根据最近的控制点更新`controlPoints`数组。如果鼠标位置距离最近的控制点足够近，则将其作为当前控制点，并将鼠标形状改为十字架。在鼠标拖动时，更新当前控制点的位置，并调用`glutPostRedisplay`函数触发重绘操作。当鼠标释放时，将鼠标形状改回箭头。

在`menu`函数中，处理菜单事件。当用户选择“Show/Hide Grid”菜单项时，将`showGrid`变量取反，并调用`glutPostRedisplay`函数触发重绘操作。

最后，在`main`函数中，初始化OpenGL和GLUT，并创建菜单。调用`glutMainLoop`函数进入主循环，等待用户事件的发生。