Java 8 + Swing：如何绘制填充多边形

Question

抱歉内容有些长...但至少有图片吧?

我编写了一个算法，通过统计生成N个凸多边形来创建一幅马赛克图像，这些多边形覆盖整个图像且不重叠。这些多边形的边数在3-8之间，每条边的角度都是45度的倍数。这些多边形在内部被存储为矩形，并记录每个角落的位移。下面是一张图片，解释了这个算法的工作原理:

getRight()返回x + width - 1，getBottom()返回y + height - 1。该类旨在维护填充像素周围的紧密边界框，因此图像中显示的坐标是正确的。请注意，width >= ul + ur + 1，width >= ll + lr + 1，height >= ul + ll + 1，height >= ur + ul + 1，否则将在一侧出现空像素。还要注意，角落的位移可能为0，从而指示该角落中的所有像素都已填充。这使得该表示可以存储3-8边凸多边形，每个边至少有一个像素的长度。

虽然将这些区域进行数学表示很好，但我想绘制它们以便能够看到它们。使用一个简单的lambda和一种迭代每个多边形像素的方法，我可以完美地渲染图像。例如，下面是使用99个允许所有分裂方向的多边形绘制的克洛德·莫奈的戴遮阳伞的女人。

渲染此图像的代码如下：

public void drawOnto(Graphics graphics) {
    graphics.setColor(getColor());
    forEach(
        (i, j) -> {
            graphics.fillRect(x + i, y + j, 1, 1);
        }
    );
}

private void forEach(PerPixel algorithm) {
    for (int j = 0; j < height; ++j) {
        int nj = height - 1 - j;

        int minX;
        if (j < ul) {
            minX = ul - j;
        } else if (nj < ll) {
            minX = ll - nj;
        } else {
            minX = 0;
        }

        int maxX = width;
        if (j < ur) {
            maxX -= ur - j;
        } else if (nj < lr) {
            maxX -= lr - nj;
        }

        for (int i = minX; i < maxX; ++i) {
            algorithm.perform(i, j);
        }
    }
}

然而，出于许多原因，这并不是理想的。首先，图形化表示多边形的概念现在已经成为类本身的一部分；最好允许其他专注于表示这些多边形的类存在。其次，这需要许多、许多次调用fillRect()来绘制单个像素。最后，我希望能够开发其他渲染这些多边形的方法，而不是直接绘制它们（例如，在由多边形中心表示的Voronoi图上执行加权插值）。

所有这些都指向生成一个代表多边形顶点的java.awt.Polygon（我将其命名为Region以区分于Polygon类）。没问题；我编写了一个方法来生成一个Polygon，它具有上面的角落，并且没有重复，以处理位移为0或一侧只有一个像素的情况：

public Polygon getPolygon() {
    int[] xes = {
        x + ul,
        getRight() - ur,
        getRight(),
        getRight(),
        getRight() - lr,
        x + ll,
        x,
        x
    };
    int[] yes = {
        y,
        y,
        y + ur,
        getBottom() - lr,
        getBottom(),
        getBottom(),
        getBottom() - ll,
        y + ul
    };

    int[] keptXes = new int[8];
    int[] keptYes = new int[8];
    int length = 0;
    for (int i = 0; i < 8; ++i) {
        if (
            length == 0 ||
            keptXes[length - 1] != xes[i] ||
            keptYes[length - 1] != yes[i]
        ) {
            keptXes[length] = xes[i];
            keptYes[length] = yes[i];
            length++;
        }
    }

    return new Polygon(keptXes, keptYes, length);
}

问题在于，当我尝试使用Polygon和Graphics.fillPolygon()方法时，它没有填充所有的像素！下面是使用这种不同方法呈现的相同马赛克：

所以我有几个关于这种行为的相关问题：

1. 为什么Polygon类没有填充所有这些像素，即使角度是45度的简单倍数？

2. 如何在我的渲染器中一贯地编写代码以解决这个缺陷（就我的应用程序而言），以便我可以使用我的getPolygon()方法？我不想改变它输出的顶点，因为我需要它们精确进行重心计算。

