calculate-packing 0.0.49 → 0.0.51

package/README.md

@@ -3,6 +3,8 @@
 **calculate-packing** is a small TypeScript library that ships the placement /
 packing algorithm used by the [tscircuit tool-chain](https://github.com/tscircuit/tscircuit) for automatically laying out PCB components.
 
+[Paste PackInput and Debug Online](https://calculate-packing.tscircuit.com/?fixture=%7B%22path%22%3A%22site%2Fpack%2Fpack-debugger-from-input.page.tsx%22%7D)
+
 The solver turns a user-supplied `PackInput` (components, pads & strategy
 settings) into a collision-free `PackOutput` while
 

package/dist/index.js

@@ -2519,6 +2519,38 @@ gap_distance=${candidate.gapDistance}`,
 
 // lib/PackSolver2/PackSolver2.ts
 import { computeDistanceBetweenBoxes as computeDistanceBetweenBoxes3 } from "@tscircuit/math-utils";
+
+// lib/math/getPolygonCentroid.ts
+function getPolygonCentroid(points) {
+  if (points.length < 3) {
+    const sumX = points.reduce((sum, p) => sum + p.x, 0);
+    const sumY = points.reduce((sum, p) => sum + p.y, 0);
+    return { x: sumX / points.length, y: sumY / points.length };
+  }
+  let signedArea = 0;
+  let cx = 0;
+  let cy = 0;
+  for (let i = 0; i < points.length; i++) {
+    const p1 = points[i];
+    const p2 = points[(i + 1) % points.length];
+    const crossProduct = p1.x * p2.y - p2.x * p1.y;
+    signedArea += crossProduct;
+    cx += (p1.x + p2.x) * crossProduct;
+    cy += (p1.y + p2.y) * crossProduct;
+  }
+  signedArea *= 0.5;
+  const area = Math.abs(signedArea);
+  if (area < 1e-10) {
+    const sumX = points.reduce((sum, p) => sum + p.x, 0);
+    const sumY = points.reduce((sum, p) => sum + p.y, 0);
+    return { x: sumX / points.length, y: sumY / points.length };
+  }
+  cx /= 6 * signedArea;
+  cy /= 6 * signedArea;
+  return { x: cx, y: cy };
+}
+
+// lib/PackSolver2/PackSolver2.ts
 var PackSolver2 = class extends BaseSolver {
   packInput;
   unpackedComponentQueue = [];
@@ -2542,9 +2574,13 @@ var PackSolver2 = class extends BaseSolver {
   }
   packFirstComponent() {
     const firstComponentToPack = this.unpackedComponentQueue.shift();
+    let initialPosition = { x: 0, y: 0 };
+    if (this.packInput.boundaryOutline && this.packInput.boundaryOutline.length >= 3) {
+      initialPosition = getPolygonCentroid(this.packInput.boundaryOutline);
+    }
     const newPackedComponent = {
       ...firstComponentToPack,
-      center: { x: 0, y: 0 },
+      center: initialPosition,
       ccwRotationOffset: 0,
       pads: firstComponentToPack.pads.map((p) => ({
         ...p,
@@ -2569,7 +2605,23 @@ var PackSolver2 = class extends BaseSolver {
         return distance + 1e-6 < this.packInput.minGap;
       });
     });
-    if (!tooCloseToObstacles) {
+    let outsideBoundaryOutline = false;
+    if (this.packInput.boundaryOutline && this.packInput.boundaryOutline.length >= 3) {
+      const componentBounds = getComponentBounds(newPackedComponent, 0);
+      const allPadsInside = newPackedComponent.pads.every(
+        (pad) => isPointInPolygon(pad.absoluteCenter, this.packInput.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.packInput.boundaryOutline)
+      );
+      outsideBoundaryOutline = !allPadsInside || !cornersInside;
+    }
+    if (!tooCloseToObstacles && !outsideBoundaryOutline) {
       this.packedComponents.push(newPackedComponent);
       return;
     }

package/package.json

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