fix 2D polygon volume algorithm

Author: TiagoFar78

worldedit-core/src/main/java/com/sk89q/worldedit/regions/Polygonal2DRegion.java

@@ -26,8 +26,6 @@
 import com.sk89q.worldedit.util.formatting.text.TranslatableComponent;
 import com.sk89q.worldedit.world.World;
 
-import java.math.BigDecimal;
-import java.math.RoundingMode;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Iterator;
@@ -209,22 +207,146 @@ public BlockVector3 getMaximumPoint() {
 
     @Override
     public long getVolume() {
+        if (points.size() <= 2) {
+            return 0;
+        }
+
+        List<BlockVector2> reverseOrderPoints = new ArrayList<>(points);
+        Collections.reverse(reverseOrderPoints);
+        long area = Math.max(getAreaClockwise(points), getAreaClockwise(reverseOrderPoints));
+
+        return area * (maxY - minY + 1);
+    }
+
+    private long getAreaClockwise(List<BlockVector2> points) {
+        int n = points.size();
+
+        int[] previousDirections = new int[n];
+        int[] followingDirections = new int[n];
+        for (int i = 0; i < 2; i++) {
+            for (int j = 0; j < n; j++) {
+                previousDirections[j] = getDirection(points, j);
+                if (previousDirections[j] == 0) {
+                    previousDirections[j] = previousDirections[(j - 1 + n) % n];
+                }
+
+                followingDirections[n - 1 - j] = getDirection(points, n - 1 - j);
+                if (followingDirections[n - 1 - j] == 0) {
+                    followingDirections[n - 1 - j] = followingDirections[(n - j) % n];
+                }
+            }
+        }
+
         long area = 0;
-        int i;
-        int j = points.size() - 1;
 
-        for (i = 0; i < points.size(); ++i) {
-            long x = points.get(j).x() + points.get(i).x();
-            long z = points.get(j).z() - points.get(i).z();
-            area += x * z;
+        int minX = points.stream().mapToInt(BlockVector2::x).min().orElse(0);
+        int j = n - 1;
+        int prevIsNewDirection = isNewDirection(points, j - 1, previousDirections, followingDirections);
+        for (int i = 0; i < n; i++) {
+            int x1 = points.get(j).x() - minX;
+            int z1 = points.get(j).z();
+            int x2 = points.get(i).x() - minX;
+            int z2 = points.get(i).z();
+            int isNewDirectionValue = isNewDirection(points, j, previousDirections, followingDirections);
+            area += areaInPoints(x1, z1, x2, z2, isNewDirectionValue, prevIsNewDirection);
+
+            prevIsNewDirection = isNewDirectionValue;
             j = i;
         }
 
-        return BigDecimal.valueOf(area)
-                .multiply(BigDecimal.valueOf(0.5))
-                .abs()
-                .setScale(0, RoundingMode.FLOOR)
-                .longValue() * (maxY - minY + 1);
+        return area;
+    }
+
+    private int getDirection(List<BlockVector2> points, int i) {
+        int z1 = points.get(i).z();
+        int z2 = points.get((i + 1) % points.size()).z();
+        return z1 > z2 ? 1 : z1 == z2 ? 0 : -1;
+    }
+
+    private int isNewDirection(List<BlockVector2> points, int i, int[] previousDirections, int[] followingDirections) {
+        int n = points.size();
+
+        int x = points.get(i % n).x();
+        int z = points.get(i % n).z();
+        int x1 = points.get((i + 1) % n).x();
+        int x2 = points.get((i - 1 + n) % n).x();
+        int z1 = points.get((i + 1) % n).z();
+        int z2 = points.get((i - 1 + n) % n).z();
+        int previousEdgeOrientation = crossProduct(x1, z1, x, z, x2, z2);
+
+        x = points.get((i + 1) % n).x();
+        z = points.get((i + 1) % n).z();
+        x1 = points.get(i % n).x();
+        x2 = points.get((i + 2) % n).x();
+        z1 = points.get(i % n).z();
+        z2 = points.get((i + 2) % n).z();
+        int nextEdgeOrientation = crossProduct(x1, z1, x, z, x2, z2);
+
+        int direction = getDirection(points, i);
+        if (direction == -1) {
+            return direction != followingDirections[(i + 1) % n] && nextEdgeOrientation > 0 ? 1 : 0;
+        }
+
+        if (direction == 1) {
+            return direction != previousDirections[(i - 1 + n) % n] && previousEdgeOrientation < 0 ? 1 : 0;
+        }
+
+        boolean prevCondition = previousDirections[(i - 1 + n) % n] == 1 && previousEdgeOrientation >= 0;
+        boolean follCondition = followingDirections[(i + 1) % n] == -1 && nextEdgeOrientation <= 0;
+
+        return prevCondition && follCondition ? 2 : prevCondition || follCondition ? 1 : 0;
+    }
+
+    private int crossProduct(int x1, int y1, int x, int y, int x2, int y2) {
+        return (x1 - x) * (y2 - y) - (x2 - x) * (y1 - y);
+    }
+
+    public long areaInPoints(int x1, int z1, int x2, int z2, int isNewDirectionValue, int prevIsNewDirectionValue) {
+        if (z1 == z2) {
+            if (isNewDirectionValue == 2 && isNewDirectionValue != prevIsNewDirectionValue) {
+                return Math.abs(x1 - x2) - 1;
+            }
+
+            return isNewDirectionValue != 0 ? Math.abs(x1 - x2) : 0;
+        }
+
+        boolean isNewDirection = isNewDirectionValue == 1;
+        boolean isIncreasing = z1 > z2;
+        long area = 0;
+
+        int side = Math.min(x1, x2) + (isIncreasing ? 1 : 0);
+        int height = isNewDirection ? next(z1 - z2) : z1 - z2;
+        area += (long) side * height;
+
+        if ((isIncreasing && (x1 < x2 || isNewDirection)) || (!isIncreasing && (x1 < x2 && !isNewDirection))) {
+            area += Math.abs(x1 - x2);
+        }
+
+        int z = Math.abs(z1 - z2);
+        int x = Math.abs(x1 - x2);
+        int squaresInLine = x + z - gcd(x, z);
+        if (!isIncreasing) {
+            area -= (x * z - squaresInLine) / 2;
+            area -= squaresInLine;
+        } else {
+            area += (x * z - squaresInLine) / 2;
+        }
+
+        return area;
+    }
+
+    private int next(int value) {
+        return value < 0 ? value - 1 : value + 1;
+    }
+
+    private int gcd(int n1, int n2) {
+        while (n2 != 0) {
+            int temp = n2;
+            n2 = n1 % n2;
+            n1 = temp;
+        }
+
+        return n1;
     }
 
     @Override

worldedit-core/src/test/java/com/sk89q/worldedit/regions/Polygonal2DRegionTest.java

@@ -0,0 +1,90 @@
+/*
+ * WorldEdit, a Minecraft world manipulation toolkit
+ * Copyright (C) sk89q <http://www.sk89q.com>
+ * Copyright (C) WorldEdit team and contributors
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.sk89q.worldedit.regions;
+
+import com.sk89q.worldedit.math.BlockVector2;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class Polygonal2DRegionTest {
+
+    @ParameterizedTest(name = "index={index}")
+    @MethodSource("areaTestData")
+    void testArea(int[][] coordinates, long expectedVolume) {
+        List<BlockVector2> points = toPoints(coordinates);
+        Polygonal2DRegion region = new Polygonal2DRegion(null, points, 0, 0);
+
+        assertEquals(expectedVolume, region.getVolume());
+    }
+
+    static List<Arguments> areaTestData() {
+        return List.of(
+                Arguments.of(new int[][]{{0, 0}, {0, 1}, {1, 1}, {1, 0}}, 4), // simple square
+                Arguments.of(new int[][]{{0, 0}, {2, 2}, {2, 0}}, 6), // triangle removing diagonal
+                Arguments.of(new int[][]{{6, 3}, {6, 1}, {0, 0}}, 10), // polygon with separated parts
+                Arguments.of(new int[][]{{-1, 1}, {4, 1}, {4, -3}, {-1, -3}}, 30), // x < 0
+                Arguments.of(new int[][]{
+                        {0, 9}, {6, 9}, {6, 0}, {1, 2}, {4, 4}, {3, 7}, {0, 5}
+                }, 47), // concave
+                Arguments.of(new int[][]{
+                        {0, 4}, {2, 6}, {4, 6}, {6, 4}, {6, 2}, {4, 0}, {2, 0}, {0, 2}
+                }, 37), // octagon
+                Arguments.of(new int[][]{
+                        {0, 0}, {2, 2}, {2, 4}, {0, 6}, {6, 6}, {4, 4}, {4, 2}, {6, 0}
+                }, 33), // hourglass
+                Arguments.of(new int[][]{
+                        {0, 5}, {11, 5}, {11, 0}, {9, 0}, {9, 4}, {7, 4}, {7, 1}, {6, 1},
+                        {6, 2}, {4, 2}, {4, 1}, {3, 1}, {3, 0}, {1, 0}, {1, 3}, {0, 3}
+                }, 60), // checks if new direction is well assigned
+                Arguments.of(new int[][]{
+                        {0, 5}, {2, 3}, {5, 3}, {7, 1}, {0, 1}
+                }, 24), // horizontal and downwards
+                Arguments.of(new int[][]{
+                        {0, 0}, {2, 2}, {4, 2}, {6, 4}, {6, 0}
+                }, 21), // horizontal and upwards
+                Arguments.of(new int[][]{
+                        {0, 5}, {3, 5}, {2, 3}, {5, 3}, {7, 5}, {7, 1}, {0, 1}
+                }, 34), // horizontal with upwards and downwards
+                Arguments.of(new int[][]{
+                        {0, 5}, {3, 5}, {2, 3}, {4, 3}, {5, 3}, {7, 5}, {7, 1}, {0, 1}
+                }, 34), // horizontal, upwards, downwards, split
+                Arguments.of(new int[][]{
+                        {1, 3}, {3, 3}, {4, 5}, {6, 8}, {7, 6}, {9, 6}, {12, 8}, {11, 6}, {11, 4},
+                        {10, 2}, {8, 0}, {6, 1}, {9, 4}, {6, 3}, {4, 1}, {3, 0}, {1, 1}
+                }, 55) // complex polygon
+        );
+    }
+
+    private static List<BlockVector2> toPoints(int[]... coordinates) {
+        List<BlockVector2> points = new ArrayList<>();
+        for (int[] coordinate : coordinates) {
+            points.add(BlockVector2.at(coordinate[0], coordinate[1]));
+        }
+
+        return points;
+    }
+
+}