---

MCE

如果上面的代码片段和图片无法充分解释问题，我已经添加了一个最小、完整和可验证的示例，演示了我所描述的行为。

package com.sadakatsu.mce;

import java.awt.Color;
import java.awt.Graphics;
import java.awt.Polygon;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;

import javax.imageio.ImageIO;

public class Main {
    @FunctionalInterface
    private static interface PerPixel {
        void perform(int x, int y);
    }

    private static class Region {
        private int height;
        private int ll;
        private int lr;
        private int width;
        private int ul;
        private int ur;
        private int x;
        private int y;

        public Region(
            int x,
            int y,
            int width,
            int height,
            int ul,
            int ur,
            int ll,
            int lr
        ) {
            if (
                width < 0 || width <= ll + lr || width <= ul + ur ||
                height < 0 || height <= ul + ll || height <= ur + lr ||
                ul < 0 ||
                ur < 0 ||
                ll < 0 ||
                lr < 0
            ) {
                throw new IllegalArgumentException();
            }

            this.height = height;
            this.ll = ll;
            this.lr = lr;
            this.width = width;
            this.ul = ul;
            this.ur = ur;
            this.x = x;
            this.y = y;
        }

        public Color getColor() {
            return Color.BLACK;
        }

        public int getBottom() {
            return y + height - 1;
        }

        public int getRight() {
            return x + width - 1;
        }

        public Polygon getPolygon() {
            int[] xes = {
                x + ul,
                getRight() - ur,
                getRight(),
                getRight(),
                getRight() - lr,
                x + ll,
                x,
                x
            };
            int[] yes = {
                y,
                y,
                y + ur,
                getBottom() - lr,
                getBottom(),
                getBottom(),
                getBottom() - ll,
                y + ul
            };

            int[] keptXes = new int[8];
            int[] keptYes = new int[8];
            int length = 0;
            for (int i = 0; i < 8; ++i) {
                if (
                    length == 0 ||
                    keptXes[length - 1] != xes[i] ||
                    keptYes[length - 1] != yes[i]
                ) {
                    keptXes[length] = xes[i];
                    keptYes[length] = yes[i];
                    length++;
                }
            }

            return new Polygon(keptXes, keptYes, length);
        }

        public void drawOnto(Graphics graphics) {
            graphics.setColor(getColor());
            forEach(
                (i, j) -> {
                    graphics.fillRect(x + i, y + j, 1, 1);
                }
            );
        }

        private void forEach(PerPixel algorithm) {
            for (int j = 0; j < height; ++j) {
                int nj = height - 1 - j;

                int minX;
                if (j < ul) {
                    minX = ul - j;
                } else if (nj < ll) {
                    minX = ll - nj;
                } else {
                    minX = 0;
                }

                int maxX = width;
                if (j < ur) {
                    maxX -= ur - j;
                } else if (nj < lr) {
                    maxX -= lr - nj;
                }

                for (int i = minX; i < maxX; ++i) {
                    algorithm.perform(i, j);
                }
            }
        }
    }

    public static void main(String[] args) throws IOException {
        int width = 10;
        int height = 8;

        Region region = new Region(0, 0, 10, 8, 2, 3, 4, 1);

        BufferedImage image = new BufferedImage(
            width,
            height,
            BufferedImage.TYPE_3BYTE_BGR
        );
        Graphics graphics = image.getGraphics();
        graphics.setColor(Color.WHITE);
        graphics.fillRect(0, 0, width, height);
        region.drawOnto(graphics);
        ImageIO.write(image, "PNG", new File("expected.png"));

        image = new BufferedImage(
            width,
            height,
            BufferedImage.TYPE_3BYTE_BGR
        );
        graphics = image.getGraphics();
        graphics.setColor(Color.WHITE);
        graphics.fillRect(0, 0, width, height);
        graphics.setColor(Color.BLACK);
        graphics.fillPolygon(region.getPolygon());
        ImageIO.write(image, "PNG", new File("got.png"));
    }
}

