写一份关于扫描线填充算法和种子填充算法实验的实验小结

扫描线填充算法和种子填充算法是计算机图形学中常用的两种填充算法。它们可以用于对封闭图形进行填充，实现图形的着色和渲染。下面是这两种算法的实验小结：

1.扫描线填充算法

扫描线填充算法是一种基于扫描线的填充算法，其基本思想是将图形分解为多个扫描线，并逐条扫描线进行处理。该算法的具体步骤如下：

（1）确定扫描线的起点和终点，即确定扫描线的区间。

（2）在每个扫描线上，找出所有与扫描线相交的线段，并将其排序。

（3）依次处理每个相交线段，对其进行填充。

（4）重复步骤（1）至（3），直到所有扫描线都被处理。

扫描线填充算法的优点是能够高效地处理复杂的凸多边形，但是对于凹多边形和复杂的曲线填充效果不佳。

2.种子填充算法

种子填充算法是一种基于区域种子的填充算法，其基本思想是从某一点开始，将该点所在的区域内的所有像素点都填充上同一种颜色。该算法的具体步骤如下：

（1）选择一个起始点，即种子点。

（2）将种子点所在的像素点填充上指定颜色。

（3）对于种子点相邻的像素点，如果其颜色与种子点的颜色相同且未被填充，则将其填充上相同的颜色，并将其加入种子点列表。

（4）重复步骤（3）直到种子点列表为空。

种子填充算法的优点是适用于各种图形，填充效果好，但是可能会遇到内存溢出的问题。

总的来说，扫描线填充算法和种子填充算法各有优点和缺点，在实际应用中应根据具体情况选择合适的算法。

相关问题

帮我用C++写一个扫描线填充算法和种子填充算法，并给我注释

好的，下面给您提供 C++ 的代码实现，其中包含扫描线填充算法和种子填充算法的实现，并且带有注释说明。

#include <iostream>
#include <graphics.h>
#include <stack>
using namespace std;

// 扫描线填充算法
void scanLineFill(int x[], int y[], int n, int color) {
    // 找到最上面的顶点
    int minY = y[0];
    for (int i = 1; i < n; i++) {
        if (y[i] < minY) {
            minY = y[i];
        }
    }

    // 找到最下面的顶点
    int maxY = y[0];
    for (int i = 1; i < n; i++) {
        if (y[i] > maxY) {
            maxY = y[i];
        }
    }

    // 扫描线算法填充
    for (int i = minY; i <= maxY; i++) {
        stack<int> s;

        // 求交点
        for (int j = 0; j < n; j++) {
            int k = (j + 1) % n;
            if ((y[j] <= i && y[k] > i) || (y[k] <= i && y[j] > i)) {
                int x0 = x[j] + (i - y[j]) * (x[k] - x[j]) / (y[k] - y[j]);
                s.push(x0);
            }
        }

        // 排序
        while (!s.empty()) {
            int x1 = s.top();
            s.pop();
            int x2 = s.top();
            s.pop();
            if (x1 > x2) {
                swap(x1, x2);
            }
            setcolor(color);
            line(x1, i, x2, i);
        }
    }
}

// 种子填充算法
void seedFill(int x, int y, int fillColor, int oldColor) {
    if (getpixel(x, y) == oldColor) {
        putpixel(x, y, fillColor);
        seedFill(x + 1, y, fillColor, oldColor);
        seedFill(x - 1, y, fillColor, oldColor);
        seedFill(x, y + 1, fillColor, oldColor);
        seedFill(x, y - 1, fillColor, oldColor);
    }
}

int main() {
    initgraph(640, 480);

    // 绘制多边形
    int x[] = { 200, 300, 400, 300 };
    int y[] = { 100, 200, 100, 50 };
    int n = 4;
    setcolor(GREEN);
    fillpoly(n, x, y);
    setcolor(RED);
    drawpoly(n, x, y);

    // 扫描线填充
    scanLineFill(x, y, n, YELLOW);

    // 种子填充
    seedFill(250, 150, CYAN, BLACK);

    getch();
    closegraph();
    return 0;
}

代码中，`scanLineFill` 函数实现了扫描线填充算法，其原理是扫描每一行的像素点，找到多边形与该行的交点，然后进行排序，填充颜色。`seedFill` 函数实现了种子填充算法，其原理是从种子点开始，递归地向四个方向扩散，直到与原始颜色不同的颜色边界。

在代码中，我们绘制了一个多边形，并使用扫描线填充算法和种子填充算法对其进行了填充。您可以根据需要自行修改代码实现。

帮我用C++写一个扫描线填充算法和种子填充算法，并给我注释，

好的，下面是扫描线填充算法和种子填充算法的C++实现：

## 扫描线填充算法

#include <iostream>
#include <graphics.h>
#include <conio.h>

using namespace std;

void scanLineFill(int x[], int y[], int n) {
    int i, j, k;
    for(i = 0; i < 480; i++) { // 从屏幕顶部开始扫描
        j = 0;
        while(j < n) {
            if((y[j] < i && y[(j+1)%n]>i) || (y[j]>i && y[(j+1)%n]<i)) { // 判断是否跨越当前扫描线
                float x_inters = (float)(x[j] + (float)(i - y[j])*(float)(x[(j+1)%n] - x[j])/(float)(y[(j+1)%n] - y[j])); // 求交点x坐标
                int inter = (int)(x_inters + 0.5); // 取整
                setcolor(2); // 绿色
                line(inter, i, inter, i); // 绘制像素点
            }
            j++;
        }
    }
}

int main() {
    int gd = DETECT, gm;
    initgraph(&gd, &gm, "");
    int x[] = {100, 200, 200, 100};
    int y[] = {100, 100, 200, 200};
    scanLineFill(x, y, 4);
    getch();
    closegraph();
    return 0;
}

扫描线填充算法是一种基于扫描线的多边形填充算法。其主要思想是用水平的扫描线从上往下扫描，找到多边形的交点，并对相邻的两个交点之间的线段进行填充。

## 种子填充算法

#include <iostream>
#include <graphics.h>
#include <conio.h>

using namespace std;

void seedFill(int x, int y, int fill_color, int border_color) {
    if(getpixel(x, y) != border_color && getpixel(x, y) != fill_color) { // 判断当前像素点是否需要填充
        putpixel(x, y, fill_color); // 填充像素点
        seedFill(x+1, y, fill_color, border_color); // 向右填充
        seedFill(x-1, y, fill_color, border_color); // 向左填充
        seedFill(x, y+1, fill_color, border_color); // 向下填充
        seedFill(x, y-1, fill_color, border_color); // 向上填充
    }
}

int main() {
    int gd = DETECT, gm;
    initgraph(&gd, &gm, "");
    rectangle(100, 100, 200, 200); // 绘制矩形
    seedFill(150, 150, 2, 0); // 从(150,150)点开始填充，填充颜色为绿色(2)，边界颜色为黑色(0)
    getch();
    closegraph();
    return 0;
}

种子填充算法是一种基于像素点的区域填充算法。其主要思想是从指定的种子点开始，对相邻的像素点进行判断，如果需要填充则填充，并递归地对其四个相邻的像素点进行判断和填充。