@tscircuit/curvy-trace-solver 0.0.7 → 0.0.8

package/dist/index.d.ts

@@ -49,6 +49,9 @@ declare class CurvyTraceSolver extends BaseSolver {
     private updateCollisionPairs;
     private computeTotalCost;
     private computeCostForTrace;
+    private tracesIntersect;
+    private findIntersectingPairs;
+    private resolveIntersections;
     private optimizeStep;
     private buildOutputTraces;
     _step(): void;

package/dist/index.js

@@ -1014,6 +1014,13 @@ function segmentDistSq(a1x, a1y, a2x, a2y, b1x, b1y, b2x, b2y) {
     ptSegDistSq(b2x, b2y, a1x, a1y, a2x, a2y)
   );
 }
+function segmentsIntersect(a1x, a1y, a2x, a2y, b1x, b1y, b2x, b2y) {
+  const d1 = (b2x - b1x) * (a1y - b1y) - (b2y - b1y) * (a1x - b1x);
+  const d2 = (b2x - b1x) * (a2y - b1y) - (b2y - b1y) * (a2x - b1x);
+  const d3 = (a2x - a1x) * (b1y - a1y) - (a2y - a1y) * (b1x - a1x);
+  const d4 = (a2x - a1x) * (b2y - a1y) - (a2y - a1y) * (b2x - a1x);
+  return (d1 > 0 && d2 < 0 || d1 < 0 && d2 > 0) && (d3 > 0 && d4 < 0 || d3 < 0 && d4 > 0);
+}
 function chordContains(aT1, aT2, bT1, bT2, perimeter) {
   const normalize = (t) => (t % perimeter + perimeter) % perimeter;
   const a1 = normalize(aT1), a2 = normalize(aT2);
@@ -1102,17 +1109,23 @@ var CurvyTraceSolver = class extends BaseSolver {
       t2: getPerimeterT(pair.end, bounds),
       idx
     }));