- sadakatsu

---

这是我今天看到的最酷的事情 :-) +1 - Paul Samsotha

对我来说，这似乎是因为你代码中多边形内部的定义与java.awt.Polygon的定义不同; 在它们各自的参考系内都是正确的，只是定义不同。如果您想使用Polygon，则需要从您的定义转换为它的定义；否则无法避免... - Durandal

@peeskillet: :) 当这个应用程序Mosaic完全可用时，我会将其放在我的GitHub（https://github.com/sadakatsu）上。一旦它上线，你就可以玩耍了。我希望这将在1-2周内完成。 - sadakatsu

重写JPanel的getPreferredSize方法，然后所有坐标都从getHeight/weight开始计算，包括调整大小时的重绘（忘记了像素完美，例如将10除以3：-），所有块都只是形状，将所有对象放入数组中，在paintComponent内部循环遍历对象数组。这里有一些关于代码的例子。 - mKorbel

@mKorbel：我不理解你的评论。它与我的问题有什么关系？ - sadakatsu

Answer 1

我花了一整天的时间来解决这个问题，看起来我找到了一个解决方法。线索在Shape类的文档中找到，其中写道：

内部定义：如果且仅当以下条件满足时，一个点被认为位于形状内部：

• 它完全位于形状边界内部，或者

• 它恰好位于形状边界上，并且紧邻该点的递增X方向上的空间完全位于边界内部，或者

• 它恰好位于水平边界段上，并且紧邻该点的递增Y方向上的空间位于边界内部。

实际上，这段文字有点误导人；第三种情况覆盖了第二种情况（即使一个像素位于形状底部的水平边界段上，并且其右侧有一个填充点，它仍然不会被填充）。以图示方式表示，下面的Polygon将不会绘制出被x标记的像素：

红色、绿色和蓝色像素是Polygon的一部分；其余部分不是。蓝色像素属于第一种情况，绿色像素属于第二种情况，而红色像素属于第三种情况。请注意，凸包沿最右侧和最低像素都不会被绘制。要使它们被绘制，您必须将顶点移动到橙色像素处，如所示，以形成新的最右/最底部分凸包。

最简单的方法是使用camickr的方法：同时使用fillPolygon()和drawPolygon()。至少在我的45度多边形凸包的情况下，drawPolygon()精确地绘制到顶点（可能也适用于其他情况），因此将填充fillPolygon()未覆盖的像素。但是，fillPolygon()和drawPolygon()都不会绘制单个像素的Polygon，因此必须编写特殊情况来处理它。

我在尝试理解上述“内部”定义时开发的实际解决方案是创建一个不同的Polygon，其中包含如图所示的修改后的角落。它的好处（？）是只调用一次绘图库并自动处理特殊情况。它可能实际上并不是最优的，但这里是我用于任何人考虑的代码：

package com.sadakatsu.mosaic.renderer;

import java.awt.Polygon;
import java.util.Arrays;

import com.sadakatsu.mosaic.Region;

public class RegionPolygon extends Polygon {
    public RegionPolygon(Region region) {
        int bottom = region.getBottom();
        int ll = region.getLL();
        int lr = region.getLR();
        int right = region.getRight();
        int ul = region.getUL();
        int ur = region.getUR();
        int x = region.getX();
        int y = region.getY();

        int[] xes = {
            x + ul,
            right - ur + 1,
            right + 1,
            right + 1,
            right - lr,
            x + ll + 1,
            x,
            x
        };

        int[] yes = {
            y,
            y,
            y + ur,
            bottom - lr,
            bottom + 1,
            bottom + 1,
            bottom - ll,
            y + ul
        };

        npoints = 0;
        xpoints = new int[xes.length];
        ypoints = new int[xes.length];
        for (int i = 0; i < xes.length; ++i) {
            if (
                i == 0 ||
                xpoints[npoints - 1] != xes[i] ||
                ypoints[npoints - 1] != yes[i]
            ) {
                addPoint(xes[i], yes[i]);
            }
        }
    }
}

- sadakatsu