@pooder/kit 4.3.1 → 5.0.0

package/src/geometry.ts

@@ -1,4 +1,6 @@
 import paper from "paper";
+import { pickExitIndex, scoreOutsideAbove } from "./bridgeSelection";
+import { sampleWrappedOffsets, wrappedDistance } from "./wrappedOffsets";
 
 export type FeatureOperation = "add" | "subtract";
 export type FeatureShape = "rect" | "circle";
@@ -71,6 +73,120 @@ function ensurePaper(width: number, height: number) {
   }
 }
 
+const isBridgeDebugEnabled = () =>
+  Boolean((globalThis as any).__POODER_BRIDGE_DEBUG__);
+
+function normalizePathItem(shape: paper.PathItem): paper.PathItem {
+  let result: any = shape;
+  if (typeof result.resolveCrossings === "function") result = result.resolveCrossings();
+  if (typeof result.reduce === "function") result = result.reduce({});
+  if (typeof result.reorient === "function") result = result.reorient(true, true);
+  if (typeof result.reduce === "function") result = result.reduce({});
+  return result as paper.PathItem;
+}
+
+function getBridgeDelta(itemBounds: paper.Rectangle, overlap: number) {
+  return Math.max(overlap, Math.min(5, Math.max(1, itemBounds.height * 0.02)));
+}
+
+function getExitHit(args: {
+  mainShape: paper.Path;
+  x: number;
+  bridgeBottom: number;
+  toY: number;
+  eps: number;
+  delta: number;
+  overlap: number;
+  op: FeatureOperation;
+}) {
+  const { mainShape, x, bridgeBottom, toY, eps, delta, overlap, op } = args;
+
+  const ray = new paper.Path.Line({
+    from: [x, bridgeBottom],
+    to: [x, toY],
+    insert: false,
+  });
+
+  const intersections = mainShape.getIntersections(ray) || [];
+  ray.remove();
+
+  const validHits = intersections.filter((i) => i.point.y < bridgeBottom - eps);
+  if (validHits.length === 0) return null;
+
+  validHits.sort((a, b) => b.point.y - a.point.y);
+  const flags = validHits.map((h) => {
+    const above = h.point.add(new paper.Point(0, -delta));
+    const below = h.point.add(new paper.Point(0, delta));
+    return {
+      insideAbove: mainShape.contains(above),
+      insideBelow: mainShape.contains(below),
+    };
+  });
+
+  const idx = pickExitIndex(flags);
+  if (idx < 0) return null;
+
+  if (isBridgeDebugEnabled()) {
+    console.debug("Geometry: Bridge ray", {
+      x,
+      validHits: validHits.length,
+      idx,
+      delta,
+      overlap,
+      op,
+    });
+  }
+
+  const hit = validHits[idx];
+  return { point: hit.point, location: hit };
+}
+
+function selectOuterChain(args: {
+  mainShape: paper.Path;
+  pointsA: paper.Point[];
+  pointsB: paper.Point[];
+  delta: number;
+  overlap: number;
+  op: FeatureOperation;
+}) {
+  const { mainShape, pointsA, pointsB, delta, overlap, op } = args;
+
+  const scoreA = scoreOutsideAbove(
+    pointsA.map((p) => ({
+      outsideAbove: !mainShape.contains(p.add(new paper.Point(0, -delta))),
+    })),
+  );
+  const scoreB = scoreOutsideAbove(
+    pointsB.map((p) => ({
+      outsideAbove: !mainShape.contains(p.add(new paper.Point(0, -delta))),
+    })),
+  );
+
+  const ratioA = scoreA / pointsA.length;
+  const ratioB = scoreB / pointsB.length;
+
+  if (isBridgeDebugEnabled()) {
+    console.debug("Geometry: Bridge chain", {
+      scoreA,
+      scoreB,
+      lenA: pointsA.length,
+      lenB: pointsB.length,
+      ratioA,
+      ratioB,
+      delta,
+      overlap,
+      op,
+    });
+  }
+
+  const ratioEps = 1e-6;
+  if (Math.abs(ratioA - ratioB) > ratioEps) {
+    return ratioA > ratioB ? pointsA : pointsB;
+  }
+  if (scoreA !== scoreB) return scoreA > scoreB ? pointsA : pointsB;
+  return pointsA.length <= pointsB.length ? pointsA : pointsB;
+}
+
 /**
  * Creates the base dieline shape (Rect/Circle/Ellipse/Custom)
  */
