calculate-packing 0.0.27 → 0.0.29

package/dist/index.d.ts

@@ -171,6 +171,7 @@ declare class PhasedPackSolver extends BaseSolver {
 
 declare const convertCircuitJsonToPackOutput: (circuitJson: CircuitJson, opts?: {
     source_group_id?: string;
+    shouldAddInnerObstacles?: boolean;
 }) => PackOutput;
 
 declare const getGraphicsFromPackOutput: (packOutput: PackOutput) => GraphicsObject;
@@ -233,6 +234,9 @@ interface Point {
     x: number;
     y: number;
 }
+interface PointWithNetworkId extends Point {
+    networkId?: string;
+}
 interface OffsetPadPoint {
     id: string;
     offsetX: number;
@@ -265,7 +269,7 @@ interface MultiOffsetIrlsSolverParams {
  */
 declare class MultiOffsetIrlsSolver extends BaseSolver {
     offsetPadPoints: OffsetPadPoint[];
-    targetPointMap: Map<string, Point[]>;
+    targetPointMap: Map<string, PointWithNetworkId[]>;
     currentPosition: Point;
     constraintFn?: (point: Point) => Point;
     epsilon: number;
@@ -405,6 +409,9 @@ declare class SingleComponentPackSolver extends BaseSolver {
     currentRotationIndex: number;
     activeSubSolver?: OutlineSegmentCandidatePointSolver | null;
     candidateResults: CandidateResult[];
+    rejectedCandidates: Array<CandidateResult & {
+        gapDistance: number;
+    }>;
     bestCandidate?: CandidateResult;
     outputPackedComponent?: PackedComponent;
     constructor(params: {

package/dist/index.js

@@ -23,12 +23,17 @@ function checkOverlapWithPackedComponents({
         newComponentPadBox,
         packedPadBox
       );
-      if (boxDist < minGap) {
-        return true;
+      if (boxDist + 1e-6 < minGap) {
+        return {
+          hasOverlap: true,
+          gapDistance: boxDist
+        };
       }
     }
   }
-  return false;
+  return {
+    hasOverlap: false
+  };
 }
 
 // lib/math/computeNearestPointOnSegmentForSegmentSet.ts
@@ -1408,7 +1413,7 @@ var PhasedPackSolver = class extends BaseSolver {
       component,
       packedComponents: this.packedComponents,
       minGap: this.packInput.minGap ?? 0
-    });
+    }).hasOverlap;
   }
 };
 
@@ -1552,7 +1557,7 @@ var extractPadInfos = (pcbComponent, db, getNetworkId) => {
 };
 
 // lib/plumbing/convertCircuitJsonToPackOutput.ts
-var buildPackedComponent = (pcbComponents, componentId, db, getNetworkId) => {
+var buildPackedComponent = (pcbComponents, componentId, db, getNetworkId, shouldAddInnerObstacles) => {
   const padInfos = pcbComponents.flatMap(
     (pc) => extractPadInfos(pc, db, getNetworkId)
   );
@@ -1578,6 +1583,17 @@ var buildPackedComponent = (pcbComponents, componentId, db, getNetworkId) => {
       y: p.absoluteCenter.y - center.y
     }
   }));
