以下代码适用于任何凸 4 边多边形。当初始多边形是平行四边形时，生成的子多边形本质上也是平行四边形，都具有相同的大小，即它们是均匀大小的。
由于所需的parts 的数量必须是平方数，这意味着我们可以简单地将 4 边多边形水平和垂直分割成partsPerSide = sqrt(parts)。
当我们将一个 4 边形多边形分割成多个部分时，我们最终可能会得到不是精确整数的坐标。我们可以简单地将值四舍五入为一个整数，但这样碎片的大小就不会完全均匀了。这是否可以接受是一个选择问题。在视觉上，可以注意到圆角，因为线条不会 100% 笔直。
在下面的代码中，我们假设舍入是不可接受的，即我们想要精确的偶数大小。如果四舍五入没问题，只需在末尾注释掉if (rounded != delta) throw new ArithmeticException() 代码，然后使用所需的partsPerSide 编号调用splitFourSided()。
废话不多说，代码如下：
private static Polygon[][] splitFourSided(Polygon poly, int partsPerSide) {
if (poly.npoints != 4)
throw new IllegalArgumentException("Polygon must be 4-sided");
if (partsPerSide <= 0)
throw new IllegalArgumentException("There must be a positive number of parts per side");
int[][] x = splitFourSided(poly.xpoints, partsPerSide);
int[][] y = splitFourSided(poly.ypoints, partsPerSide);
Polygon[][] pieces = new Polygon[partsPerSide][partsPerSide];
for (int row = 0; row < partsPerSide; row++) {
for (int col = 0; col < partsPerSide; col++) {
pieces[row][col] = new Polygon(
new int[] { x[row][col], x[row][col+1], x[row+1][col+1], x[row+1][col] },
new int[] { y[row][col], y[row][col+1], y[row+1][col+1], y[row+1][col] },
4);
}
}
return pieces;
}
private static int[][] splitFourSided(int[] xy, int parts) {
// To visualize, assume values are [topLeft, topRight, bottomRight, bottomLeft].
// The 'xy' array is either the x-coordinates or the y-coordinates.
// First we split left and right sides, e.g. for 3 parts:
// From: ┌ To: ┐
// ├ ┤
// ├ ┤
// └ ┘
// Then we split between those:
// ┌─┬─┬─┐
// ├─┼─┼─┤
// ├─┼─┼─┤
// └─┴─┴─┘
int[] from = splitRange(xy[0], xy[3], parts);
int[] to = splitRange(xy[1], xy[2], parts);
int[][] grid = new int[parts + 1][];
for (int i = 0; i <= parts; i++)
grid[i] = splitRange(from[i], to[i], parts);
return grid;
}
private static int[] splitRange(int from, int to, int parts) {
int[] prorated = new int[parts + 1];
for (int i = 0; i <= parts; i++)
prorated[i] = prorate(from, to, i, parts);
return prorated;
}
private static int prorate(int from, int to, int index, int parts) {
if (index == 0)
return from;
if (index == parts)
return to;
double delta = (to - (double) from) * index / parts;
int rounded = (int) Math.round(delta);
if (rounded != delta)
throw new ArithmeticException("Cannot prorate to integer value");
return from + rounded;
}
测试
int[] x = {38, 100, 80, 18};
int[] y = {50, 50, 100, 100};
Polygon poly = new Polygon(x, y, 4);
splitAndDrawFourSided(g, poly, 2);
private static void splitAndDrawFourSided(Graphics g, Polygon poly, int partsPerSide) {
Polygon[][] pieces = splitFourSided(poly, partsPerSide);
for (int row = 0; row < partsPerSide; row++)
for (int col = 0; col < partsPerSide; col++)
g.drawPolygon(pieces[row][col]);
Graphics gMain = g.create();
try {
gMain.setColor(Color.RED);
gMain.drawPolygon(poly);
} finally {
gMain.dispose();
}
}
结果
要搜索有效数量的零件，我们可以添加一个搜索循环，并更改坐标，使它们只能被 7 整除。
int[] x = {37, 100, 79, 16};
int[] y = {50, 50, 99, 99};
Polygon poly = new Polygon(x, y, 4);
for (int partsPerSide : new int[] { 2, 3, 5, 7, 11, 13, 17, 19 }) {
try {
splitAndDrawFourSided(g, poly, partsPerSide);
break; // stop when successful
} catch (@SuppressWarnings("unused") ArithmeticException ignored) {
continue; // try next number of parts
}
}
结果
如果我们删除舍入检查，该代码当然总是每边只分成 2 部分，即分成 4 部分。这显示了舍入的效果，例如在这种情况下，中心行坐标稍微偏右，导致黑线和红线不匹配。即使没有描绘输入平行四边形的红线，也可以注意到舍入。 Anti-aliasing 有帮助，但仍然可以注意到垂直线不是 100% 笔直的。