@weasel-js/geom 1.11.0 → 1.12.0

package/dist/booleans/index.d.ts

@@ -60,7 +60,9 @@ declare function pathCropPieces(...paths: Path[]): BooleanPiece[];
 /**
  * Union the triangles of an indexed mesh (`vertices` as x, y pairs; `indices`
  * three per triangle) into canonical, non-overlapping rings. Overlaps count
- * once, and triangles with no area are skipped. The result holds only M/L/Z.
+ * once, triangles with no area are skipped, and a vertex lying on another
+ * triangle's edge joins it there rather than leaving a crack. The result
+ * holds only M/L/Z.
  */
 declare function trianglesToPath(vertices: ArrayLike<number>, indices: ArrayLike<number>): PolygonPath;
 

package/dist/booleans/index.js

@@ -1,6 +1,6 @@
-import { orientBoundaries, parseContours, contoursIntersect, assembleRegions, signedArea, negligibleArea, regionArea, toPath, parseSubpaths, writePath, signChanges, sideCoeffs, evalSeg, extentOf, keepCorners, windingAt, reverseContour, sampleContour, subSeg, endSide } from '../chunk-7KLJZFBY.js';
+import { orientBoundaries, parseContours, contoursIntersect, assembleRegions, signedArea, negligibleArea, regionArea, toPath, parseSubpaths, writePath, signChanges, sideCoeffs, evalSeg, extentOf, keepCorners, windingAt, reverseContour, sampleContour, subSeg, endSide } from '../chunk-YPWFGFQX.js';
 import '../chunk-CE7IY7TB.js';
-import { resolveCorners, DEFAULT_FLATTEN_TOLERANCE, fillsOpenSubpaths, flattenCubic, flattenQuadratic, pointInPolygon } from '../chunk-J2O2B54M.js';
+import { resolveCorners, DEFAULT_FLATTEN_TOLERANCE, fillsOpenSubpaths, flattenCubic, flattenQuadratic, pointInPolygon } from '../chunk-2PKPKU4P.js';
 import '../chunk-755Y4YZS.js';
 import { PATH_Z, PATH_Q, elevateQuadraticToCubic, PATH_C, PATH_L, PATH_M } from '../chunk-B53BERKG.js';
 import polygonClipping from 'polygon-clipping';
@@ -574,19 +574,146 @@ function pathCropPieces(...paths) {
   }
   return out;
 }
