@tscircuit/curvy-trace-solver 0.0.8 → 0.0.10

package/dist/index.d.ts

@@ -39,6 +39,7 @@ declare class CurvyTraceSolver extends BaseSolver {
     private collisionPairs;
     private lastCost;
     private stagnantSteps;
+    private effectiveTraceToTraceSpacing;
     constructor(problem: CurvyTraceProblem);
     getConstructorParams(): CurvyTraceProblem;
     private precomputeObstacles;

package/dist/index.js

@@ -1071,6 +1071,8 @@ var CurvyTraceSolver = class extends BaseSolver {
   collisionPairs = [];
   lastCost = Infinity;
   stagnantSteps = 0;
+  // Relaxation: start with higher spacing and decay towards actual preferred value
+  effectiveTraceToTraceSpacing = 0;
   getConstructorParams() {
     return this.problem;
   }
@@ -1227,16 +1229,37 @@ var CurvyTraceSolver = class extends BaseSolver {
     );
   }
   // Update control points from perpendicular distances
+  // Ensures control points don't go backwards through the edge the waypoint is on
   updateControlPointsFromDistances(i) {
     const trace = this.traces[i];
-    trace.ctrl1.x = trace.waypointPair.start.x + trace.d1 * trace.perpDir1.x;
-    trace.ctrl1.y = trace.waypointPair.start.y + trace.d1 * trace.perpDir1.y;
-    trace.ctrl2.x = trace.waypointPair.end.x + trace.d2 * trace.perpDir2.x;
-    trace.ctrl2.y = trace.waypointPair.end.y + trace.d2 * trace.perpDir2.y;
+    const { minX, maxX, minY, maxY } = this.problem.bounds;
+    const eps = 1e-6;
+    let ctrl1x = trace.waypointPair.start.x + trace.d1 * trace.perpDir1.x;
+    let ctrl1y = trace.waypointPair.start.y + trace.d1 * trace.perpDir1.y;
+    let ctrl2x = trace.waypointPair.end.x + trace.d2 * trace.perpDir2.x;
+    let ctrl2y = trace.waypointPair.end.y + trace.d2 * trace.perpDir2.y;
+    const start = trace.waypointPair.start;
+    if (Math.abs(start.x - minX) < eps) ctrl1x = Math.max(ctrl1x, minX);
+    if (Math.abs(start.x - maxX) < eps) ctrl1x = Math.min(ctrl1x, maxX);
+    if (Math.abs(start.y - minY) < eps) ctrl1y = Math.max(ctrl1y, minY);
+    if (Math.abs(start.y - maxY) < eps) ctrl1y = Math.min(ctrl1y, maxY);
+    const end = trace.waypointPair.end;
+    if (Math.abs(end.x - minX) < eps) ctrl2x = Math.max(ctrl2x, minX);
+    if (Math.abs(end.x - maxX) < eps) ctrl2x = Math.min(ctrl2x, maxX);
+    if (Math.abs(end.y - minY) < eps) ctrl2y = Math.max(ctrl2y, minY);
+    if (Math.abs(end.y - maxY) < eps) ctrl2y = Math.min(ctrl2y, maxY);
+    ctrl1x = Math.max(minX, Math.min(maxX, ctrl1x));
+    ctrl1y = Math.max(minY, Math.min(maxY, ctrl1y));
+    ctrl2x = Math.max(minX, Math.min(maxX, ctrl2x));
+    ctrl2y = Math.max(minY, Math.min(maxY, ctrl2y));
+    trace.ctrl1.x = ctrl1x;
+    trace.ctrl1.y = ctrl1y;
+    trace.ctrl2.x = ctrl2x;
+    trace.ctrl2.y = ctrl2y;
   }
   // Determine which trace pairs could possibly collide based on bounding boxes
   updateCollisionPairs() {
-    const { preferredTraceToTraceSpacing: preferredSpacing } = this.problem;
+    const effectiveSpacing = this.effectiveTraceToTraceSpacing;
     this.collisionPairs = [];
     for (let i = 0; i < this.traces.length; i++) {
       for (let j = i + 1; j < this.traces.length; j++) {
@@ -1244,15 +1267,16 @@ var CurvyTraceSolver = class extends BaseSolver {
         if (ti.networkId && tj.networkId && ti.networkId === tj.networkId)
           continue;
         const bi = this.traceBounds[i], bj = this.traceBounds[j];
-        if (bi.maxX + preferredSpacing >= bj.minX && bj.maxX + preferredSpacing >= bi.minX && bi.maxY + preferredSpacing >= bj.minY && bj.maxY + preferredSpacing >= bi.minY) {
+        if (bi.maxX + effectiveSpacing >= bj.minX && bj.maxX + effectiveSpacing >= bi.minX && bi.maxY + effectiveSpacing >= bj.minY && bj.maxY + effectiveSpacing >= bi.minY) {
           this.collisionPairs.push([i, j]);
         }
       }
     }
   }
   computeTotalCost() {
-    const { preferredTraceToTraceSpacing, preferredObstacleToTraceSpacing } = this.problem;
-    const traceSpacingSq = preferredTraceToTraceSpacing ** 2;
+    const { preferredObstacleToTraceSpacing } = this.problem;
+    const effectiveSpacing = this.effectiveTraceToTraceSpacing;
+    const traceSpacingSq = effectiveSpacing ** 2;
     const obstacleSpacingSq = preferredObstacleToTraceSpacing ** 2;
     let cost = 0;
     for (const [i, j] of this.collisionPairs) {
@@ -1266,7 +1290,7 @@ var CurvyTraceSolver = class extends BaseSolver {
           const distSq = segmentDistSq(a1x, a1y, a2x, a2y, b1x, b1y, b2x, b2y);
           if (distSq < traceSpacingSq) {
             const dist = Math.sqrt(distSq);
-            cost += (preferredTraceToTraceSpacing - dist) ** 2;
+            cost += (effectiveSpacing - dist) ** 2;
             if (distSq < 1e-18) cost += 20 * traceSpacingSq;
           }
         }
@@ -1303,8 +1327,9 @@ var CurvyTraceSolver = class extends BaseSolver {
     return cost;
   }
   computeCostForTrace(traceIdx) {
-    const { preferredTraceToTraceSpacing, preferredObstacleToTraceSpacing } = this.problem;
-    const traceSpacingSq = preferredTraceToTraceSpacing ** 2;
+    const { preferredObstacleToTraceSpacing } = this.problem;
+    const effectiveSpacing = this.effectiveTraceToTraceSpacing;
+    const traceSpacingSq = effectiveSpacing ** 2;
     const obstacleSpacingSq = preferredObstacleToTraceSpacing ** 2;
     const trace = this.traces[traceIdx];
     const pi = this.sampledPoints[traceIdx];
@@ -1316,7 +1341,7 @@ var CurvyTraceSolver = class extends BaseSolver {
       if (trace.networkId && other.networkId && trace.networkId === other.networkId)
         continue;
       const bj = this.traceBounds[j];
-      if (bi.maxX + preferredTraceToTraceSpacing < bj.minX || bj.maxX + preferredTraceToTraceSpacing < bi.minX || bi.maxY + preferredTraceToTraceSpacing < bj.minY || bj.maxY + preferredTraceToTraceSpacing < bi.minY)
+      if (bi.maxX + effectiveSpacing < bj.minX || bj.maxX + effectiveSpacing < bi.minX || bi.maxY + effectiveSpacing < bj.minY || bj.maxY + effectiveSpacing < bi.minY)
         continue;
       const pj = this.sampledPoints[j];
       for (let a = 0; a < OPT_SAMPLES; a++) {
@@ -1328,7 +1353,7 @@ var CurvyTraceSolver = class extends BaseSolver {
           const distSq = segmentDistSq(a1x, a1y, a2x, a2y, b1x, b1y, b2x, b2y);
           if (distSq < traceSpacingSq) {
             const dist = Math.sqrt(distSq);
-            cost += (preferredTraceToTraceSpacing - dist) ** 2;
+            cost += (effectiveSpacing - dist) ** 2;
             if (distSq < 1e-18) cost += 20 * traceSpacingSq;
           }
         }
@@ -1559,9 +1584,10 @@ var CurvyTraceSolver = class extends BaseSolver {
     return resolved;
   }
   optimizeStep() {
-    const { bounds, preferredTraceToTraceSpacing } = this.problem;
+    const { bounds } = this.problem;
     const { minX, maxX, minY, maxY } = bounds;
     const minDim = Math.min(maxX - minX, maxY - minY);
+    const effectiveSpacing = this.effectiveTraceToTraceSpacing;
     const progress = this.optimizationStep / this.maxOptimizationSteps;
     const baseStep = 4 * (1 - progress) + 0.5;
     const minDist = minDim * 0.02;
@@ -1575,7 +1601,11 @@ var CurvyTraceSolver = class extends BaseSolver {
       if (currentCost === 0) continue;
       const trace = this.traces[i];
       const costMultiplier = currentCost > 100 ? 2 : 1;
-      const steps = [baseStep * costMultiplier, baseStep * 1.5 * costMultiplier, baseStep * 0.5];
+      const steps = [
+        baseStep * costMultiplier,
+        baseStep * 1.5 * costMultiplier,
+        baseStep * 0.5
+      ];
       for (const step of steps) {
         const deltas = currentCost > 100 ? [
           step,
@@ -1584,8 +1614,8 @@ var CurvyTraceSolver = class extends BaseSolver {
           -step * 2,
           step * 3,
           -step * 3,
-          preferredTraceToTraceSpacing * 2,
-          -preferredTraceToTraceSpacing * 2
+          effectiveSpacing * 2,
+          -effectiveSpacing * 2
         ] : [step, -step, step * 2, -step * 2];
         let bestCost = this.computeCostForTrace(i);
         let bestD1 = trace.d1;
@@ -1668,11 +1698,17 @@ var CurvyTraceSolver = class extends BaseSolver {
   }
   _step() {
     if (this.traces.length === 0) {
+      this.effectiveTraceToTraceSpacing = this.problem.preferredTraceToTraceSpacing * 3;
       this.initializeTraces();
       this.lastCost = this.computeTotalCost();
       this.stagnantSteps = 0;
     }
     if (this.optimizationStep < this.maxOptimizationSteps) {
+      const progress = this.optimizationStep / this.maxOptimizationSteps;
+      const startMultiplier = 3;
+      const endMultiplier = 1;
+      const currentMultiplier = startMultiplier + (endMultiplier - startMultiplier) * progress;
+      this.effectiveTraceToTraceSpacing = this.problem.preferredTraceToTraceSpacing * currentMultiplier;
       this.optimizeStep();
       this.optimizationStep++;
       if (this.optimizationStep % 10 === 0) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tscircuit/curvy-trace-solver",
   "main": "dist/index.js",
-  "version": "0.0.8",
+  "version": "0.0.10",
   "type": "module",
   "scripts": {
     "start": "cosmos",