请用C++及glut为我写一个sutherland裁剪算法

以下是一个基于C++和glut的Sutherland-Hodgman裁剪算法的实现：

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

struct point {
    double x, y;
};

std::vector<point> polygon = {
    {100, 100},
    {200, 100},
    {200, 200},
    {100, 200}
};

std::vector<point> clip_window = {
    {150, 150},
    {250, 150},
    {250, 250},
    {150, 250}
};

point intersection(point p1, point p2, point cp1, point cp2) {
    double m1 = (p2.y - p1.y) / (p2.x - p1.x);
    double b1 = p1.y - m1 * p1.x;

    double m2 = (cp2.y - cp1.y) / (cp2.x - cp1.x);
    double b2 = cp1.y - m2 * cp1.x;

    double x = (b2 - b1) / (m1 - m2);
    double y = m1 * x + b1;

    return {x, y};
}

std::vector<point> sutherland_hodgman_clip(std::vector<point> polygon, std::vector<point> clip_window) {
    std::vector<point> output = polygon;

    for (int i = 0; i < clip_window.size(); i++) {
        point cp1 = clip_window[i];
        point cp2 = clip_window[(i + 1) % clip_window.size()];

        std::vector<point> input = output;
        output.clear();

        for (int j = 0; j < input.size(); j++) {
            point p1 = input[j];
            point p2 = input[(j + 1) % input.size()];

            double d1 = (p1.x - cp1.x) * (cp2.y - cp1.y) - (cp2.x - cp1.x) * (p1.y - cp1.y);
            double d2 = (p2.x - cp1.x) * (cp2.y - cp1.y) - (cp2.x - cp1.x) * (p2.y - cp1.y);

            if (d1 >= 0 && d2 >= 0) {
                output.push_back(p2);
            } else if (d1 >= 0 && d2 < 0) {
                output.push_back(intersection(p1, p2, cp1, cp2));
            } else if (d1 < 0 && d2 >= 0) {
                output.push_back(intersection(p1, p2, cp1, cp2));
                output.push_back(p2);
            }
        }
    }

    return output;
}

void display() {
    glClear(GL_COLOR_BUFFER_BIT);
    glColor3f(1.0, 1.0, 1.0);

    // 绘制多边形
    glBegin(GL_LINE_LOOP);
    for (auto p : polygon) {
        glVertex2f(p.x, p.y);
    }
    glEnd();

    // 绘制裁剪窗口
    glBegin(GL_LINE_LOOP);
    for (auto p : clip_window) {
        glVertex2f(p.x, p.y);
    }
    glEnd();

    // 绘制裁剪后的多边形
    glColor3f(1.0, 0.0, 0.0);
    glBegin(GL_LINE_LOOP);
    for (auto p : sutherland_hodgman_clip(polygon, clip_window)) {
        glVertex2f(p.x, p.y);
    }
    glEnd();

    glFlush();
}

void init() {
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluOrtho2D(0.0, 400.0, 0.0, 400.0);
    glMatrixMode(GL_MODELVIEW);
}

int main(int argc, char** argv) {
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
    glutInitWindowSize(400, 400);
    glutInitWindowPosition(100, 100);
    glutCreateWindow("Sutherland-Hodgman Clipping Algorithm");
    init();
    glutDisplayFunc(display);
    glutMainLoop();
    return 0;
}

在这个实现中，我们定义了一个多边形和一个裁剪窗口，并使用`std::vector`存储它们的顶点。我们也定义了一个`point`结构体来表示二维坐标点，并实现了一个`intersection`函数来计算两条线段的交点。

在`display`函数中，我们首先绘制多边形和裁剪窗口。然后，我们使用`sutherland_hodgman_clip`函数对多边形进行裁剪，并绘制裁剪后的多边形。

在`main`函数中，我们使用glut库进行窗口和OpenGL上下文的初始化，并指定了`display`函数作为绘图回调函数。

该实现的输出如下所示：