calculate-packing 0.0.36 → 0.0.37

package/dist/index.d.ts

@@ -390,11 +390,6 @@ declare class OutlineSegmentCandidatePointSolver extends BaseSolver {
      * Adjust position to avoid component bounds crossing to the inside of the outline
      */
     private adjustPositionForOutlineCollision;
-    /**
-     * Get the outward normal for the current segment by determining which side
-     * is farther from the outline centroid
-     */
-    private getOutwardNormal;
     visualize(): GraphicsObject;
 }
 

package/dist/index.js

@@ -966,6 +966,89 @@ function pointInOutline(p, segments, rule = "even-odd") {
   }
 }
 
+// lib/OutlineSegmentCandidatePointSolver/getOutwardNormal.ts
+function getOutwardNormal(outlineSegment, fullOutline) {
+  const [p1, p2] = outlineSegment;
+  const dx = p2.x - p1.x;
+  const dy = p2.y - p1.y;
+  const len = Math.hypot(dx, dy);
+  if (len === 0) {
+    return { x: 0, y: 1 };
+  }
+  const dirX = dx / len;
+  const dirY = dy / len;
+  const left = { x: -dirY, y: dirX };
+  const right = { x: dirY, y: -dirX };
+  const mid = {
+    x: (p1.x + p2.x) / 2,
+    y: (p1.y + p2.y) / 2
+  };
+  const bbox = getOutlineBoundsWithMargin(fullOutline);
+  const scale = Math.max(bbox.maxX - bbox.minX, bbox.maxY - bbox.minY) || 1;
+  const testDistance = Math.max(1e-4, 1e-3 * scale);
+  const testLeft = {
+    x: mid.x + left.x * testDistance,
+    y: mid.y + left.y * testDistance
+  };
+  const testRight = {
+    x: mid.x + right.x * testDistance,
+    y: mid.y + right.y * testDistance
+  };
+  const locLeft = pointInOutline(testLeft, fullOutline);
+  if (locLeft === "outside") {
+    return left;
+  }
+  const locRight = pointInOutline(testRight, fullOutline);
+  if (locRight === "outside") {
+    return right;
+  }
+  const verts = [];
+  if (fullOutline.length > 0) {
+    verts.push(fullOutline[0][0]);
+    for (const seg of fullOutline) {
+      verts.push(seg[1]);
+    }
+  }
+  const signedArea = (() => {
+    let a = 0;
+    for (let i = 0; i < verts.length; i++) {
+      const v1 = verts[i];
+      const v2 = verts[(i + 1) % verts.length];
+      a += v1.x * v2.y - v2.x * v1.y;
+    }
+    return a / 2;
+  })();
+  if (Math.abs(signedArea) > 1e-12) {
+    return signedArea > 0 ? right : left;
+  }
+  const center = {
+    x: (bbox.minX + bbox.maxX) / 2,
+    y: (bbox.minY + bbox.maxY) / 2
+  };
+  const away = { x: mid.x - center.x, y: mid.y - center.y };
+  const dotLeft = left.x * away.x + left.y * away.y;
+  const dotRight = right.x * away.x + right.y * away.y;
+  return dotRight >= dotLeft ? right : left;
+}
+function getOutlineBoundsWithMargin(fullOutline, margin = 0) {
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  for (const [p1, p2] of fullOutline) {
+    minX = Math.min(minX, p1.x, p2.x);
+    minY = Math.min(minY, p1.y, p2.y);
+    maxX = Math.max(maxX, p1.x, p2.x);
+    maxY = Math.max(maxY, p1.y, p2.y);
+  }
+  return {
+    minX: minX - margin,
+    minY: minY - margin,
+    maxX: maxX + margin,
+    maxY: maxY + margin
+  };
+}
+
 // lib/LargestRectOutsideOutlineFromPointSolver.ts
 var LargestRectOutsideOutlineFromPointSolver = class extends BaseSolver {
   fullOutline;
@@ -1356,7 +1439,10 @@ var OutlineSegmentCandidatePointSolver = class extends BaseSolver {
       );
       return this.adjustPositionForOutlineCollision(projectedPoint);
     };
-    const outwardNormal = this.getOutwardNormal();
+    const outwardNormal = getOutwardNormal(
+      this.outlineSegment,
+      this.fullOutline
+    );
     const componentBounds = getInputComponentBounds(this.componentToPack, {
       rotationDegrees: this.componentRotationDegrees
     });
@@ -1556,7 +1642,10 @@ var OutlineSegmentCandidatePointSolver = class extends BaseSolver {
   adjustPositionForOutlineCollision(center) {
     const tempComponent = this.createTemporaryPackedComponent(center);
     const bounds = getComponentBounds(tempComponent, 0);
-    const outwardNormal = this.getOutwardNormal();
+    const outwardNormal = getOutwardNormal(
+      this.outlineSegment,
+      this.fullOutline
+    );
     const isHorizontalNormal = Math.abs(outwardNormal.x) > Math.abs(outwardNormal.y);
     const isVerticalNormal = !isHorizontalNormal;
     if (isHorizontalNormal) {
@@ -1591,45 +1680,6 @@ var OutlineSegmentCandidatePointSolver = class extends BaseSolver {
     }
     throw new Error("unreachable");
   }
-  /**
-   * Get the outward normal for the current segment by determining which side
-   * is farther from the outline centroid
-   */
-  getOutwardNormal() {
-    const [p1, p2] = this.outlineSegment;
-    const segmentX = p2.x - p1.x;
-    const segmentY = p2.y - p1.y;
-    const segmentLength = Math.hypot(segmentX, segmentY);
-    if (segmentLength === 0) {
-      return { x: 0, y: 1 };
-    }
-    const segmentDirX = segmentX / segmentLength;
-    const segmentDirY = segmentY / segmentLength;
-    const normal1X = -segmentDirY;
-    const normal1Y = segmentDirX;
-    const normal2X = segmentDirY;
-    const normal2Y = -segmentDirX;
-    const segmentMidpoint = {
-      x: (p1.x + p2.x) / 2,
-      y: (p1.y + p2.y) / 2
-    };
-    const testDistance = 1e-4;
-    const testPoint1 = {
-      x: segmentMidpoint.x + normal1X * testDistance,
-      y: segmentMidpoint.y + normal1Y * testDistance
-    };
-    const testPoint2 = {
-      x: segmentMidpoint.x + normal2X * testDistance,
-      y: segmentMidpoint.y + normal2Y * testDistance
-    };
-    if (pointInOutline(testPoint1, this.fullOutline) === "outside") {
-      return { x: normal1X, y: normal1Y };
-    }
-    if (pointInOutline(testPoint2, this.fullOutline) === "outside") {
-      return { x: normal2X, y: normal2Y };
-    }
-    throw new Error("No outward normal found");
-  }
   visualize() {
     const graphics = {
       lines: [],

package/package.json

@@ -2,7 +2,7 @@
   "name": "calculate-packing",
   "main": "dist/index.js",
   "type": "module",
-  "version": "0.0.36",
+  "version": "0.0.37",
   "description": "Calculate a packing layout with support for different strategy configurations",
   "scripts": {
     "start": "cosmos",