[MAPS3D-2108] Fix polygon clipping precision errors causing rendering artifacts (internal-8556)

GitOrigin-RevId: afd8d16d30959cca2964bcaa697e00c91d809b64

Author: lasselammi

src/util/polygon_clipping.ts

@@ -262,16 +262,42 @@ export function polygonSubdivision(subjectPolygon: Point[][], subdivisionEdges:
         polygons = martinez.diff(polygons, clipGeometry) as martinez.MultiPolygon;
     }
 
-    return fromMultiPolygon(polygons, 1 / scale);
+    // Snap to grid of 128 in 32bit space to eliminate martinez precision errors.
+    // This corresponds to ~0.002 tile units (128 / 65536) after scaling back.
+    return fromMultiPolygon(polygons, 1 / scale, 128);
 }
 
 function toMultiPolygon(polygon: Point[][], scale: number = 1.0): martinez.MultiPolygon {
     return [polygon.map(ring => ring.map(p => [p.x * scale, p.y * scale]))];
 }
 
-function fromMultiPolygon(geometry: martinez.MultiPolygon, scale: number = 1.0): Point[][][] {
+/**
+ * Converts martinez MultiPolygon geometry back to Point arrays.
+ *
+ * @param {martinez.MultiPolygon} geometry - The martinez MultiPolygon to convert
+ * @param {number} scale - Scale factor to apply to coordinates (default 1.0)
+ * @param {number} [gridSize] - Optional grid size for snapping coordinates before scaling.
+ *                              When provided, coordinates are rounded to the nearest multiple
+ *                              of this value before scaling. This helps eliminate floating-point
+ *                              precision errors from the martinez library, ensuring that adjacent
+ *                              polygon edges that should share vertices end up with identical
+ *                              coordinates after conversion.
+ * @returns {Point[][][]}
+ * @private
+ */
+function fromMultiPolygon(geometry: martinez.MultiPolygon, scale: number = 1.0, gridSize?: number): Point[][][] {
     return geometry.map(poly => poly.map((ring, index) => {
-        const r = ring.map(p => new Point(p[0] * scale, p[1] * scale).round());
+        const r = ring.map(p => {
+            let x = p[0];
+            let y = p[1];
+
+            if (gridSize) {
+                x = Math.round(x / gridSize) * gridSize;
+                y = Math.round(y / gridSize) * gridSize;
+            }
+
+            return new Point(x * scale, y * scale)._round();
+        });
         if (index > 0) {
             // Reverse holes
             r.reverse();

test/unit/util/polygon_clipping.test.ts

@@ -564,4 +564,63 @@ describe('polygon subdivision', () => {
         // eslint-disable-next-line @typescript-eslint/no-unsafe-call
         expect(result[7][0]).toEqualRing([new Point(90, 47), new Point(100, 50), new Point(100, 60), new Point(90, 58), new Point(90, 47)]);
     });
+
+    test('grid snapping to fix precision issues', () => {
+        // Real-world polygon that caused precision issues without grid snapping fix.
+        // The martinez library can produce nearly-coincident vertices that should be
+        // identical, causing rendering artifacts.
+        const subject = [
+            new Point(1569, 3677), new Point(1737, 3023), new Point(1825, 2634),
+            new Point(1952, 1864), new Point(2077, 728), new Point(2111, -1),
+            new Point(4966, -1), new Point(4960, 192), new Point(4843, 1624),
+            new Point(4681, 2642), new Point(4455, 3748), new Point(4278, 4475),
+            new Point(1569, 3677)
+        ];
+
+        const edges = new MockEdgeIterator([
+            [new Point(3959, -8562), new Point(868, -7651)],
+            [new Point(4357, -7209), new Point(1246, -6374)],
+            [new Point(4703, -5781), new Point(1546, -5138)],
+            [new Point(4945, -4322), new Point(1752, -3891)],
+            [new Point(5013, -2859), new Point(1970, -2624)],
+            [new Point(5086, -1399), new Point(2035, -1346)],
+            [new Point(5063, 67), new Point(2014, -69)],
+            [new Point(4954, 1538), new Point(1921, 1195)],
+            [new Point(4730, 3006), new Point(1731, 2437)],
+            [new Point(4440, 4288), new Point(1463, 3611)]
+        ]);
+
+        const result = polygonSubdivision([subject], edges);
+
+        expect(result.length).toBe(5);
+
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+        expect(result[0][0]).toEqualRing([
+            new Point(1569, 3677), new Point(1579, 3637), new Point(4330, 4263),
+            new Point(4278, 4475), new Point(1569, 3677)
+        ]);
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+        expect(result[1][0]).toEqualRing([
+            new Point(1579, 3637), new Point(1737, 3023), new Point(1825, 2634),
+            new Point(1854, 2460), new Point(4611, 2983), new Point(4455, 3748),
+            new Point(4330, 4263), new Point(1579, 3637)
+        ]);
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+        expect(result[2][0]).toEqualRing([
+            new Point(1854, 2460), new Point(1952, 1864), new Point(2024, 1207),
+            new Point(4851, 1526), new Point(4843, 1624), new Point(4681, 2642),
+            new Point(4611, 2983), new Point(1854, 2460)
+        ]);
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+        expect(result[3][0]).toEqualRing([
+            new Point(2024, 1207), new Point(2077, 728), new Point(2111, -1),
+            new Point(3539, -1), new Point(4964, 63), new Point(4960, 192),
+            new Point(4851, 1526), new Point(2024, 1207)
+        ]);
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+        expect(result[4][0]).toEqualRing([
+            new Point(3539, -1), new Point(4966, -1), new Point(4964, 63),
+            new Point(3539, -1)
+        ]);
+    });
 });