@tscircuit/capacity-autorouter 0.0.51 → 0.0.52

package/dist/index.js

@@ -4030,20 +4030,17 @@ function distance2(p1, p2) {
 
 // lib/solvers/HighDensitySolver/TwoRouteHighDensitySolver/calculateSideTraversal.ts
 var EPSILON2 = 1e-9;
-function calculateSegmentTraversal(startPoint, endPoint, bounds) {
+function calculateSegmentTraversal(startPoint, endPoint, bounds, turnDirection = "cw") {
   const startAngle = pointToAngle(startPoint, bounds);
-  let endAngle = pointToAngle(endPoint, bounds);
-  if (endAngle < startAngle) {
-    endAngle += 2 * Math.PI;
-  }
+  const endAngle = pointToAngle(endPoint, bounds);
   if (Math.abs(endAngle - startAngle) < EPSILON2) {
     return { left: 0, top: 0, right: 0, bottom: 0 };
   }
-  return calculateSidePercentages(startAngle, endAngle, bounds);
+  return calculateSidePercentages(startAngle, endAngle, bounds, turnDirection);
 }
-function calculateTraversalPercentages(A, B, C, bounds) {
-  const percentagesAB = calculateSegmentTraversal(A, B, bounds);
-  const percentagesBC = calculateSegmentTraversal(B, C, bounds);
+function calculateTraversalPercentages(A, B, C, bounds, turnDirection) {
+  const percentagesAB = calculateSegmentTraversal(A, B, bounds, turnDirection);
+  const percentagesBC = calculateSegmentTraversal(B, C, bounds, turnDirection);
   const totalPercentages = {
     left: Math.min(1, percentagesAB.left + percentagesBC.left),
     top: Math.min(1, percentagesAB.top + percentagesBC.top),
@@ -4080,7 +4077,7 @@ function pointToAngle(point, bounds) {
   distance6 = Math.max(0, Math.min(perimeter, distance6));
   return perimeter > EPSILON2 ? distance6 / perimeter * (2 * Math.PI) : 0;
 }
-function calculateSidePercentages(startAngle, endAngle, bounds) {
+function calculateSidePercentages(startAngle, endAngle, bounds, turnDirection) {
   const width = bounds.maxX - bounds.minX;
   const height = bounds.maxY - bounds.minY;
   if (width < EPSILON2 && height < EPSILON2)
@@ -4104,17 +4101,54 @@ function calculateSidePercentages(startAngle, endAngle, bounds) {
     // Ends at 2PI
   ];
   const result = { left: 0, top: 0, right: 0, bottom: 0 };
-  const totalAngleTraversal = endAngle - startAngle;
-  if (totalAngleTraversal < EPSILON2) return result;
+  const calculateTraversalOverlap = (sStart, sEnd, tStart, tEnd, wrapsAround) => {
+    const effectiveSEnd = sEnd > 2 * Math.PI - EPSILON2 ? 2 * Math.PI : sEnd;
+    if (effectiveSEnd <= sStart + EPSILON2) return 0;
+    if (!wrapsAround) {
+      const overlapStart = Math.max(sStart, tStart);
+      const overlapEnd = Math.min(effectiveSEnd, tEnd);
+      return Math.max(0, overlapEnd - overlapStart);
+    } else {
+      const overlap1Start = Math.max(sStart, tStart);
+      const overlap1End = Math.min(effectiveSEnd, 2 * Math.PI);
+      const overlap1 = Math.max(0, overlap1End - overlap1Start);
+      const overlap2Start = Math.max(sStart, 0);
+      const overlap2End = Math.min(effectiveSEnd, tEnd);
+      const overlap2 = Math.max(0, overlap2End - overlap2Start);
+      return overlap1 + overlap2;
+    }
+  };
   for (const side of sides) {
     const sideAngleRange = side.end - side.start;
     if (sideAngleRange < EPSILON2 || side.length < EPSILON2) continue;
-    const overlapStart = Math.max(startAngle, side.start);
-    const overlapEnd = Math.min(endAngle, side.end);
-    if (overlapStart < overlapEnd - EPSILON2) {
-      const traversedAngleOnSide = overlapEnd - overlapStart;
+    let traversedAngleOnSide = 0;
+    if (turnDirection === "cw") {
+      const wraps = startAngle > endAngle + EPSILON2;
+      traversedAngleOnSide = calculateTraversalOverlap(
+        side.start,
+        side.end,
+        startAngle,
+        endAngle,
+        wraps
+      );
+    } else {
+      const wraps = endAngle > startAngle + EPSILON2;
+      traversedAngleOnSide = calculateTraversalOverlap(
+        side.start,
+        side.end,
+        endAngle,
+        // Start of equivalent CW traversal
+        startAngle,
+        // End of equivalent CW traversal
+        wraps
+      );
+    }
+    if (traversedAngleOnSide > EPSILON2) {
       const percentage = traversedAngleOnSide / sideAngleRange;
-      result[side.name] += Math.max(0, percentage);
+      result[side.name] += Math.max(
+        0,
+        Number.isFinite(percentage) ? percentage : 0
+      );
     }
   }
   for (const key in result) {
@@ -4126,6 +4160,28 @@ function calculateSidePercentages(startAngle, endAngle, bounds) {
   return result;
 }
 
+// lib/solvers/HighDensitySolver/TwoRouteHighDensitySolver/computeTurnDirection.ts
+function triangleDirection({
+  angleA,
+  angleB,
+  angleC
+}) {
+  const Ax = Math.cos(angleA);
+  const Ay = Math.sin(angleA);
+  const Bx = Math.cos(angleB);
+  const By = Math.sin(angleB);
+  const Cx = Math.cos(angleC);
+  const Cy = Math.sin(angleC);
+  const signedArea = (Bx - Ax) * (Cy - Ay) - (By - Ay) * (Cx - Ax);
+  return signedArea < 0 ? "ccw" : "cw";
+}
+function computeTurnDirection(A, B, C, bounds) {
+  const angleA = pointToAngle(A, bounds);
+  const angleB = pointToAngle(B, bounds);
+  const angleC = pointToAngle(C, bounds);
+  return triangleDirection({ angleA, angleB, angleC });
+}
+
 // lib/solvers/HighDensitySolver/TwoRouteHighDensitySolver/SingleTransitionCrossingRouteSolver.ts
 var SingleTransitionCrossingRouteSolver = class extends BaseSolver {
   // Input parameters
@@ -4213,7 +4269,14 @@ var SingleTransitionCrossingRouteSolver = class extends BaseSolver {
     const A = flatRoute.A;
     const B = ntrP1;
     const C = flatRoute.B;
-    const sideTraversal = calculateTraversalPercentages(A, B, C, this.bounds);
+    const turnDirection = computeTurnDirection(A, B, C, this.bounds);
+    const sideTraversal = calculateTraversalPercentages(
+      A,
+      B,
+      C,
+      this.bounds,
+      turnDirection
+    );
     const viaBounds = {
       minX: this.bounds.minX + (sideTraversal.left > 0.5 ? marginFromBorderWithTrace : marginFromBorderWithoutTrace),
       minY: this.bounds.minY + (sideTraversal.bottom > 0.5 ? marginFromBorderWithTrace : marginFromBorderWithoutTrace),
@@ -4291,23 +4354,29 @@ var SingleTransitionCrossingRouteSolver = class extends BaseSolver {
       otherRouteStart.z !== flatStart.z ? otherRouteStart : otherRouteEnd,
       this.traceThickness
     );
-    const p1 = findPointToGetAroundCircle(flatStart, p2, {
-      center: { x: via.x, y: via.y },
-      radius: minDistFromViaToTrace
-    }).E;
-    const p3 = findPointToGetAroundCircle(p2, flatEnd, {
+    const viaCircle = {
       center: { x: via.x, y: via.y },
       radius: minDistFromViaToTrace
-    }).E;
-    const p1IsNeeded = pointToSegmentDistance(via, flatStart, p2) < minDistFromViaToTrace;
-    const p3IsNeeded = pointToSegmentDistance(via, p2, flatEnd) < minDistFromViaToTrace;
+    };
+    const p1 = findPointToGetAroundCircle(flatStart, p2, viaCircle).E;
+    const p3 = findPointToGetAroundCircle(p2, flatEnd, viaCircle).E;
+    const p0_5 = findPointToGetAroundCircle(flatStart, p1, viaCircle).E;
+    const p1_5 = findPointToGetAroundCircle(p1, p2, viaCircle).E;
+    const p2_5 = findPointToGetAroundCircle(p2, p3, viaCircle).E;
+    const p3_5 = findPointToGetAroundCircle(p3, flatEnd, viaCircle).E;
+    const p2_better = findPointToGetAroundCircle(p1_5, p2_5, viaCircle).E;
     return {
       connectionName: flatRouteConnectionName,
       route: [
         { x: flatStart.x, y: flatStart.y, z: flatStart.z ?? 0 },
-        ...p1IsNeeded ? [{ x: p1.x, y: p1.y, z: flatStart.z ?? 0 }] : [],
-        { x: p2.x, y: p2.y, z: flatStart.z ?? 0 },
-        ...p3IsNeeded ? [{ x: p3.x, y: p3.y, z: flatStart.z ?? 0 }] : [],
+        { x: p0_5.x, y: p0_5.y, z: flatStart.z ?? 0 },
+        { x: p1.x, y: p1.y, z: flatStart.z ?? 0 },
+        { x: p1_5.x, y: p1_5.y, z: flatStart.z ?? 0 },
+        // { x: p2.x, y: p2.y, z: flatStart.z ?? 0 },
+        { x: p2_better.x, y: p2_better.y, z: flatStart.z ?? 0 },
+        { x: p2_5.x, y: p2_5.y, z: flatStart.z ?? 0 },
+        { x: p3.x, y: p3.y, z: flatStart.z ?? 0 },
+        { x: p3_5.x, y: p3_5.y, z: flatStart.z ?? 0 },
         { x: flatEnd.x, y: flatEnd.y, z: flatEnd.z ?? 0 }
       ],
       traceThickness: this.traceThickness,
@@ -7926,13 +7995,13 @@ function minimumDistanceBetweenSegments(A1, A2, B1, B2) {
   if (segmentsIntersect(A1, A2, B1, B2)) {
     return 0;
   }
-  const distA1 = pointToSegmentDistance4(A1, B1, B2);
-  const distA2 = pointToSegmentDistance4(A2, B1, B2);
-  const distB1 = pointToSegmentDistance4(B1, A1, A2);
-  const distB2 = pointToSegmentDistance4(B2, A1, A2);
+  const distA1 = pointToSegmentDistance5(A1, B1, B2);
+  const distA2 = pointToSegmentDistance5(A2, B1, B2);
+  const distB1 = pointToSegmentDistance5(B1, A1, A2);
+  const distB2 = pointToSegmentDistance5(B2, A1, A2);
   return Math.min(distA1, distA2, distB1, distB2);
 }
-function pointToSegmentDistance4(P, Q1, Q2) {
+function pointToSegmentDistance5(P, Q1, Q2) {
   const v = { x: Q2.x - Q1.x, y: Q2.y - Q1.y };
   const w = { x: P.x - Q1.x, y: P.y - Q1.y };
   const c1 = dotProduct(w, v);