+
+// src/booleans/meshJunctions.ts
+var ON_EDGE = 2 ** -20;
+function junctionRings(vertices, triangles) {
+  const n = vertices.length / 2;
+  let scale = 0, minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  for (let i = 0; i < n; i++) {
+    const x = vertices[i * 2], y = vertices[i * 2 + 1];
+    scale = Math.max(scale, Math.abs(x), Math.abs(y));
+    minX = Math.min(minX, x);
+    minY = Math.min(minY, y);
+    maxX = Math.max(maxX, x);
+    maxY = Math.max(maxY, y);
+  }
+  const eps = scale * ON_EDGE;
+  const cell = Math.max(maxX - minX, maxY - minY, eps) / Math.max(1, Math.sqrt(n));
+  const grid = /* @__PURE__ */ new Map();
+  const key = (cx, cy) => `${cx},${cy}`;
+  for (const i of new Set(triangles)) {
+    const k = key(Math.floor((vertices[i * 2] - minX) / cell), Math.floor((vertices[i * 2 + 1] - minY) / cell));
+    const bucket = grid.get(k);
+    if (bucket) bucket.push(i);
+    else grid.set(k, [i]);
+  }
+  const onEdge = (p, q) => {
+    const px = vertices[p * 2], py = vertices[p * 2 + 1];
+    const dx = vertices[q * 2] - px, dy = vertices[q * 2 + 1] - py;
+    const len2 = dx * dx + dy * dy;
+    if (len2 === 0) return [];
+    const len = Math.sqrt(len2);
+    const hits = [];
+    const x0 = Math.floor((Math.min(px, px + dx) - eps - minX) / cell), x1 = Math.floor((Math.max(px, px + dx) + eps - minX) / cell);
+    const y0 = Math.floor((Math.min(py, py + dy) - eps - minY) / cell), y1 = Math.floor((Math.max(py, py + dy) + eps - minY) / cell);
+    for (let cx = x0; cx <= x1; cx++) {
+      for (let cy = y0; cy <= y1; cy++) {
+        for (const i of grid.get(key(cx, cy)) ?? []) {
+          const vx = vertices[i * 2] - px, vy = vertices[i * 2 + 1] - py;
+          const t = (vx * dx + vy * dy) / len2;
+          if (t * len <= eps || (1 - t) * len <= eps) continue;
+          if (Math.abs(vx * dy - vy * dx) / len <= eps) hits.push({ i, t });
+        }
+      }
+    }
+    return hits.sort((a, b) => a.t - b.t).map((h) => h.i);
+  };
+  const rings = [];
+  for (let k = 0; k + 2 < triangles.length; k += 3) {
+    const ring = [];
+    for (let e = 0; e < 3; e++) {
+      const p = triangles[k + e], q = triangles[k + (e + 1) % 3];
+      for (const i of [p, ...onEdge(p, q)]) ring.push([vertices[i * 2], vertices[i * 2 + 1]]);
+    }
+    ring.push(ring[0]);
+    rings.push(ring);
+  }
+  return rings;
+}
+
+// src/booleans/meshOutline.ts
+function meshOutline(rings) {
+  const points = /* @__PURE__ */ new Map();
+  const edges = /* @__PURE__ */ new Map();
+  const keyOf = (p) => {
+    const k = `${p[0]},${p[1]}`;
+    if (!points.has(k)) points.set(k, p);
+    return k;
+  };
+  for (const ring of rings) {
+    const keys = ring.slice(0, -1).map(keyOf);
+    if (ringArea(ring) < 0) keys.reverse();
+    for (let i = 0; i < keys.length; i++) {
+      const a = keys[i], b = keys[(i + 1) % keys.length];
+      if (a === b) continue;
+      const back = `${b}|${a}`;
+      const n = edges.get(back);
+      if (n) {
+        if (n === 1) edges.delete(back);
+        else edges.set(back, n - 1);
+      } else {
+        const fwd = `${a}|${b}`;
+        edges.set(fwd, (edges.get(fwd) ?? 0) + 1);
+      }
+    }
+  }
+  const loops = walkLoops(edges).map((loop) => loop.map((k) => points.get(k)));
+  return loops.length === 0 ? null : bridge(loops);
+}
+function walkLoops(edges) {
+  const out = /* @__PURE__ */ new Map();
+  for (const [edge, n] of edges) {
+    const [a, b] = edge.split("|");
+    let list = out.get(a);
+    if (!list) out.set(a, list = []);
+    for (let i = 0; i < n; i++) list.push(b);
+  }
+  const loops = [];
+  for (const start of out.keys()) {
+    while ((out.get(start)?.length ?? 0) > 0) {
+      const loop = [start];
+      let at = out.get(start).pop();
+      while (at !== start) {
+        loop.push(at);
+        const next = out.get(at);
+        at = next.pop();
+      }
+      loops.push(loop);
+    }
+  }
+  return loops;
+}
+function bridge(loops) {
+  const entered = loops.map((loop) => {
+    let k = 0;
+    for (let i = 1; i < loop.length; i++) if (loop[i][0] < loop[k][0] || loop[i][0] === loop[k][0] && loop[i][1] < loop[k][1]) k = i;
+    return [...loop.slice(k), ...loop.slice(0, k)];
+  });
+  entered.sort((a, b) => a[0][0] - b[0][0] || a[0][1] - b[0][1]);
+  const ring = [];
+  for (const loop of entered) ring.push(...loop, loop[0]);
+  for (let i = entered.length - 2; i >= 0; i--) ring.push(entered[i][0]);
+  return ring;
+}
+function ringArea(ring) {
+  let a = 0;
+  for (let i = 0; i + 1 < ring.length; i++) a += ring[i][0] * ring[i + 1][1] - ring[i + 1][0] * ring[i][1];
+  return a;
+}
+
+// src/booleans/trianglesToPath.ts
 function trianglesToPath(vertices, indices) {
-  const triangles = [];
+  const kept = [];
   for (let i = 0; i + 2 < indices.length; i += 3) {
     const a = indices[i] * 2, b = indices[i + 1] * 2, c = indices[i + 2] * 2;
     const ax = vertices[a], ay = vertices[a + 1];
-    const bx = vertices[b], by = vertices[b + 1];
-    const cx = vertices[c], cy = vertices[c + 1];
-    if ((bx - ax) * (cy - ay) - (cx - ax) * (by - ay) === 0) continue;
-    triangles.push([[[[ax, ay], [bx, by], [cx, cy], [ax, ay]]]]);
-  }
-  if (triangles.length === 0) return multiPolygonToPath([]);
-  const [head, ...rest] = triangles;
-  return multiPolygonToPath(polygonClipping.union(head, ...rest));
+    if ((vertices[b] - ax) * (vertices[c + 1] - ay) - (vertices[c] - ax) * (vertices[b + 1] - ay) === 0) continue;
+    kept.push(indices[i], indices[i + 1], indices[i + 2]);
+  }
+  if (kept.length === 0) return multiPolygonToPath([]);
+  const outline = meshOutline(junctionRings(vertices, kept));
+  return multiPolygonToPath(outline ? polygonClipping.union([[outline]]) : []);
 }
 
 // src/booleans/cutCrossings.ts