calculate-packing 0.0.46 → 0.0.48

package/dist/index.d.ts

@@ -409,6 +409,7 @@ declare class OutlineSegmentCandidatePointSolver extends BaseSolver {
     private createTemporaryPackedComponent;
     /**
      * Adjust position to avoid component bounds crossing to the inside of the outline
+     * and ensure the component stays within the boundary outline
      */
     private adjustPositionForOutlineCollision;
     visualize(): GraphicsObject;

package/dist/index.js

@@ -1403,6 +1403,26 @@ function normalizeVector(direction) {
   };
 }
 
+// lib/math/isPointInPolygon.ts
+function isPointInPolygon(point, polygon) {
+  if (polygon.length < 3) return false;
+  let inside = false;
+  const n = polygon.length;
+  const poly = [...polygon];
+  if (poly[0].x !== poly[n - 1].x || poly[0].y !== poly[n - 1].y) {
+    poly.push({ ...poly[0] });
+  }
+  for (let i = 0, j = poly.length - 1; i < poly.length; j = i++) {
+    const xi = poly[i].x;
+    const yi = poly[i].y;
+    const xj = poly[j].x;
+    const yj = poly[j].y;
+    const intersect = yi > point.y !== yj > point.y && point.x < (xj - xi) * (point.y - yi) / (yj - yi) + xi;
+    if (intersect) inside = !inside;
+  }
+  return inside;
+}
+
 // lib/OutlineSegmentCandidatePointSolver/OutlineSegmentCandidatePointSolver.ts
 var OutlineSegmentCandidatePointSolver = class extends BaseSolver {
   outlineSegment;
@@ -1511,12 +1531,30 @@ var OutlineSegmentCandidatePointSolver = class extends BaseSolver {
         Math.sign(this.outlineSegment[1].y - this.outlineSegment[0].y)
       )
     };
