使用堆栈进行洪水填充

Question

我正在使用 Java 中的递归 Flood 填充算法来填充图像的某些区域。 对于非常小的图像，它可以正常工作，但是当图像变大时，JVM 会给我一个堆栈溢出错误。

这就是为什么我必须用我自己的堆栈使用 Flood Fill 重新实现该方法的原因。 （我读到这是在这种情况下最好的方法）

谁能解释一下如何编码？ （如果手头没有代码，有算法的伪代码就可以了）

我在网上看了很多，但不是很了解。

编辑：我添加了递归代码

public void floodFill(int x, int y, Color targetColor,Color replacementColor) {

    if (img.getRGB(x, y) != targetColor.getRGB()) return;

    img.setRGB(x, y, replacementColor.getRGB());
    floodFill(x - 1, y, targetColor, replacementColor);
    floodFill(x + 1, y, targetColor, replacementColor);
    floodFill(x, y - 1, targetColor, replacementColor);
    floodFill(x, y + 1, targetColor, replacementColor);

    return;

}

谢谢！

Answer 1

您可以使用 Queue 从 Floodfill 算法中移除递归。以下是一些基本的想法：

1. 有办法标记访问点
2. 开始时，将起点排队。
3. 当队列不为空时，继续将其元素出队。并且每个元素
   1. 填充其颜色并将刚刚出列的点标记为已访问
   2. 将未访问的具有相同颜色的相邻点排入队列

以下是我的 Java 代码，用于解决 blob 检测类似但不同的问题。我希望你能从中得到一些想法，并能适应它的问题。但是代码没有很好地分解。

package blobdetector;

import java.awt.Point;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.util.LinkedList;
import java.util.Queue;
import javax.imageio.ImageIO;
import javax.management.Query;

public class Main {

    public Main() {
    }

    public static boolean isBlack(BufferedImage image, int posX, int posY) {

        int color = image.getRGB(posX, posY);

        int brightness = (color & 0xFF) + ((color >> 2) & 0xFF)
        + ((color >> 4) & 0xFF);
        brightness /= 3;

        return brightness < 128;
    }

    public static void main(String[] args) {
        if (args.length != 1) {
            System.err.println("ERROR: Pass filename as argument.");
            return;
        }

        String filename = args[0];
        // String filename =
        // "C:\\Users\\Natthawut\\Desktop\\blob.jpg";
        try {
            BufferedImage bimg = ImageIO.read(new File(filename));

            boolean[][] painted = new boolean[bimg.getHeight()][bimg.getWidth()];

            for (int i = 0; i < bimg.getHeight(); i++) {
                for (int j = 0; j < bimg.getWidth(); j++) {

                    if (isBlack(bimg, j, i) && !painted[i][j]) {

                        Queue<Point> queue = new LinkedList<Point>();
                        queue.add(new Point(j, i));

                        int pixelCount = 0;
                        while (!queue.isEmpty()) {
                            Point p = queue.remove();

                            if ((p.x >= 0)
                                    && (p.x < bimg.getWidth() && (p.y >= 0) && (p.y < bimg
                                            .getHeight()))) {
                                if (!painted[p.y][p.x]
                                                  && isBlack(bimg, p.x, p.y)) {
                                    painted[p.y][p.x] = true;
                                    pixelCount++;

                                    queue.add(new Point(p.x + 1, p.y));
                                    queue.add(new Point(p.x - 1, p.y));
                                    queue.add(new Point(p.x, p.y + 1));
                                    queue.add(new Point(p.x, p.y - 1));
                                }
                            }
                        }
                        System.out.println("Blob detected : " + pixelCount
                                + " pixels");
                    }

                }
            }

        } catch (IOException ex) {
            ex.printStackTrace();
        }

    }

}

测试输入：

Answer 2

这是我基于此页面的信息和网络上收集的其他信息（经过测试和工作）的实现

玩得开心;-)

public static void floodFillImage(BufferedImage image,int x, int y, Color color) 
{
    int srcColor = image.getRGB(x, y);
    boolean[][] hits = new boolean[image.getHeight()][image.getWidth()];

    Queue<Point> queue = new LinkedList<Point>();
    queue.add(new Point(x, y));

    while (!queue.isEmpty()) 
    {
        Point p = queue.remove();

        if(floodFillImageDo(image,hits,p.x,p.y, srcColor, color.getRGB()))
        {     
            queue.add(new Point(p.x,p.y - 1)); 
            queue.add(new Point(p.x,p.y + 1)); 
            queue.add(new Point(p.x - 1,p.y)); 
            queue.add(new Point(p.x + 1,p.y)); 
        }
    }
}

private static boolean floodFillImageDo(BufferedImage image, boolean[][] hits,int x, int y, int srcColor, int tgtColor) 
{
    if (y < 0) return false;
    if (x < 0) return false;
    if (y > image.getHeight()-1) return false;
    if (x > image.getWidth()-1) return false;

    if (hits[y][x]) return false;

    if (image.getRGB(x, y)!=srcColor)
        return false;

    // valid, paint it

    image.setRGB(x, y, tgtColor);
    hits[y][x] = true;
    return true;
}

Answer 3

你应该返回最后一个 floodFill 语句，把它变成一个尾调用。这将节省您的堆栈空间。

Answer 4

洪水填充中的一个重要点是您是在处理点深度优先还是广度优先。深度优先是您使用堆栈查看的原始解决方案，广度优先是下面显示的使用队列存储点的算法。填充大的凸空间时差异很大。广度优先方法存储在大致圆形边缘（或填充边缘）的完美凸区域上。如果您使用深度优先方法，则在最坏的情况下，您可能会将每个像素存储在 conxex 区域中，这意味着在最坏的情况下，填充的 1000x1000 图像泛洪可能需要 1000000 个堆栈帧。