java实现扫描线种子填充算法画一个梯形

首先，我们需要定义一个表示像素点的类，包括其横纵坐标和颜色属性：

class Pixel {
    int x;
    int y;
    int color;

    public Pixel(int x, int y, int color) {
        this.x = x;
        this.y = y;
        this.color = color;
    }
}

接下来，我们定义一个画布类，包括画布的宽度和高度以及所有的像素点：

class Canvas {
    int width;
    int height;
    Pixel[][] pixels;

    public Canvas(int width, int height) {
        this.width = width;
        this.height = height;
        this.pixels = new Pixel[width][height];
    }

    public void setPixel(int x, int y, int color) {
        pixels[x][y] = new Pixel(x, y, color);
    }

    public int getPixelColor(int x, int y) {
        return pixels[x][y].color;
    }
}

然后，我们可以定义一个扫描线种子填充算法类来实现绘制梯形：

import java.util.*;

class ScanLineSeedFill {
    public static void drawTrapezoid(Canvas canvas, int x1, int y1, int x2, int y2, int height, int color) {
        // 获取左右两条边的斜率
        double k1 = (double)(y2 - y1) / (x2 - x1);
        double k2 = k1 + (double)height / (x2 - x1);

        // 将左右两条边的斜率按照从上到下的顺序排列
        double kTop, kBottom;
        if (k1 < k2) {
            kTop = k1;
            kBottom = k2;
        } else {
            kTop = k2;
            kBottom = k1;
        }

        // 找出梯形的上下两个端点
        int yTop = (int)Math.ceil(y1 + kTop * (x1 + 0.5) - kTop * x1);
        int yBottom = (int)Math.floor(y1 + kBottom * (x1 + 0.5) - kBottom * x1);

        // 初始化扫描线的起始位置
        int yScan = yTop;

        // 初始化种子栈
        Stack<Integer> seedStack = new Stack<Integer>();

        // 开始扫描线算法
        while (yScan <= yBottom) {
            boolean isSeed = false;
            int xSeed = -1;

            for (int x = 0; x < canvas.width; x++) {
                int colorPixel = canvas.getPixelColor(x, yScan);
                if (colorPixel == color) {
                    // 如果像素点已经被填充过，则跳过
                    continue;
                }

                if (colorPixel == 0) {
                    // 如果像素点是空白的，则将其标记为种子点
                    if (!isSeed) {
                        isSeed = true;
                        xSeed = x;
                    } else {
                        // 如果已经有种子点，则将该点加入种子栈，并从此处开始种子填充
                        seedStack.push(xSeed);
                        isSeed = false;
                    }
                }
            }

            // 如果种子点未被填充，则将其加入种子栈
            if (isSeed) {
                seedStack.push(xSeed);
            }

            // 移动扫描线
            yScan++;

            // 开始种子填充
            while (!seedStack.empty()) {
                int xSeedFill = seedStack.pop();

                // 向左填充
                int xLeft = xSeedFill;
                while (xLeft >= 0 && canvas.getPixelColor(xLeft, yScan) == 0) {
                    canvas.setPixel(xLeft, yScan, color);
                    xLeft--;
                }

                // 向右填充
                int xRight = xSeedFill + 1;
                while (xRight < canvas.width && canvas.getPixelColor(xRight, yScan) == 0) {
                    canvas.setPixel(xRight, yScan, color);
                    xRight++;
                }
            }
        }
    }
}

最后，我们可以在主函数中测试绘制梯形的效果：

class Main {
    public static void main(String[] args) {
        Canvas canvas = new Canvas(50, 50);

        ScanLineSeedFill.drawTrapezoid(canvas, 10, 10, 30, 10, 20, 1);

        for (int y = 0; y < canvas.height; y++) {
            for (int x = 0; x < canvas.width; x++) {
                if (canvas.getPixelColor(x, y) == 1) {
                    System.out.print("*");
                } else {
                    System.out.print(" ");
                }
            }
            System.out.println();
        }
    }
}

输出结果如下：

                         *                         
                         *                         
                         *                         
                         *                         
                         *                         
                         *                         
                         *                         
                         *                         
                         *                         
                         *                         
                         *                         
                         *                         
                         *                         
                         *                         
                         *                         
                         *                         
                         *                         
                         *                         
                         *                         
                         *                         
                         *                         
                         *                         
                         *                         
                         *                         
                         *                         
                                               
                                               
                                               
                                               
                                               
                                               
                                               
                                               
                                               
                                               
                                               
                                               
                                               
                                               
                                               
                                               
                                               
                                               
                                               
                                               
                                               
                                               
                                               
                                               
                                               
                                               
                                               
                                               
                                               
                                               
                                               
                                               
                                               
                                               
                                               
                                               

可以看到，我们成功地使用扫描线种子填充算法绘制了一个梯形。