-    const viableBounds = {
+    let viableBounds = {
       minX: largestRectBounds.minX - componentBounds.minX * segmentNormAbs.x,
       minY: largestRectBounds.minY - componentBounds.minY * segmentNormAbs.y,
       maxX: largestRectBounds.maxX - componentBounds.maxX * segmentNormAbs.x,
       maxY: largestRectBounds.maxY - componentBounds.maxY * segmentNormAbs.y
     };
+    if (this.boundaryOutline && this.boundaryOutline.length >= 3) {
+      let boundaryMinX = Infinity;
+      let boundaryMinY = Infinity;
+      let boundaryMaxX = -Infinity;
+      let boundaryMaxY = -Infinity;
+      for (const point of this.boundaryOutline) {
+        boundaryMinX = Math.min(boundaryMinX, point.x);
+        boundaryMinY = Math.min(boundaryMinY, point.y);
+        boundaryMaxX = Math.max(boundaryMaxX, point.x);
+        boundaryMaxY = Math.max(boundaryMaxY, point.y);
+      }
+      viableBounds = {
+        minX: Math.max(viableBounds.minX, boundaryMinX - componentBounds.minX),
+        minY: Math.max(viableBounds.minY, boundaryMinY - componentBounds.minY),
+        maxX: Math.min(viableBounds.maxX, boundaryMaxX - componentBounds.maxX),
+        maxY: Math.min(viableBounds.maxY, boundaryMaxY - componentBounds.maxY)
+      };
+    }
     this.viableBounds = viableBounds;
     const viableBoundsWidth = viableBounds.maxX - viableBounds.minX;
     const viableBoundsHeight = viableBounds.maxY - viableBounds.minY;
@@ -1676,6 +1714,7 @@ var OutlineSegmentCandidatePointSolver = class extends BaseSolver {
   }
   /**
    * Adjust position to avoid component bounds crossing to the inside of the outline
+   * and ensure the component stays within the boundary outline
    */
   adjustPositionForOutlineCollision(center) {
     const tempComponent = this.createTemporaryPackedComponent(center);
@@ -1686,37 +1725,66 @@ var OutlineSegmentCandidatePointSolver = class extends BaseSolver {
     );
     const isHorizontalNormal = Math.abs(outwardNormal.x) > Math.abs(outwardNormal.y);
     const isVerticalNormal = !isHorizontalNormal;
+    let adjustedCenter = center;
     if (isHorizontalNormal) {
       const isXPlusFacing = outwardNormal.x > 0;
       const isXMinusFacing = !isXPlusFacing;
       if (isXPlusFacing) {
-        return {
+        adjustedCenter = {
           x: bounds.maxX,
           y: center.y
         };
       } else if (isXMinusFacing) {
-        return {
+        adjustedCenter = {
           x: bounds.minX,
           y: center.y
         };
       }
-    }
-    if (isVerticalNormal) {
+    } else if (isVerticalNormal) {
       const isYPlusFacing = outwardNormal.y > 0;
       const isYMinusFacing = !isYPlusFacing;
       if (isYPlusFacing) {
-        return {
+        adjustedCenter = {
           x: center.x,
           y: bounds.maxY
         };
       } else if (isYMinusFacing) {
-        return {
+        adjustedCenter = {
           x: center.x,
           y: bounds.minY
         };
       }
     }
-    throw new Error("unreachable");
+    if (this.boundaryOutline && this.boundaryOutline.length >= 3) {
+      const adjustedComponent = this.createTemporaryPackedComponent(adjustedCenter);
+      const adjustedBounds = getComponentBounds(adjustedComponent, 0);
+      const allPadsInside = adjustedComponent.pads.every(
+        (pad) => isPointInPolygon(pad.absoluteCenter, this.boundaryOutline)
+      );
+      const cornersInside = [
+        { x: adjustedBounds.minX, y: adjustedBounds.minY },
+        { x: adjustedBounds.minX, y: adjustedBounds.maxY },
+        { x: adjustedBounds.maxX, y: adjustedBounds.minY },
+        { x: adjustedBounds.maxX, y: adjustedBounds.maxY }
+      ].every((corner) => isPointInPolygon(corner, this.boundaryOutline));
+      if (!allPadsInside || !cornersInside) {
+        if (this.viableBounds) {
+          adjustedCenter = {
+            x: clamp(
+              adjustedCenter.x,
+              this.viableBounds.minX,
+              this.viableBounds.maxX
+            ),
+            y: clamp(
+              adjustedCenter.y,
+              this.viableBounds.minY,
+              this.viableBounds.maxY
+            )
+          };
+        }
+      }
+    }
+    return adjustedCenter;
   }
   visualize() {
     const graphics = {
@@ -2128,6 +2196,20 @@ var SingleComponentPackSolver = class extends BaseSolver {
             return distance2 + 1e-6 < this.minGap;
           });
         });
+        let outsideBoundaryOutline = false;
+        if (this.boundaryOutline && this.boundaryOutline.length >= 3) {
+          const componentBounds = getComponentBounds(candidateComponent, 0);
+          const allPadsInside = candidateComponent.pads.every(
+            (pad) => isPointInPolygon(pad.absoluteCenter, this.boundaryOutline)
+          );
+          const cornersInside = [
+            { x: componentBounds.minX, y: componentBounds.minY },
+            { x: componentBounds.minX, y: componentBounds.maxY },
+            { x: componentBounds.maxX, y: componentBounds.minY },
+            { x: componentBounds.maxX, y: componentBounds.maxY }
+          ].every((corner) => isPointInPolygon(corner, this.boundaryOutline));
+          outsideBoundaryOutline = !allPadsInside || !cornersInside;
+        }
         distance = this.calculateDistance(optimalPosition, rotation);
         if (hasOverlap) {
           this.rejectedCandidates.push({
@@ -2149,6 +2231,17 @@ var SingleComponentPackSolver = class extends BaseSolver {
             rotationIndex: this.currentRotationIndex,
             gapDistance: minObstacleGapDistance
           });
+        } else if (outsideBoundaryOutline) {
+          this.rejectedCandidates.push({
+            segment: queuedSegment.segment,
+            rotation,
+            optimalPosition,
+            distance,
+            segmentIndex: queuedSegment.segmentIndex,
+            rotationIndex: this.currentRotationIndex,
+            gapDistance: -1
+            // Special marker for boundary violation
+          });
         } else {
           this.candidateResults.push({
             segment: queuedSegment.segment,
@@ -2853,6 +2946,12 @@ var convertCircuitJsonToPackOutput = (circuitJson, opts = {}) => {
   });
   const db = cju(circuitJson);
   let unnamedCounter = 0;
+  const pcbBoard = circuitJson.find(
+    (item) => item.type === "pcb_board"
+  );
+  if (pcbBoard && pcbBoard.outline) {
+    packOutput.boundaryOutline = pcbBoard.outline;
+  }
   const getNetworkId = (pcbPortId) => {
     if (pcbPortId) {
       const pcbPort = db.pcb_port.get(pcbPortId);

package/package.json

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