四连通边界填充算法流程

四连通边界填充算法流程主要包括以下步骤：

1. 选择起始点，通常为图像的左上角或右上角，将其标记为已填充。
2. 检查当前点的四个相邻点是否满足填充条件（通常是与开始点颜色相同且未被填充），如果满足则将其标记为已填充，并将其加入待填充点集合中。
3. 从待填充点集合中取出下一个点，重复步骤2直到所有可填充点都已被填充或不符合填充条件。

通过这个算法，可以很轻松地实现基于四连通区域的填充功能。

相关问题

vs使用freeglut编程实现四连通边界填算法及泛滥填充算法

首先，你需要在 Visual Studio 中安装 FreeGLUT 库。可以在官网下载对应版本的库，并按照官方指南进行安装。

接下来，你可以创建一个空的 C++ 项目，并在项目属性中添加 FreeGLUT 库的链接。具体步骤如下：

1. 右键点击项目，选择“属性”。
2. 在左侧面板中选择“VC++ 目录”。
3. 在“包含目录”中添加 FreeGLUT 的 include 文件夹路径。
4. 在“库目录”中添加 FreeGLUT 的 lib 文件夹路径。
5. 在“链接器 -> 输入 -> 附加依赖项”中添加 FreeGLUT 的 lib 文件名（例如：freeglut.lib）。

完成上述步骤后，你可以开始编写四连通边界填算法和泛滥填充算法的代码。以下是一个简单的示例：

#include <GL/freeglut.h>

void drawPixel(int x, int y) {
    glBegin(GL_POINTS);
    glVertex2i(x, y);
    glEnd();
}

void boundaryFill4(int x, int y, float* fillColor, float* borderColor) {
    float interiorColor[3];
    glReadPixels(x, y, 1, 1, GL_RGB, GL_FLOAT, interiorColor);

    if (interiorColor[0] != borderColor[0] ||
        interiorColor[1] != borderColor[1] ||
        interiorColor[2] != borderColor[2]) {

        drawPixel(x, y);
        glFlush();

        boundaryFill4(x + 1, y, fillColor, borderColor);
        boundaryFill4(x - 1, y, fillColor, borderColor);
        boundaryFill4(x, y + 1, fillColor, borderColor);
        boundaryFill4(x, y - 1, fillColor, borderColor);
    }
}

void floodFill(int x, int y, float* fillColor, float* borderColor) {
    float interiorColor[3];
    glReadPixels(x, y, 1, 1, GL_RGB, GL_FLOAT, interiorColor);

    if (interiorColor[0] != borderColor[0] ||
        interiorColor[1] != borderColor[1] ||
        interiorColor[2] != borderColor[2]) {

        drawPixel(x, y);
        glFlush();

        floodFill(x + 1, y, fillColor, borderColor);
        floodFill(x - 1, y, fillColor, borderColor);
        floodFill(x, y + 1, fillColor, borderColor);
        floodFill(x, y - 1, fillColor, borderColor);
    }
}

void display() {
    float fillColor[] = { 1.0, 1.0, 0.0 };
    float borderColor[] = { 0.0, 0.0, 0.0 };

    glClearColor(1.0, 1.0, 1.0, 1.0);
    glClear(GL_COLOR_BUFFER_BIT);

    glColor3f(0.0, 0.0, 0.0);
    glBegin(GL_LINE_LOOP);
    glVertex2i(100, 100);
    glVertex2i(200, 100);
    glVertex2i(200, 200);
    glVertex2i(100, 200);
    glEnd();

    boundaryFill4(150, 150, fillColor, borderColor);
    //floodFill(150, 150, fillColor, borderColor);

    glFlush();
}

int main(int argc, char** argv) {
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
    glutInitWindowSize(400, 400);
    glutCreateWindow("Boundary Fill and Flood Fill Algorithms");
    gluOrtho2D(0, 400, 0, 400);
    glutDisplayFunc(display);
    glutMainLoop();
    return 0;
}

该示例中包含了两个函数：`boundaryFill4` 和 `floodFill`，它们分别实现了四连通边界填算法和泛滥填充算法。在 `display` 函数中，我们先画了一个矩形，并在其中心点处调用了这两个函数。

注意，该示例中只实现了单色填充。如果你需要用不同的颜色填充不同区域，可以在 `drawPixel` 函数中添加更多参数，并在 `boundaryFill4` 和 `floodFill` 函数中进行判断和处理。

vs使用freeglut编程实现四连通边界填算法

下面是使用 freeglut 库实现四连通边界填充算法的示例代码：

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

// 定义颜色
#define BLACK 0
#define WHITE 1
#define RED 2
#define GREEN 3
#define BLUE 4
#define YELLOW 5

// 定义窗口大小和像素大小
#define WIDTH 400
#define HEIGHT 400
#define PIXEL_SIZE 5

int pixels[WIDTH/PIXEL_SIZE][HEIGHT/PIXEL_SIZE]; // 存储像素的数组

