@tscircuit/curvy-trace-solver 0.0.5 → 0.0.7

package/dist/index.d.ts

@@ -16,7 +16,8 @@ interface CurvyTraceProblem {
     bounds: Bounds;
     waypointPairs: WaypointPair[];
     obstacles: Obstacle[];
-    preferredSpacing: number;
+    preferredTraceToTraceSpacing: number;
+    preferredObstacleToTraceSpacing: number;
 }
 interface OutputTrace {
     waypointPair: WaypointPair;
@@ -44,6 +45,7 @@ declare class CurvyTraceSolver extends BaseSolver {
     private initializeTraces;
     private updateSampledTraces;
     private updateSingleTraceSample;
+    private updateControlPointsFromDistances;
     private updateCollisionPairs;
     private computeTotalCost;
     private computeCostForTrace;

package/dist/index.js

@@ -932,16 +932,27 @@ function getPerimeterT(p, bounds) {
   if (Math.abs(p.x - minX) < eps) return 2 * W + H + (p.y - minY);
   return 0;
 }
-function getPerimeterPoint(t, bounds) {
+function getInwardPerpendicular(p, bounds) {
   const { minX, maxX, minY, maxY } = bounds;
-  const W = maxX - minX;
-  const H = maxY - minY;
-  const perimeter = 2 * W + 2 * H;
-  t = (t % perimeter + perimeter) % perimeter;
-  if (t <= W) return { x: minX + t, y: maxY };
-  if (t <= W + H) return { x: maxX, y: maxY - (t - W) };
-  if (t <= 2 * W + H) return { x: maxX - (t - W - H), y: minY };
-  return { x: minX, y: minY + (t - 2 * W - H) };
+  const eps = 1e-6;
+  const onTop = Math.abs(p.y - maxY) < eps;
+  const onBottom = Math.abs(p.y - minY) < eps;
+  const onRight = Math.abs(p.x - maxX) < eps;
+  const onLeft = Math.abs(p.x - minX) < eps;
+  if (onTop && onRight) return { x: -Math.SQRT1_2, y: -Math.SQRT1_2 };
+  if (onTop && onLeft) return { x: Math.SQRT1_2, y: -Math.SQRT1_2 };
+  if (onBottom && onRight) return { x: -Math.SQRT1_2, y: Math.SQRT1_2 };
+  if (onBottom && onLeft) return { x: Math.SQRT1_2, y: Math.SQRT1_2 };
+  if (onTop) return { x: 0, y: -1 };
+  if (onBottom) return { x: 0, y: 1 };
+  if (onRight) return { x: -1, y: 0 };
+  if (onLeft) return { x: 1, y: 0 };
+  const cx = (minX + maxX) / 2;
+  const cy = (minY + maxY) / 2;
+  const dx = cx - p.x;
+  const dy = cy - p.y;
+  const len = Math.hypot(dx, dy);
+  return len > 0 ? { x: dx / len, y: dy / len } : { x: 0, y: -1 };
 }
 function sampleCubicBezierInline(p0x, p0y, p1x, p1y, p2x, p2y, p3x, p3y, points, numSamples) {
   for (let i = 0; i <= numSamples; i++) {
@@ -1103,21 +1114,14 @@ var CurvyTraceSolver = class extends BaseSolver {
     }
     const maxDepth = Math.max(...Array.from(nestingDepth.values()), 1);
     this.traces = tracesWithT.map(({ pair, t1, t2, idx }) => {
-      let dt = t2 - t1;
-      if (dt > perimeter / 2) dt -= perimeter;
-      if (dt < -perimeter / 2) dt += perimeter;
-      const tCtrl1 = t1 + dt * 0.33;
-      const tCtrl2 = t1 + dt * 0.67;
-      const pPerim1 = getPerimeterPoint(tCtrl1, bounds);
-      const pPerim2 = getPerimeterPoint(tCtrl2, bounds);
-      const pLinear1 = {
-        x: pair.start.x + (pair.end.x - pair.start.x) * 0.33,
-        y: pair.start.y + (pair.end.y - pair.start.y) * 0.33
-      };
-      const pLinear2 = {
-        x: pair.start.x + (pair.end.x - pair.start.x) * 0.67,
-        y: pair.start.y + (pair.end.y - pair.start.y) * 0.67
-      };
+      const perpDir1 = getInwardPerpendicular(pair.start, bounds);
+      const perpDir2 = getInwardPerpendicular(pair.end, bounds);
+      const chordLength = Math.hypot(
+        pair.end.x - pair.start.x,
+        pair.end.y - pair.start.y
+      );
+      const depth = nestingDepth.get(idx) || 0;
+      const normalizedDepth = depth / maxDepth;
       const midPoint = {
         x: (pair.start.x + pair.end.x) / 2,
         y: (pair.start.y + pair.end.y) / 2
@@ -1128,23 +1132,31 @@ var CurvyTraceSolver = class extends BaseSolver {
       );
       const maxDist = Math.hypot(W / 2, H / 2);
       const spatialDepth = 1 - distToCenter / maxDist;
-      const depth = nestingDepth.get(idx) || 0;
-      const normalizedDepth = depth / maxDepth;
-      const basePull = 0.3 + spatialDepth * 0.4;
-      const pullAmount = Math.max(0.05, basePull - normalizedDepth * 0.2);
+      const baseFactor = 0.25 + spatialDepth * 0.15;
+      const depthAdjustment = 1 - normalizedDepth * 0.3;
+      const initialDist = chordLength * baseFactor * depthAdjustment;
+      const minDist = Math.min(W, H) * 0.05;
+      const d1 = Math.max(minDist, initialDist);
+      const d2 = Math.max(minDist, initialDist);
+      const ctrl1 = {
+        x: pair.start.x + d1 * perpDir1.x,
+        y: pair.start.y + d1 * perpDir1.y
+      };
+      const ctrl2 = {
+        x: pair.end.x + d2 * perpDir2.x,
+        y: pair.end.y + d2 * perpDir2.y
+      };
       return {
         waypointPair: pair,
-        ctrl1: {
-          x: pLinear1.x * (1 - pullAmount) + pPerim1.x * pullAmount,
-          y: pLinear1.y * (1 - pullAmount) + pPerim1.y * pullAmount
-        },
-        ctrl2: {
-          x: pLinear2.x * (1 - pullAmount) + pPerim2.x * pullAmount,
-          y: pLinear2.y * (1 - pullAmount) + pPerim2.y * pullAmount
-        },
+        ctrl1,
+        ctrl2,
         networkId: pair.networkId,
         t1,
-        t2
+        t2,
+        perpDir1,
+        perpDir2,
+        d1,
+        d2
       };
     });
     this.sampledPoints = this.traces.map(
@@ -1199,9 +1211,17 @@ var CurvyTraceSolver = class extends BaseSolver {
       OPT_SAMPLES + 1
     );
   }
+  // Update control points from perpendicular distances
+  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;
+  }
   // Determine which trace pairs could possibly collide based on bounding boxes
   updateCollisionPairs() {
-    const { preferredSpacing } = this.problem;
+    const { preferredTraceToTraceSpacing: preferredSpacing } = this.problem;
     this.collisionPairs = [];
     for (let i = 0; i < this.traces.length; i++) {
       for (let j = i + 1; j < this.traces.length; j++) {
@@ -1216,8 +1236,9 @@ var CurvyTraceSolver = class extends BaseSolver {
     }
   }
   computeTotalCost() {
-    const { preferredSpacing } = this.problem;
-    const spacingSq = preferredSpacing * preferredSpacing;
+    const { preferredTraceToTraceSpacing, preferredObstacleToTraceSpacing } = this.problem;
+    const traceSpacingSq = preferredTraceToTraceSpacing ** 2;
+    const obstacleSpacingSq = preferredObstacleToTraceSpacing ** 2;
     let cost = 0;
     for (const [i, j] of this.collisionPairs) {
       const pi = this.sampledPoints[i], pj = this.sampledPoints[j];
@@ -1228,10 +1249,10 @@ var CurvyTraceSolver = class extends BaseSolver {
           const b1x = pj[b * 2], b1y = pj[b * 2 + 1];
           const b2x = pj[(b + 1) * 2], b2y = pj[(b + 1) * 2 + 1];
           const distSq = segmentDistSq(a1x, a1y, a2x, a2y, b1x, b1y, b2x, b2y);
-          if (distSq < spacingSq) {
+          if (distSq < traceSpacingSq) {
             const dist = Math.sqrt(distSq);
-            cost += (preferredSpacing - dist) ** 2;
-            if (distSq < 1e-18) cost += 20 * spacingSq;
+            cost += (preferredTraceToTraceSpacing - dist) ** 2;
+            if (distSq < 1e-18) cost += 20 * traceSpacingSq;
           }
         }
       }
@@ -1250,16 +1271,16 @@ var CurvyTraceSolver = class extends BaseSolver {
         const oy2 = this.obstacleSegments[obsBase + 3];
         const obsMinX = Math.min(ox1, ox2), obsMaxX = Math.max(ox1, ox2);
         const obsMinY = Math.min(oy1, oy2), obsMaxY = Math.max(oy1, oy2);
-        if (bi.maxX + preferredSpacing < obsMinX || obsMaxX + preferredSpacing < bi.minX || bi.maxY + preferredSpacing < obsMinY || obsMaxY + preferredSpacing < bi.minY)
+        if (bi.maxX + preferredObstacleToTraceSpacing < obsMinX || obsMaxX + preferredObstacleToTraceSpacing < bi.minX || bi.maxY + preferredObstacleToTraceSpacing < obsMinY || obsMaxY + preferredObstacleToTraceSpacing < bi.minY)
           continue;
         for (let a = 0; a < OPT_SAMPLES; a++) {
           const a1x = pi[a * 2], a1y = pi[a * 2 + 1];
           const a2x = pi[(a + 1) * 2], a2y = pi[(a + 1) * 2 + 1];
           const distSq = segmentDistSq(a1x, a1y, a2x, a2y, ox1, oy1, ox2, oy2);
-          if (distSq < spacingSq) {
+          if (distSq < obstacleSpacingSq) {
             const dist = Math.sqrt(distSq);
-            cost += (preferredSpacing - dist) ** 2;
-            if (distSq < 1e-18) cost += 20 * spacingSq;
+            cost += (preferredObstacleToTraceSpacing - dist) ** 2;
+            if (distSq < 1e-18) cost += 20 * obstacleSpacingSq;
           }
         }
       }
@@ -1267,8 +1288,9 @@ var CurvyTraceSolver = class extends BaseSolver {
     return cost;
   }
   computeCostForTrace(traceIdx) {
-    const { preferredSpacing } = this.problem;
-    const spacingSq = preferredSpacing * preferredSpacing;
+    const { preferredTraceToTraceSpacing, preferredObstacleToTraceSpacing } = this.problem;
+    const traceSpacingSq = preferredTraceToTraceSpacing ** 2;
+    const obstacleSpacingSq = preferredObstacleToTraceSpacing ** 2;
     const trace = this.traces[traceIdx];
     const pi = this.sampledPoints[traceIdx];
     const bi = this.traceBounds[traceIdx];
@@ -1279,7 +1301,7 @@ var CurvyTraceSolver = class extends BaseSolver {
       if (trace.networkId && other.networkId && trace.networkId === other.networkId)
         continue;
       const 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 + preferredTraceToTraceSpacing < bj.minX || bj.maxX + preferredTraceToTraceSpacing < bi.minX || bi.maxY + preferredTraceToTraceSpacing < bj.minY || bj.maxY + preferredTraceToTraceSpacing < bi.minY)
         continue;
       const pj = this.sampledPoints[j];
       for (let a = 0; a < OPT_SAMPLES; a++) {
@@ -1289,10 +1311,10 @@ var CurvyTraceSolver = class extends BaseSolver {
           const b1x = pj[b * 2], b1y = pj[b * 2 + 1];
           const b2x = pj[(b + 1) * 2], b2y = pj[(b + 1) * 2 + 1];
           const distSq = segmentDistSq(a1x, a1y, a2x, a2y, b1x, b1y, b2x, b2y);
-          if (distSq < spacingSq) {
+          if (distSq < traceSpacingSq) {
             const dist = Math.sqrt(distSq);
-            cost += (preferredSpacing - dist) ** 2;
-            if (distSq < 1e-18) cost += 20 * spacingSq;
+            cost += (preferredTraceToTraceSpacing - dist) ** 2;
+            if (distSq < 1e-18) cost += 20 * traceSpacingSq;
           }
         }
       }
@@ -1307,16 +1329,16 @@ var CurvyTraceSolver = class extends BaseSolver {
       const oy2 = this.obstacleSegments[obsBase + 3];
       const obsMinX = Math.min(ox1, ox2), obsMaxX = Math.max(ox1, ox2);
       const obsMinY = Math.min(oy1, oy2), obsMaxY = Math.max(oy1, oy2);
-      if (bi.maxX + preferredSpacing < obsMinX || obsMaxX + preferredSpacing < bi.minX || bi.maxY + preferredSpacing < obsMinY || obsMaxY + preferredSpacing < bi.minY)
+      if (bi.maxX + preferredObstacleToTraceSpacing < obsMinX || obsMaxX + preferredObstacleToTraceSpacing < bi.minX || bi.maxY + preferredObstacleToTraceSpacing < obsMinY || obsMaxY + preferredObstacleToTraceSpacing < bi.minY)
         continue;
       for (let a = 0; a < OPT_SAMPLES; a++) {
         const a1x = pi[a * 2], a1y = pi[a * 2 + 1];
         const a2x = pi[(a + 1) * 2], a2y = pi[(a + 1) * 2 + 1];
         const distSq = segmentDistSq(a1x, a1y, a2x, a2y, ox1, oy1, ox2, oy2);
-        if (distSq < spacingSq) {
+        if (distSq < obstacleSpacingSq) {
           const dist = Math.sqrt(distSq);
-          cost += (preferredSpacing - dist) ** 2;
-          if (distSq < 1e-18) cost += 20 * spacingSq;
+          cost += (preferredObstacleToTraceSpacing - dist) ** 2;
+          if (distSq < 1e-18) cost += 20 * obstacleSpacingSq;
         }
       }
     }
@@ -1325,9 +1347,11 @@ var CurvyTraceSolver = class extends BaseSolver {
   optimizeStep() {
     const { bounds } = this.problem;
     const { minX, maxX, minY, maxY } = bounds;
+    const minDim = Math.min(maxX - minX, maxY - minY);
     const progress = this.optimizationStep / this.maxOptimizationSteps;
     const baseStep = 3.5 * (1 - progress) + 0.5;
-    const SQRT1_2 = Math.SQRT1_2;
+    const minDist = minDim * 0.02;
+    const maxDist = minDim * 1.5;
     const traceCosts = [];
     for (let i = 0; i < this.traces.length; i++) {
       traceCosts.push({ idx: i, cost: this.computeCostForTrace(i) });
@@ -1338,74 +1362,65 @@ var CurvyTraceSolver = class extends BaseSolver {
       const trace = this.traces[i];
       const steps = [baseStep, baseStep * 1.5, baseStep * 0.5];
       for (const step of steps) {
-        const directions = [
-          { dx: step, dy: 0 },
-          { dx: -step, dy: 0 },
-          { dx: 0, dy: step },
-          { dx: 0, dy: -step },
-          { dx: step * SQRT1_2, dy: step * SQRT1_2 },
-          { dx: -step * SQRT1_2, dy: -step * SQRT1_2 },
-          { dx: step * SQRT1_2, dy: -step * SQRT1_2 },
-          { dx: -step * SQRT1_2, dy: step * SQRT1_2 }
-        ];
+        const deltas = [step, -step, step * 2, -step * 2];
         let bestCost = this.computeCostForTrace(i);
-        let bestCtrl1x = trace.ctrl1.x;
-        let bestCtrl1y = trace.ctrl1.y;
-        let bestCtrl2x = trace.ctrl2.x;
-        let bestCtrl2y = trace.ctrl2.y;
-        const origCtrl1x = trace.ctrl1.x;
-        const origCtrl1y = trace.ctrl1.y;
-        const origCtrl2x = trace.ctrl2.x;
-        const origCtrl2y = trace.ctrl2.y;
-        for (const dir of directions) {
-          trace.ctrl1.x = Math.max(minX, Math.min(maxX, origCtrl1x + dir.dx));
-          trace.ctrl1.y = Math.max(minY, Math.min(maxY, origCtrl1y + dir.dy));
+        let bestD1 = trace.d1;
+        let bestD2 = trace.d2;
+        const origD1 = trace.d1;
+        const origD2 = trace.d2;
+        for (const delta of deltas) {
+          trace.d1 = Math.max(minDist, Math.min(maxDist, origD1 + delta));
+          this.updateControlPointsFromDistances(i);
           this.updateSingleTraceSample(i);
           const cost1 = this.computeCostForTrace(i);
           if (cost1 < bestCost) {
             bestCost = cost1;
-            bestCtrl1x = trace.ctrl1.x;
-            bestCtrl1y = trace.ctrl1.y;
-            bestCtrl2x = origCtrl2x;
-            bestCtrl2y = origCtrl2y;
+            bestD1 = trace.d1;
+            bestD2 = origD2;
           }
-          trace.ctrl1.x = origCtrl1x;
-          trace.ctrl1.y = origCtrl1y;
-          trace.ctrl2.x = Math.max(minX, Math.min(maxX, origCtrl2x + dir.dx));
-          trace.ctrl2.y = Math.max(minY, Math.min(maxY, origCtrl2y + dir.dy));
+          trace.d1 = origD1;
+          this.updateControlPointsFromDistances(i);
+          trace.d2 = Math.max(minDist, Math.min(maxDist, origD2 + delta));
+          this.updateControlPointsFromDistances(i);
           this.updateSingleTraceSample(i);
           const cost2 = this.computeCostForTrace(i);
           if (cost2 < bestCost) {
             bestCost = cost2;
-            bestCtrl1x = origCtrl1x;
-            bestCtrl1y = origCtrl1y;
-            bestCtrl2x = trace.ctrl2.x;
-            bestCtrl2y = trace.ctrl2.y;
+            bestD1 = origD1;
+            bestD2 = trace.d2;
           }
-          trace.ctrl2.x = origCtrl2x;
-          trace.ctrl2.y = origCtrl2y;
-          trace.ctrl1.x = Math.max(minX, Math.min(maxX, origCtrl1x + dir.dx));
-          trace.ctrl1.y = Math.max(minY, Math.min(maxY, origCtrl1y + dir.dy));
-          trace.ctrl2.x = Math.max(minX, Math.min(maxX, origCtrl2x + dir.dx));
-          trace.ctrl2.y = Math.max(minY, Math.min(maxY, origCtrl2y + dir.dy));
+          trace.d2 = origD2;
+          this.updateControlPointsFromDistances(i);
+          trace.d1 = Math.max(minDist, Math.min(maxDist, origD1 + delta));
+          trace.d2 = Math.max(minDist, Math.min(maxDist, origD2 + delta));
+          this.updateControlPointsFromDistances(i);
           this.updateSingleTraceSample(i);
           const cost3 = this.computeCostForTrace(i);
           if (cost3 < bestCost) {
             bestCost = cost3;
-            bestCtrl1x = trace.ctrl1.x;
-            bestCtrl1y = trace.ctrl1.y;
-            bestCtrl2x = trace.ctrl2.x;
-            bestCtrl2y = trace.ctrl2.y;
+            bestD1 = trace.d1;
+            bestD2 = trace.d2;
+          }
+          trace.d1 = origD1;
+          trace.d2 = origD2;
+          this.updateControlPointsFromDistances(i);
+          trace.d1 = Math.max(minDist, Math.min(maxDist, origD1 + delta));
+          trace.d2 = Math.max(minDist, Math.min(maxDist, origD2 - delta));
+          this.updateControlPointsFromDistances(i);
+          this.updateSingleTraceSample(i);
+          const cost4 = this.computeCostForTrace(i);
+          if (cost4 < bestCost) {
+            bestCost = cost4;
+            bestD1 = trace.d1;
+            bestD2 = trace.d2;
           }
-          trace.ctrl1.x = origCtrl1x;
-          trace.ctrl1.y = origCtrl1y;
-          trace.ctrl2.x = origCtrl2x;
-          trace.ctrl2.y = origCtrl2y;
+          trace.d1 = origD1;
+          trace.d2 = origD2;
+          this.updateControlPointsFromDistances(i);
         }
-        trace.ctrl1.x = bestCtrl1x;
-        trace.ctrl1.y = bestCtrl1y;
-        trace.ctrl2.x = bestCtrl2x;
-        trace.ctrl2.y = bestCtrl2y;
+        trace.d1 = bestD1;
+        trace.d2 = bestD2;
+        this.updateControlPointsFromDistances(i);
         this.updateSingleTraceSample(i);
         if (bestCost < currentCost * 0.9) break;
       }

package/package.json

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