@@ -182,87 +298,129 @@ function getPerimeterShape(options: GeometryOptions): paper.PathItem {
         const bridgeBottom = itemBounds.top;
 
         if (bridgeBottom > bridgeTop) {
-            // Ray Casting Approach:
-            // 1. Create a vertical ray from the center of the feature upwards
-            const centerX = itemBounds.center.x;
-            const ray = new paper.Path.Line({
-              from: [centerX, bridgeBottom],
-              to: [centerX, bridgeTop - 10], // Extend slightly past top to ensure intersection
-              insert: false
-            });
-
-            // 2. Find intersections with the main shape
-            const intersections = mainShape.getIntersections(ray);
-            
-            // 3. Find the lowest intersection point (highest Y)
-            // Intersections are usually sorted by offset, but we want to be safe.
-            // We want the point with the largest Y that is still <= bridgeBottom.
-            let targetY = bridgeTop; // Default to top if no intersection (shouldn't happen if overlapping)
-            let found = false;
-
-            if (intersections && intersections.length > 0) {
-               // Filter intersections that are strictly above the feature start
-               // (allow small tolerance for touching)
-               const validHits = intersections.filter(i => i.point.y < bridgeBottom - 0.1);
-               
-               if (validHits.length > 0) {
-                  // We want the HIT that is CLOSEST to the feature (Largest Y)
-                  validHits.sort((a, b) => b.point.y - a.point.y);
-                  targetY = validHits[0].point.y;
-                  found = true;
-               }
-            }
-            
-            ray.remove();
-
-            // 4. Create the bridge rect
-            // If we found a hit, targetY is the surface of the main shape.
-            // We want to overlap slightly to ensure union.
-            const overlap = 2; // Overlap by 2 units
-            const rectBottom = bridgeBottom; // Start at feature top
-            let rectTop = found ? targetY + overlap : bridgeTop; // If not found, go all the way? Or maybe fail safe.
-            
-            // If we didn't find an intersection, it might mean the feature is completely below the shape (no X overlap).
-            // In that case, maybe we shouldn't bridge? Or bridge to the bounding box bottom?
-            // For now, if found, use it. If not, use mainBounds.bottom?
-            // Let's assume if !found, we try to project to mainBounds.bottom if it's above us.
-            if (!found) {
-               if (mainBounds.bottom < bridgeBottom) {
-                  targetY = mainBounds.bottom;
-                  rectTop = targetY - overlap; // Penetrate up
-               }
-            }
-
-            if (rectTop < rectBottom) {
-               const bridgeRect = new paper.Path.Rectangle({
-                  from: [itemBounds.left, rectTop],
-                  to: [itemBounds.right, rectBottom],
-                  insert: false
-               });
-
-               const unitedItem = item.unite(bridgeRect);
-               item.remove();
-               bridgeRect.remove();
-
-               if (f.operation === "add") {
-                  adds.push(unitedItem);
-               } else {
-                  subtracts.push(unitedItem);
-               }
-            } else {
-               // Bridge height is negative or zero, just use item
-               if (f.operation === "add") {
-                  adds.push(item);
-               } else {
-                  subtracts.push(item);
-               }
-            }
+          const overlap = 2;
+          const rayPadding = 10;
+          const eps = 0.1;
+          const delta = getBridgeDelta(itemBounds, overlap);
+
+          const toY = bridgeTop - rayPadding;
+          const inset = Math.min(1, Math.max(0, itemBounds.width * 0.01));
+          const xLeft = itemBounds.left + inset;
+          const xRight = itemBounds.right - inset;
+
+          if (!(mainShape instanceof paper.Path)) {
+            throw new Error("Geometry: Bridge requires base shape to be a Path");
+          }
+
+          const leftHit = getExitHit({
+            mainShape,
+            x: xLeft,
+            bridgeBottom,
+            toY,
+            eps,
+            delta,
+            overlap,
+            op: f.operation,
+          });
+          const rightHit = getExitHit({
+            mainShape,
+            x: xRight,
+            bridgeBottom,
+            toY,
+            eps,
+            delta,
+            overlap,
+            op: f.operation,
+          });
+
+          if (!leftHit || !rightHit || xRight - xLeft <= eps) {
+            throw new Error("Geometry: Bridge ray intersection not found");
+          }
+
+          const path = mainShape as paper.Path;
+          const pathLength = path.length;
+          const leftOffset = leftHit.location.offset;
+          const rightOffset = rightHit.location.offset;
+
+          const distanceA = wrappedDistance(pathLength, leftOffset, rightOffset);
+          const distanceB = wrappedDistance(pathLength, rightOffset, leftOffset);
+          const countFor = (d: number) => Math.max(8, Math.min(80, Math.ceil(d / 6)));
+
+          const offsetsA = sampleWrappedOffsets(
+            pathLength,
+            leftOffset,
+            rightOffset,
+            countFor(distanceA),
+          );
+
+          const offsetsB = sampleWrappedOffsets(
+            pathLength,
+            rightOffset,
+            leftOffset,
+            countFor(distanceB),
+          );
+
+          const pointsA = offsetsA
+            .map((o) => path.getPointAt(o))
+            .filter((p): p is paper.Point => Boolean(p));
+          const pointsB = offsetsB
+            .map((o) => path.getPointAt(o))
+            .filter((p): p is paper.Point => Boolean(p));
+
+          if (pointsA.length < 2 || pointsB.length < 2) {
+            throw new Error("Geometry: Bridge contour sampling failed");
+          }
+
+          let topBase = selectOuterChain({
+            mainShape,
+            pointsA,
+            pointsB,
+            delta,
+            overlap,
+            op: f.operation,
+          });
+
+          const dist2 = (a: paper.Point, b: paper.Point) => {
+            const dx = a.x - b.x;
+            const dy = a.y - b.y;
+            return dx * dx + dy * dy;
+          };
+
+          if (dist2(topBase[0], leftHit.point) > dist2(topBase[0], rightHit.point)) {
+            topBase = topBase.slice().reverse();
+          }
+
+          topBase = topBase.slice();
+          topBase[0] = leftHit.point;
+          topBase[topBase.length - 1] = rightHit.point;
+
+          const capShiftY = f.operation === "subtract" ? -Math.max(overlap * 2, delta) : overlap;
+          const topPoints = topBase.map(
+            (p) => p.add(new paper.Point(0, capShiftY)),
+          );
+
+          const bridgeBottomY = bridgeBottom + overlap * 2;
+          const bridgePoly = new paper.Path({ insert: false });
+          for (const p of topPoints) bridgePoly.add(p);
+          bridgePoly.add(new paper.Point(xRight, bridgeBottomY));
+          bridgePoly.add(new paper.Point(xLeft, bridgeBottomY));
+          bridgePoly.closed = true;
+
+          const unitedItem = item.unite(bridgePoly);
+          item.remove();
+          bridgePoly.remove();
+
+          if (f.operation === "add") {
+            adds.push(unitedItem);
+          } else {
+            subtracts.push(unitedItem);
+          }
+        } else {
+          if (f.operation === "add") {
+            adds.push(item);
           } else {
-           if (f.operation === "add") {
-              adds.push(item);
-           } else {
-              subtracts.push(item);
-           }
+            subtracts.push(item);
+          }
         }
       } else {
         if (f.operation === "add") {
@@ -280,7 +438,7 @@ function getPerimeterShape(options: GeometryOptions): paper.PathItem {
           const temp = mainShape.unite(item);
           mainShape.remove();
           item.remove();
-          mainShape = temp;
+          mainShape = normalizePathItem(temp);
         } catch (e) {
           console.error("Geometry: Failed to unite feature", e);
           item.remove();
@@ -295,7 +453,7 @@ function getPerimeterShape(options: GeometryOptions): paper.PathItem {
           const temp = mainShape.subtract(item);
           mainShape.remove();
           item.remove();
-          mainShape = temp;
+          mainShape = normalizePathItem(temp);
         } catch (e) {
           console.error("Geometry: Failed to subtract feature", e);
           item.remove();
@@ -336,12 +494,12 @@ function applySurfaceFeatures(
         const temp = result.unite(item);
         result.remove();
         item.remove();
-        result = temp;
+        result = normalizePathItem(temp);
       } else {
         const temp = result.subtract(item);
         result.remove();
         item.remove();
-        result = temp;
+        result = normalizePathItem(temp);
       }
     } catch (e) {
       console.error("Geometry: Failed to apply surface feature", e);