种子填充算法的opengl实现代码

以下是一个基于 OpenGL 的种子填充算法实现代码：

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

const int WIDTH = 600;
const int HEIGHT = 400;

void init() {
    glClearColor(0.0, 0.0, 0.0, 0.0);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluOrtho2D(0.0, WIDTH, 0.0, HEIGHT);
    glMatrixMode(GL_MODELVIEW);
}

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

    // 选择一个种子点
    int seedX = 300;
    int seedY = 200;

    // 开始填充
    glPointSize(1.0);
    glBegin(GL_POINTS);
    glColor3f(1.0, 0.0, 0.0);
    glVertex2i(seedX, seedY);
    glEnd();

    glFlush();

    // 记录已经填充的点
    bool filled[WIDTH][HEIGHT] = { false };

    // 添加种子点到队列
    int queue[WIDTH * HEIGHT][2];
    int queueStart = 0;
    int queueEnd = 0;
    queue[queueEnd][0] = seedX;
    queue[queueEnd][1] = seedY;
    queueEnd++;

    // 开始种子填充算法
    while (queueStart != queueEnd) {
        // 取出队列头部的点
        int x = queue[queueStart][0];
        int y = queue[queueStart][1];
        queueStart++;

        // 向上填充
        int upX = x;
        int upY = y + 1;
        if (upY < HEIGHT && !filled[upX][upY]) {
            filled[upX][upY] = true;
            glBegin(GL_POINTS);
            glVertex2i(upX, upY);
            glEnd();
            queue[queueEnd][0] = upX;
            queue[queueEnd][1] = upY;
            queueEnd++;
        }

        // 向下填充
        int downX = x;
        int downY = y - 1;
        if (downY >= 0 && !filled[downX][downY]) {
            filled[downX][downY] = true;
            glBegin(GL_POINTS);
            glVertex2i(downX, downY);
            glEnd();
            queue[queueEnd][0] = downX;
            queue[queueEnd][1] = downY;
            queueEnd++;
        }

        // 向左填充
        int leftX = x - 1;
        int leftY = y;
        if (leftX >= 0 && !filled[leftX][leftY]) {
            filled[leftX][leftY] = true;
            glBegin(GL_POINTS);
            glVertex2i(leftX, leftY);
            glEnd();
            queue[queueEnd][0] = leftX;
            queue[queueEnd][1] = leftY;
            queueEnd++;
        }

        // 向右填充
        int rightX = x + 1;
        int rightY = y;
        if (rightX < WIDTH && !filled[rightX][rightY]) {
            filled[rightX][rightY] = true;
            glBegin(GL_POINTS);
            glVertex2i(rightX, rightY);
            glEnd();
            queue[queueEnd][0] = rightX;
            queue[queueEnd][1] = rightY;
            queueEnd++;
        }

        glFlush();
    }
}

int main(int argc, char** argv) {
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
    glutInitWindowSize(WIDTH, HEIGHT);
    glutInitWindowPosition(100, 100);
    glutCreateWindow("Seed Fill Algorithm");
    init();
    glutDisplayFunc(display);
    glutMainLoop();
    return 0;
}

在这个实现中，我们首先选择了一个种子点，然后在 OpenGL 中将其绘制出来。接着，我们使用一个二维布尔数组 `filled` 来记录哪些点已经被填充了。我们使用一个队列来保存待填充的点，初始时只有种子点在队列中。在每次循环中，我们从队列头部取出一个点，向上下左右四个方向检查是否需要填充，如果需要填充，就在 OpenGL 中绘制该点，并将其加入队列。我们不断重复这个过程，直到队列为空，即所有需要填充的点都已经填充完毕。