calculate-packing 0.0.27 → 0.0.28

package/dist/index.d.ts

@@ -233,6 +233,9 @@ interface Point {
     x: number;
     y: number;
 }
+interface PointWithNetworkId extends Point {
+    networkId?: string;
+}
 interface OffsetPadPoint {
     id: string;
     offsetX: number;
@@ -265,7 +268,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 +408,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;
   }
 };
 
@@ -2451,7 +2456,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 +2734,7 @@ var SingleComponentPackSolver = class extends BaseSolver {
   currentRotationIndex = 0;
   activeSubSolver = null;
   candidateResults = [];
+  rejectedCandidates = [];
   bestCandidate;
   outputPackedComponent;
   constructor(params) {
@@ -2804,13 +2813,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 +3001,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.28",
   "description": "Calculate a packing layout with support for different strategy configurations",
   "scripts": {
     "start": "cosmos",