-    const nestingDepth = /* @__PURE__ */ new Map();
+    const containedBy = tracesWithT.map(() => []);
+    const contains = tracesWithT.map(() => []);
     for (const trace of tracesWithT) {
-      let depth = 0;
       for (const other of tracesWithT) {
-        if (trace.idx !== other.idx && chordContains(other.t1, other.t2, trace.t1, trace.t2, perimeter)) {
-          depth++;
+        if (trace.idx !== other.idx) {
+          if (trace.pair.networkId && other.pair.networkId && trace.pair.networkId === other.pair.networkId) {
+            continue;
+          }
+          if (chordContains(other.t1, other.t2, trace.t1, trace.t2, perimeter)) {
+            containedBy[trace.idx].push(other.idx);
+            contains[other.idx].push(trace.idx);
+          }
         }
       }
-      nestingDepth.set(trace.idx, depth);
     }
-    const maxDepth = Math.max(...Array.from(nestingDepth.values()), 1);
+    const nestingDepth = containedBy.map((arr) => arr.length);
+    const maxDepth = Math.max(...nestingDepth, 1);
     this.traces = tracesWithT.map(({ pair, t1, t2, idx }) => {
       const perpDir1 = getInwardPerpendicular(pair.start, bounds);
       const perpDir2 = getInwardPerpendicular(pair.end, bounds);
@@ -1120,7 +1133,7 @@ var CurvyTraceSolver = class extends BaseSolver {
         pair.end.x - pair.start.x,
         pair.end.y - pair.start.y
       );
-      const depth = nestingDepth.get(idx) || 0;
+      const depth = nestingDepth[idx];
       const normalizedDepth = depth / maxDepth;
       const midPoint = {
         x: (pair.start.x + pair.end.x) / 2,
@@ -1156,7 +1169,9 @@ var CurvyTraceSolver = class extends BaseSolver {
         perpDir1,
         perpDir2,
         d1,
-        d2
+        d2,
+        containedBy: containedBy[idx],
+        contains: contains[idx]
       };
     });
     this.sampledPoints = this.traces.map(
@@ -1344,12 +1359,211 @@ var CurvyTraceSolver = class extends BaseSolver {
     }
     return cost;
   }
+  // Check if two traces intersect or are very close (potential intersection)
+  // Uses higher resolution sampling for accuracy
+  tracesIntersect(i, j) {
+    const trace1 = this.traces[i];
+    const trace2 = this.traces[j];
+    const INTERSECT_SAMPLES = 15;
+    const p1 = new Float64Array((INTERSECT_SAMPLES + 1) * 2);
+    const p2 = new Float64Array((INTERSECT_SAMPLES + 1) * 2);
+    sampleCubicBezierInline(
+      trace1.waypointPair.start.x,
+      trace1.waypointPair.start.y,
+      trace1.ctrl1.x,
+      trace1.ctrl1.y,
+      trace1.ctrl2.x,
+      trace1.ctrl2.y,
+      trace1.waypointPair.end.x,
+      trace1.waypointPair.end.y,
+      p1,
+      INTERSECT_SAMPLES
+    );
+    sampleCubicBezierInline(
+      trace2.waypointPair.start.x,
+      trace2.waypointPair.start.y,
+      trace2.ctrl1.x,
+      trace2.ctrl1.y,
+      trace2.ctrl2.x,
+      trace2.ctrl2.y,
+      trace2.waypointPair.end.x,
+      trace2.waypointPair.end.y,
+      p2,
+      INTERSECT_SAMPLES
+    );
+    for (let a = 0; a < INTERSECT_SAMPLES; a++) {
+      const a1x = p1[a * 2];
+      const a1y = p1[a * 2 + 1];
+      const a2x = p1[(a + 1) * 2];
+      const a2y = p1[(a + 1) * 2 + 1];
+      for (let b = 0; b < INTERSECT_SAMPLES; b++) {
+        const b1x = p2[b * 2];
+        const b1y = p2[b * 2 + 1];
+        const b2x = p2[(b + 1) * 2];
+        const b2y = p2[(b + 1) * 2 + 1];
+        if (segmentsIntersect(a1x, a1y, a2x, a2y, b1x, b1y, b2x, b2y)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  // Find all pairs of traces that currently intersect
+  findIntersectingPairs() {
+    const intersecting = [];
+    for (let i = 0; i < this.traces.length; i++) {
+      for (let j = i + 1; j < this.traces.length; j++) {
+        const ti = this.traces[i];
+        const tj = this.traces[j];
+        if (ti.networkId && tj.networkId && ti.networkId === tj.networkId) {
+          continue;
+        }
+        const bi = this.traceBounds[i];
+        const bj = this.traceBounds[j];
+        if (bi.maxX < bj.minX || bj.maxX < bi.minX || bi.maxY < bj.minY || bj.maxY < bi.minY) {
+          continue;
+        }
+        if (this.tracesIntersect(i, j)) {
+          intersecting.push([i, j]);
+        }
+      }
+    }
+    return intersecting;
+  }
+  // Resolve intersections by separating traces in depth
+  // Only keeps changes if they improve overall cost
+  resolveIntersections() {
+    const { bounds, preferredTraceToTraceSpacing } = this.problem;
+    const { minX, maxX, minY, maxY } = bounds;
+    const minDim = Math.min(maxX - minX, maxY - minY);
+    const minDist = minDim * 0.02;
+    const maxDist = minDim * 1.5;
+    const intersecting = this.findIntersectingPairs();
+    if (intersecting.length === 0) return 0;
+    let resolved = 0;
+    for (const [i, j] of intersecting) {
+      const ti = this.traces[i];
+      const tj = this.traces[j];
+      if (!this.tracesIntersect(i, j)) continue;
+      let outerIdx;
+      let innerIdx;
+      if (ti.containedBy.includes(j)) {
+        outerIdx = j;
+        innerIdx = i;
+      } else if (tj.containedBy.includes(i)) {
+        outerIdx = i;
+        innerIdx = j;
+      } else {
+        const avgDi = (ti.d1 + ti.d2) / 2;
+        const avgDj = (tj.d1 + tj.d2) / 2;
+        if (avgDi < avgDj) {
+          outerIdx = i;
+          innerIdx = j;
+        } else {
+          outerIdx = j;
+          innerIdx = i;
+        }
+      }
+      const outerTrace = this.traces[outerIdx];
+      const innerTrace = this.traces[innerIdx];
+      const origOuterD1 = outerTrace.d1;
+      const origOuterD2 = outerTrace.d2;
+      const origInnerD1 = innerTrace.d1;
+      const origInnerD2 = innerTrace.d2;
+      const costBeforeThis = this.computeTotalCost();
+      const separation = preferredTraceToTraceSpacing * 2;
+      const strategies = [
+        // Strategy 1: Small increase for inner
+        { innerMult: 1, outerMult: 0 },
+        // Strategy 2: Small decrease for outer
+        { innerMult: 0, outerMult: 1 },
+        // Strategy 3: Both directions
+        { innerMult: 0.5, outerMult: 0.5 },
+        // Strategy 4: Larger increase for inner
+        { innerMult: 2, outerMult: 0 },
+        // Strategy 5: Both larger
+        { innerMult: 1, outerMult: 1 },
+        // More aggressive
+        { innerMult: 3, outerMult: 0 },
+        { innerMult: 2, outerMult: 1 },
+        { innerMult: 4, outerMult: 0 }
+      ];
+      let bestCost = costBeforeThis;
+      let bestStrategy = null;
+      for (const strategy of strategies) {
+        outerTrace.d1 = origOuterD1;
+        outerTrace.d2 = origOuterD2;
+        innerTrace.d1 = origInnerD1;
+        innerTrace.d2 = origInnerD2;
+        innerTrace.d1 = Math.min(
+          maxDist,
+          origInnerD1 + separation * strategy.innerMult
+        );
+        innerTrace.d2 = Math.min(
+          maxDist,
+          origInnerD2 + separation * strategy.innerMult
+        );
+        outerTrace.d1 = Math.max(
+          minDist,
+          origOuterD1 - separation * strategy.outerMult
+        );
+        outerTrace.d2 = Math.max(
+          minDist,
+          origOuterD2 - separation * strategy.outerMult
+        );
+        this.updateControlPointsFromDistances(innerIdx);
+        this.updateControlPointsFromDistances(outerIdx);
+        this.updateSingleTraceSample(innerIdx);
+        this.updateSingleTraceSample(outerIdx);
+        if (!this.tracesIntersect(outerIdx, innerIdx)) {
+          const newCost = this.computeTotalCost();
+          if (bestStrategy === null || newCost < bestCost) {
+            bestCost = newCost;
+            bestStrategy = strategy;
+          }
+        }
+      }
+      if (bestStrategy) {
+        innerTrace.d1 = Math.min(
+          maxDist,
+          origInnerD1 + separation * bestStrategy.innerMult
+        );
+        innerTrace.d2 = Math.min(
+          maxDist,
+          origInnerD2 + separation * bestStrategy.innerMult
+        );
+        outerTrace.d1 = Math.max(
+          minDist,
+          origOuterD1 - separation * bestStrategy.outerMult
+        );
+        outerTrace.d2 = Math.max(
+          minDist,
+          origOuterD2 - separation * bestStrategy.outerMult
+        );
+        this.updateControlPointsFromDistances(innerIdx);
+        this.updateControlPointsFromDistances(outerIdx);
+        this.updateSingleTraceSample(innerIdx);
+        this.updateSingleTraceSample(outerIdx);
+        resolved++;
+      } else {
+        outerTrace.d1 = origOuterD1;
+        outerTrace.d2 = origOuterD2;
+        innerTrace.d1 = origInnerD1;
+        innerTrace.d2 = origInnerD2;
+        this.updateControlPointsFromDistances(outerIdx);
+        this.updateControlPointsFromDistances(innerIdx);
+        this.updateSingleTraceSample(outerIdx);
+        this.updateSingleTraceSample(innerIdx);
+      }
+    }
+    return resolved;
+  }
   optimizeStep() {
-    const { bounds } = this.problem;
+    const { bounds, preferredTraceToTraceSpacing } = 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 baseStep = 4 * (1 - progress) + 0.5;
     const minDist = minDim * 0.02;
     const maxDist = minDim * 1.5;
     const traceCosts = [];
@@ -1360,9 +1574,19 @@ var CurvyTraceSolver = class extends BaseSolver {
     for (const { idx: i, cost: currentCost } of traceCosts) {
       if (currentCost === 0) continue;
       const trace = this.traces[i];
-      const steps = [baseStep, baseStep * 1.5, baseStep * 0.5];
+      const costMultiplier = currentCost > 100 ? 2 : 1;
+      const steps = [baseStep * costMultiplier, baseStep * 1.5 * costMultiplier, baseStep * 0.5];
       for (const step of steps) {
-        const deltas = [step, -step, step * 2, -step * 2];
+        const deltas = currentCost > 100 ? [
+          step,
+          -step,
+          step * 2,
+          -step * 2,
+          step * 3,
+          -step * 3,
+          preferredTraceToTraceSpacing * 2,
+          -preferredTraceToTraceSpacing * 2
+        ] : [step, -step, step * 2, -step * 2];
         let bestCost = this.computeCostForTrace(i);
         let bestD1 = trace.d1;
         let bestD2 = trace.d2;
@@ -1451,13 +1675,25 @@ var CurvyTraceSolver = class extends BaseSolver {
     if (this.optimizationStep < this.maxOptimizationSteps) {
       this.optimizeStep();
       this.optimizationStep++;
+      if (this.optimizationStep % 10 === 0) {
+        const resolved = this.resolveIntersections();
+        if (resolved > 0) {
+          this.updateCollisionPairs();
+        }
+      }
       const currentCost = this.computeTotalCost();
       if (currentCost === 0) {
         this.optimizationStep = this.maxOptimizationSteps;
       } else if (currentCost >= this.lastCost * 0.99) {
         this.stagnantSteps++;
-        if (this.stagnantSteps > 15) {
-          this.optimizationStep = this.maxOptimizationSteps;
+        if (this.stagnantSteps > 10) {
+          const resolved = this.resolveIntersections();
+          if (resolved > 0) {
+            this.updateCollisionPairs();
+            this.stagnantSteps = 0;
+          } else if (this.stagnantSteps > 15) {
+            this.optimizationStep = this.maxOptimizationSteps;
+          }
         }
       } else {
         this.stagnantSteps = 0;
@@ -1465,6 +1701,7 @@ var CurvyTraceSolver = class extends BaseSolver {
       this.lastCost = currentCost;
     }
     if (this.optimizationStep >= this.maxOptimizationSteps) {
+      this.resolveIntersections();
       this.buildOutputTraces();
       this.solved = true;
     }

package/package.json

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