+  if (shouldAddInnerObstacles) {
+    const innerPad = {
+      padId: `${componentId}-inner`,
+      networkId: `${componentId}-inner`,
+      type: "rect",
+      size: { x: maxX - minX, y: maxY - minY },
+      absoluteCenter: center,
+      offset: { x: 0, y: 0 }
+    };
+    pads.push(innerPad);
+  }
   return {
     componentId,
     center,
@@ -1628,7 +1644,8 @@ var convertCircuitJsonToPackOutput = (circuitJson, opts = {}) => {
           [pcbComponent],
           pcbComponent.pcb_component_id,
           db,
-          getNetworkId
+          getNetworkId,
+          opts.shouldAddInnerObstacles
         )
       );
     } else if (node.nodeType === "group") {
@@ -2451,7 +2468,10 @@ var OutlineSegmentCandidatePointSolver = class extends BaseSolver {
       for (const packedComponent of this.packedComponents) {
         for (const packedPad of packedComponent.pads) {
           if (packedPad.networkId === pad.networkId) {
-            targetPoints.push(packedPad.absoluteCenter);
+            targetPoints.push({
+              ...packedPad.absoluteCenter,
+              networkId: packedPad.networkId
+            });
           }
         }
       }
@@ -2726,6 +2746,7 @@ var SingleComponentPackSolver = class extends BaseSolver {
   currentRotationIndex = 0;
   activeSubSolver = null;
   candidateResults = [];
+  rejectedCandidates = [];
   bestCandidate;
   outputPackedComponent;
   constructor(params) {
@@ -2804,13 +2825,23 @@ var SingleComponentPackSolver = class extends BaseSolver {
       let optimalPosition;
       if (this.activeSubSolver.solved && this.activeSubSolver.optimalPosition) {
         optimalPosition = this.activeSubSolver.optimalPosition;
-        const hasOverlap = checkOverlapWithPackedComponents({
+        const { hasOverlap, gapDistance } = checkOverlapWithPackedComponents({
           component: this.createPackedComponent(optimalPosition, rotation),
           packedComponents: this.packedComponents,
           minGap: this.minGap
         });
-        if (!hasOverlap) {
-          distance = this.calculateDistance(optimalPosition, rotation);
+        distance = this.calculateDistance(optimalPosition, rotation);
+        if (hasOverlap) {
+          this.rejectedCandidates.push({
+            segment: queuedSegment.segment,
+            rotation,
+            optimalPosition,
+            distance,
+            segmentIndex: queuedSegment.segmentIndex,
+            rotationIndex: this.currentRotationIndex,
+            gapDistance
+          });
+        } else {
           this.candidateResults.push({
             segment: queuedSegment.segment,
             rotation,
@@ -2982,16 +3013,26 @@ var SingleComponentPackSolver = class extends BaseSolver {
     this.visualizeOutlinePhase(graphics);
     for (let i = 0; i < this.candidateResults.length; i++) {
       const candidate = this.candidateResults[i];
-      if (candidate.optimalPosition) {
-        const step = i;
-        const isBest = step === 0;
-        graphics.points.push({
-          x: candidate.optimalPosition.x,
-          y: candidate.optimalPosition.y,
-          label: `step=${step}, d=${candidate.distance.toFixed(3)}`,
-          color: isBest ? "rgba(0,255,0,0.8)" : "rgba(255,165,0,0.6)"
-        });
-      }
+      if (!candidate.optimalPosition) continue;
+      const step = i;
+      const isBest = step === 0;
+      graphics.points.push({
+        x: candidate.optimalPosition.x,
+        y: candidate.optimalPosition.y,
+        label: `step=${step}, d=${candidate.distance.toFixed(3)}`,
+        color: isBest ? "rgba(0,255,0,0.8)" : "rgba(255,165,0,0.6)"
+      });
+    }
+    for (let i = 0; i < this.rejectedCandidates.length; i++) {
+      const candidate = this.rejectedCandidates[i];
+      if (!candidate.optimalPosition) continue;
+      graphics.points.push({
+        x: candidate.optimalPosition.x,
+        y: candidate.optimalPosition.y,
+        label: `rejected, d=${candidate.distance.toFixed(3)}
+gap_distance=${candidate.gapDistance}`,
+        color: "rgba(255,0,0,0.8)"
+      });
     }
     if (this.outputPackedComponent) {
       for (const pad of this.outputPackedComponent.pads) {

package/package.json

@@ -2,7 +2,7 @@
   "name": "calculate-packing",
   "main": "dist/index.js",
   "type": "module",
-  "version": "0.0.27",
+  "version": "0.0.29",
   "description": "Calculate a packing layout with support for different strategy configurations",
   "scripts": {
     "start": "cosmos",
@@ -19,7 +19,7 @@
     "@biomejs/biome": "^2.1.1",
     "@flatten-js/core": "^1.6.2",
     "@react-hook/resize-observer": "^2.0.2",
-    "@tscircuit/circuit-json-util": "^0.0.57",
+    "@tscircuit/circuit-json-util": "^0.0.66",
     "@tscircuit/footprinter": "^0.0.203",
     "@tscircuit/math-utils": "^0.0.19",
     "@types/bun": "latest",