@tscircuit/capacity-autorouter 0.0.64 → 0.0.66

package/README.md

@@ -6,6 +6,12 @@ An MIT-licensed full-pipeline PCB autorouter library for node.js and TypeScript
 
 Check out this [short youtube explanation of this autorouter](https://youtu.be/MmTk0806fAo)
 
+## How to file a bug report
+
+1. You should have [created a bug report via the tscircuit errors tab](https://docs.tscircuit.com/contributing/report-autorouter-bugs)
+2. Run `bun run bug-report <bug-report-url>`
+3. This will download the bug report and create a debugging fixture file in the `examples/bug-reports` directory, you can then find the bug report in the server (via `bun run start`)
+
 ## Installation
 
 ```bash

package/dist/index.d.ts

@@ -420,6 +420,8 @@ interface HighDensityHyperParameters {
     FLIP_TRACE_ALIGNMENT_DIRECTION: boolean;
     MULTI_HEAD_POLYLINE_SOLVER: boolean;
     SEGMENTS_PER_POLYLINE: number;
+    BOUNDARY_PADDING: number;
+    ITERATION_PENALTY: number;
 }
 
 type Node = {
@@ -754,10 +756,17 @@ declare class HyperSingleIntraNodeSolver extends HyperParameterSupervisorSolver<
         })[];
     } | {
         name: string;
-        possibleValues: {
+        possibleValues: ({
             MULTI_HEAD_POLYLINE_SOLVER: boolean;
             SEGMENTS_PER_POLYLINE: number;
-        }[];
+            BOUNDARY_PADDING: number;
+            ITERATION_PENALTY?: undefined;
+        } | {
+            MULTI_HEAD_POLYLINE_SOLVER: boolean;
+            SEGMENTS_PER_POLYLINE: number;
+            BOUNDARY_PADDING: number;
+            ITERATION_PENALTY: number;
+        })[];
     })[];
     computeG(solver: IntraNodeRouteSolver): number;
     computeH(solver: IntraNodeRouteSolver): number;

package/dist/index.js

@@ -7434,6 +7434,7 @@ var MultiHeadPolyLineIntraNodeSolver = class extends BaseSolver {
   traceWidth = 0.15;
   availableZ = [];
   uniqueConnections = 0;
+  BOUNDARY_PADDING;
   lastCandidate = null;
   maxViaCount;
   minViaCount;
@@ -7446,6 +7447,7 @@ var MultiHeadPolyLineIntraNodeSolver = class extends BaseSolver {
     this.colorMap = params.colorMap ?? generateColorMapFromNodeWithPortPoints(params.nodeWithPortPoints);
     this.hyperParameters = params.hyperParameters ?? {};
     this.SEGMENTS_PER_POLYLINE = params.hyperParameters?.SEGMENTS_PER_POLYLINE ?? 3;
+    this.BOUNDARY_PADDING = params.hyperParameters?.BOUNDARY_PADDING ?? 0.05;
     this.connMap = params.connMap;
     this.cellSize = this.nodeWithPortPoints.width / 1024;
     this.candidates = [];
@@ -7792,33 +7794,71 @@ var MultiHeadPolyLineIntraNodeSolver = class extends BaseSolver {
                 const fy = dy / dist * forceMag;
                 const sourceIdSeg2 = `seg:${j}:${seg2.p1Idx}:${seg2.p2Idx}`;
                 const sourceIdSeg1 = `seg:${i}:${seg1.p1Idx}:${seg1.p2Idx}`;
-                addForceContribution(
-                  i,
+                const endpointForce = (ep, epIdx, otherSeg, targetLine, oppLine, srcIdOpp, srcIdThis) => {
+                  const cp = pointToSegmentClosestPoint(
+                    ep,
+                    otherSeg.p1,
+                    otherSeg.p2
+                  );
+                  const dx2 = ep.x - cp.x;
+                  const dy2 = ep.y - cp.y;
+                  const dSq2 = dx2 * dx2 + dy2 * dy2;
+                  if (dSq2 <= EPSILON4) return;
+                  const dist2 = Math.sqrt(dSq2);
+                  const mag = SEGMENT_FORCE_MULTIPLIER * FORCE_MAGNITUDE * Math.exp(-FORCE_DECAY_RATE * dist2);
+                  const fx2 = dx2 / dist2 * mag;
+                  const fy2 = dy2 / dist2 * mag;
+                  addForceContribution(targetLine, epIdx, srcIdOpp, fx2, fy2);
+                  addForceContribution(
+                    oppLine,
+                    otherSeg.p1Idx,
+                    srcIdThis,
+                    -fx2 / 2,
+                    -fy2 / 2
+                  );
+                  addForceContribution(
+                    oppLine,
+                    otherSeg.p2Idx,
+                    srcIdThis,
+                    -fx2 / 2,
+                    -fy2 / 2
+                  );
+                };
+                endpointForce(
+                  seg1.p1,
                   seg1.p1Idx,
+                  seg2,
+                  i,
+                  j,
                   sourceIdSeg2,
-                  fx / 2,
-                  fy / 2
+                  sourceIdSeg1
                 );
-                addForceContribution(
-                  i,
+                endpointForce(
+                  seg1.p2,
                   seg1.p2Idx,
+                  seg2,
+                  i,
+                  j,
                   sourceIdSeg2,
-                  fx / 2,
-                  fy / 2
+                  sourceIdSeg1
                 );
-                addForceContribution(
-                  j,
+                endpointForce(
+                  seg2.p1,
                   seg2.p1Idx,
+                  seg1,
+                  j,
+                  i,
                   sourceIdSeg1,
-                  -fx / 2,
-                  -fy / 2
+                  sourceIdSeg2
                 );
-                addForceContribution(
-                  j,
+                endpointForce(
+                  seg2.p2,
                   seg2.p2Idx,
+                  seg1,
+                  j,
+                  i,
                   sourceIdSeg1,
-                  -fx / 2,
-                  -fy / 2
+                  sourceIdSeg2
                 );
               }
             }
@@ -8046,7 +8086,8 @@ var MultiHeadPolyLineIntraNodeSolver = class extends BaseSolver {
           const radius = this.viaDiameter / 2;
           let boundaryForceX = 0;
           let boundaryForceY = 0;
-          const forceMargin = this.viaDiameter / 2;
+          const baseForceMargin = this.viaDiameter / 2;
+          const forceMargin = baseForceMargin + this.BOUNDARY_PADDING;
           const minX = this.bounds.minX + forceMargin;
           const maxX = this.bounds.maxX - forceMargin;
           const minY = this.bounds.minY + forceMargin;
@@ -8070,7 +8111,8 @@ var MultiHeadPolyLineIntraNodeSolver = class extends BaseSolver {
           newX = mPoint.x + netForce.fx;
           newY = mPoint.y + netForce.fy;
         } else {
-          const padding = this.traceWidth / 2;
+          const basePadding = this.traceWidth / 2;
+          const padding = basePadding + this.BOUNDARY_PADDING;
           newX = Math.max(
             this.bounds.minX + padding,
             Math.min(this.bounds.maxX - padding, newX)
@@ -8115,8 +8157,8 @@ var MultiHeadPolyLineIntraNodeSolver = class extends BaseSolver {
     );
     const allPointsWithinBounds = candidate.polyLines.every((polyLine) => {
       return polyLine.mPoints.every((mPoint) => {
-        const padding = (mPoint.z1 !== mPoint.z2 ? this.viaDiameter / 2 : 0) * // Forgiveness outside bounds
-        0.9;
+        const basePadding = mPoint.z1 !== mPoint.z2 ? this.viaDiameter / 2 : this.traceWidth / 2;
+        const padding = basePadding + this.BOUNDARY_PADDING;
         return withinBounds(mPoint, this.bounds, padding);
       });
     });
@@ -8429,6 +8471,20 @@ var MultiHeadPolyLineIntraNodeSolver2 = class extends MultiHeadPolyLineIntraNode
         netForces[lineIndex][mPointIndex].fy += fy;
       }
     };
+    const endpointForce = (ep, epIdx, otherSeg, targetLine, oppLine) => {
+      const cp = pointToSegmentClosestPoint(ep, otherSeg.p1, otherSeg.p2);
+      const dx = ep.x - cp.x;
+      const dy = ep.y - cp.y;
+      const dSq = dx * dx + dy * dy;
+      if (dSq <= EPSILON4) return;
+      const dist = Math.sqrt(dSq);
+      const mag = SEGMENT_FORCE_MULTIPLIER * FORCE_MAGNITUDE * Math.exp(-FORCE_DECAY_RATE * dist);
+      const fx = dx / dist * mag;
+      const fy = dy / dist * mag;
+      addNetForce(targetLine, epIdx, fx, fy);
+      addNetForce(oppLine, otherSeg.p1Idx, -fx / 2, -fy / 2);
+      addNetForce(oppLine, otherSeg.p2Idx, -fx / 2, -fy / 2);
+    };
     for (let i = 0; i < numPolyLines; i++) {
       for (let j = i + 1; j < numPolyLines; j++) {
         const polyLine1 = polyLines[i];
@@ -8474,28 +8530,10 @@ var MultiHeadPolyLineIntraNodeSolver2 = class extends MultiHeadPolyLineIntraNode
                 seg2.p1,
                 seg2.p2
               );
-              if (minDist < EPSILON4) continue;
-              const center1 = {
-                x: (seg1.p1.x + seg1.p2.x) / 2,
-                y: (seg1.p1.y + seg1.p2.y) / 2
-              };
-              const center2 = {
-                x: (seg2.p1.x + seg2.p2.x) / 2,
-                y: (seg2.p1.y + seg2.p2.y) / 2
-              };
-              const dx = center1.x - center2.x;
-              const dy = center1.y - center2.y;
-              const dSq = dx * dx + dy * dy;
-              if (dSq > EPSILON4) {
-                const dist = Math.sqrt(dSq);
-                const forceMag = SEGMENT_FORCE_MULTIPLIER * FORCE_MAGNITUDE * Math.exp(-FORCE_DECAY_RATE * dist);
-                const fx = dx / dist * forceMag;
-                const fy = dy / dist * forceMag;
-                addNetForce(i, seg1.p1Idx, fx / 2, fy / 2);
-                addNetForce(i, seg1.p2Idx, fx / 2, fy / 2);
-                addNetForce(j, seg2.p1Idx, -fx / 2, -fy / 2);
-                addNetForce(j, seg2.p2Idx, -fx / 2, -fy / 2);
-              }
+              endpointForce(seg1.p1, seg1.p1Idx, seg2, i, j);
+              endpointForce(seg1.p2, seg1.p2Idx, seg2, i, j);
+              endpointForce(seg2.p1, seg2.p1Idx, seg1, j, i);
+              endpointForce(seg2.p2, seg2.p2Idx, seg1, j, i);
             }
           }
         }
@@ -8646,7 +8684,8 @@ var MultiHeadPolyLineIntraNodeSolver2 = class extends MultiHeadPolyLineIntraNode
           const radius = this.viaDiameter / 2;
           let boundaryForceX = 0;
           let boundaryForceY = 0;
-          const forceMargin = this.viaDiameter / 2;
+          const baseForceMargin = this.viaDiameter / 2;
+          const forceMargin = baseForceMargin + this.BOUNDARY_PADDING;
           const minX = this.bounds.minX + forceMargin;
           const maxX = this.bounds.maxX - forceMargin;
           const minY = this.bounds.minY + forceMargin;
@@ -8670,7 +8709,8 @@ var MultiHeadPolyLineIntraNodeSolver2 = class extends MultiHeadPolyLineIntraNode
           newX = mPoint.x + currentForceX;
           newY = mPoint.y + currentForceY;
         } else {
-          const padding = this.traceWidth / 2;
+          const basePadding = this.traceWidth / 2;
+          const padding = basePadding + this.BOUNDARY_PADDING;
           newX = Math.max(
             this.bounds.minX + padding,
             Math.min(this.bounds.maxX - padding, newX)
@@ -9007,7 +9047,15 @@ var HyperSingleIntraNodeSolver = class extends HyperParameterSupervisorSolver {
         possibleValues: [
           {
             MULTI_HEAD_POLYLINE_SOLVER: true,
-            SEGMENTS_PER_POLYLINE: 6
+            SEGMENTS_PER_POLYLINE: 6,
+            BOUNDARY_PADDING: 0.05
+          },
+          {
+            MULTI_HEAD_POLYLINE_SOLVER: true,
+            SEGMENTS_PER_POLYLINE: 6,
+            BOUNDARY_PADDING: -0.05,
+            // Allow vias/traces outside the boundary
+            ITERATION_PENALTY: 1e4
           }
         ]
       }
@@ -9015,7 +9063,7 @@ var HyperSingleIntraNodeSolver = class extends HyperParameterSupervisorSolver {
   }
   computeG(solver) {
     if (solver?.hyperParameters?.MULTI_HEAD_POLYLINE_SOLVER) {
-      return 1e3 + solver.iterations / 1e4 + 1e4 * (solver.hyperParameters.SEGMENTS_PER_POLYLINE - 3);
+      return 1e3 + ((solver.hyperParameters?.ITERATION_PENALTY ?? 0) + solver.iterations) / 1e4 + 1e4 * (solver.hyperParameters.SEGMENTS_PER_POLYLINE - 3);
     }
     return solver.iterations / 1e4;
   }