// 初始化像素数组为白色
void initPixels() {
    for (int i = 0; i < WIDTH/PIXEL_SIZE; i++) {
        for (int j = 0; j < HEIGHT/PIXEL_SIZE; j++) {
            pixels[i][j] = WHITE;
        }
    }
}

// 绘制单个像素
void drawPixel(int x, int y) {
    int color = pixels[x/PIXEL_SIZE][y/PIXEL_SIZE];
    switch (color) {
        case BLACK:
            glColor3f(0.0f, 0.0f, 0.0f);
            break;
        case WHITE:
            glColor3f(1.0f, 1.0f, 1.0f);
            break;
        case RED:
            glColor3f(1.0f, 0.0f, 0.0f);
            break;
        case GREEN:
            glColor3f(0.0f, 1.0f, 0.0f);
            break;
        case BLUE:
            glColor3f(0.0f, 0.0f, 1.0f);
            break;
        case YELLOW:
            glColor3f(1.0f, 1.0f, 0.0f);
            break;
    }
    glBegin(GL_QUADS);
        glVertex2i(x, y);
        glVertex2i(x+PIXEL_SIZE, y);
        glVertex2i(x+PIXEL_SIZE, y+PIXEL_SIZE);
        glVertex2i(x, y+PIXEL_SIZE);
    glEnd();
}

// 绘制所有像素
void drawPixels() {
    for (int i = 0; i < WIDTH; i += PIXEL_SIZE) {
        for (int j = 0; j < HEIGHT; j += PIXEL_SIZE) {
            drawPixel(i, j);
        }
    }
}

// 判断是否为边界像素
bool isBoundary(int x, int y) {
    if (x == 0 || y == 0 || x == WIDTH-PIXEL_SIZE || y == HEIGHT-PIXEL_SIZE) {
        return true;
    }
    int left = pixels[(x-PIXEL_SIZE)/PIXEL_SIZE][y/PIXEL_SIZE];
    int right = pixels[(x+PIXEL_SIZE)/PIXEL_SIZE][y/PIXEL_SIZE];
    int up = pixels[x/PIXEL_SIZE][(y-PIXEL_SIZE)/PIXEL_SIZE];
    int down = pixels[x/PIXEL_SIZE][(y+PIXEL_SIZE)/PIXEL_SIZE];
    if (left == WHITE || right == WHITE || up == WHITE || down == WHITE) {
        return true;
    }
    return false;
}

// 四连通边界填充算法
void boundaryFill(int x, int y, int fill_color, int boundary_color) {
    int color = pixels[x/PIXEL_SIZE][y/PIXEL_SIZE];
    if (color != boundary_color && color != fill_color) {
        pixels[x/PIXEL_SIZE][y/PIXEL_SIZE] = fill_color;
        drawPixel(x, y);
        if (!isBoundary(x-PIXEL_SIZE, y)) {
            boundaryFill(x-PIXEL_SIZE, y, fill_color, boundary_color);
        }
        if (!isBoundary(x+PIXEL_SIZE, y)) {
            boundaryFill(x+PIXEL_SIZE, y, fill_color, boundary_color);
        }
        if (!isBoundary(x, y-PIXEL_SIZE)) {
            boundaryFill(x, y-PIXEL_SIZE, fill_color, boundary_color);
        }
        if (!isBoundary(x, y+PIXEL_SIZE)) {
            boundaryFill(x, y+PIXEL_SIZE, fill_color, boundary_color);
        }
    }
}

// 鼠标点击事件回调函数
void onMouseClick(int button, int state, int x, int y) {
    if (button == GLUT_LEFT_BUTTON && state == GLUT_DOWN) {
        boundaryFill(x, HEIGHT-y, YELLOW, BLACK);
        glFlush();
    }
}

// 显示回调函数
void display() {
    glClear(GL_COLOR_BUFFER_BIT);
    drawPixels();
    glFlush();
}

int main(int argc, char *argv[]) {
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
    glutInitWindowSize(WIDTH, HEIGHT);
    glutCreateWindow("Boundary Fill");
    glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
    initPixels();
    glutDisplayFunc(display);
    glutMouseFunc(onMouseClick);
    glutMainLoop();
    return 0;
}

在这个示例代码中，首先定义了一些常量，包括窗口大小、像素大小和颜色。然后定义了一个二维数组 `pixels`，用于存储每个像素的颜色。在 `initPixels()` 函数中，将所有像素初始化为白色。`drawPixel()` 函数用于绘制单个像素，根据像素的颜色使用不同的颜色绘制矩形。`drawPixels()` 函数则用于绘制所有像素。`isBoundary()` 函数判断一个像素是否为边界像素，如果是则返回 true，否则返回 false。`boundaryFill()` 函数实现了四连通边界填充算法，使用递归的方式对周围像素进行填充。最后，在 `onMouseClick()` 函数中，当鼠标左键点击时，对点击位置进行填充。

在 `main()` 函数中，使用 freeglut 库初始化窗口，并注册显示回调函数、鼠标点击事件回调函数，然后进入主循环。当鼠标点击时，调用 `onMouseClick()` 函数进行填充。在显示回调函数中，使用 `drawPixels()` 函数绘制所有像素。