@pooder/kit 4.3.0 → 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,91 +298,129 @@ function getPerimeterShape(options: GeometryOptions): paper.PathItem {
         const bridgeBottom = itemBounds.top;
 
         if (bridgeBottom > bridgeTop) {
-          // 1. Create a full column up to the top of the main shape
-          // Start slightly inside the feature to ensure overlap at the bottom
-          const startY = bridgeBottom + 1; 
-          const bridgeRect = new paper.Path.Rectangle({
-            from: [itemBounds.left, bridgeTop],
-            to: [itemBounds.right, startY],
-            insert: false,
+          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");
+          }
 
-          // 2. Subtract the main shape from this column
-          // This leaves us with the parts of the column that are NOT inside the main shape (gaps)
-          const gaps = bridgeRect.subtract(mainShape);
-          bridgeRect.remove();
+          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");
+          }
 
-          // 3. Find the gap piece that connects to our feature
-          // It should be the piece with the lowest bottom (highest Y) matching our feature top
-          let bridgePart: paper.PathItem | null = null;
+          let topBase = selectOuterChain({
+            mainShape,
+            pointsA,
+            pointsB,
+            delta,
+            overlap,
+            op: f.operation,
+          });
 
-          // Helper to check if a part is the bottom one
-          const isBottomPart = (part: paper.PathItem) => {
-             // Check if bottom aligns with feature top (allow small tolerance)
-             return Math.abs(part.bounds.bottom - startY) < 2; 
+          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 (gaps instanceof paper.CompoundPath) {
-             // Find the child that is at the bottom
-             const children = gaps.children;
-             let maxBottom = -Infinity;
-             let bestChild = null;
-             
-             for (const child of children) {
-                if (child.bounds.bottom > maxBottom) {
-                   maxBottom = child.bounds.bottom;
-                   bestChild = child;
-                }
-             }
-             
-             if (bestChild && isBottomPart(bestChild as paper.PathItem)) {
-                bridgePart = (bestChild as paper.PathItem).clone();
-             }
-          } else if (gaps instanceof paper.Path) {
-             if (isBottomPart(gaps)) {
-                bridgePart = gaps.clone();
-             }
+          if (dist2(topBase[0], leftHit.point) > dist2(topBase[0], rightHit.point)) {
+            topBase = topBase.slice().reverse();
           }
-          
-          gaps.remove();
-
-          if (bridgePart) {
-              // Overlap fix:
-              // Scale the bridge up slightly from the bottom to ensure it overlaps with the main shape at the top.
-              // This prevents hairline gaps due to perfect alignment from subtract().
-              const bounds = bridgePart.bounds;
-              if (bounds.height > 0) {
-                 const overlap = 1; 
-                 const scaleY = (bounds.height + overlap) / bounds.height;
-                 // Scale around the bottom-center to keep the connection to the feature intact
-                 bridgePart.scale(1, scaleY, new paper.Point(bounds.center.x, bounds.bottom));
-              }
-
-              // Unite the bridge with the feature
-              const unitedItem = item.unite(bridgePart);
-              item.remove();
-              bridgePart.remove();
-              
-              if (f.operation === "add") {
-                adds.push(unitedItem);
-              } else {
-                subtracts.push(unitedItem);
-              }
-           } else {
-             // No bridge needed (feature touches or intersects main shape directly)
-             // or calculation failed. Fallback to original item.
-             if (f.operation === "add") {
-               adds.push(item);
-             } else {
-               subtracts.push(item);
-             }
+
+          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 {
-              subtracts.push(item);
-           }
+          if (f.operation === "add") {
+            adds.push(item);
+          } else {
+            subtracts.push(item);
+          }
         }
       } else {
         if (f.operation === "add") {
@@ -284,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();
@@ -299,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();
@@ -340,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);