@tscircuit/capacity-autorouter 0.0.4 → 0.0.5

package/dist/index.d.ts

@@ -213,6 +213,7 @@ declare class CapacityPathingSolver extends BaseSolver {
     reduceCapacityAlongPath(nextConnection: {
         path?: CapacityMeshNode[];
     }): void;
+    isConnectedToEndGoal(node: CapacityMeshNode, endGoal: CapacityMeshNode): boolean;
     _step(): void;
     visualize(): GraphicsObject;
 }
@@ -771,6 +772,30 @@ declare class CapacitySegmentPointOptimizer extends BaseSolver {
     visualize(): GraphicsObject;
 }
 
+/**
+ * Converts a net containing many points to connect into an array of point pair
+ * connections.
+ *
+ * For example, a connection with 3 pointsToConnect could be turned into 2
+ * connections of 2 points each.
+ *
+ * Where we create the minimum number of pairs, we're using a minimum spanning
+ * tree (MST).
+ *
+ * Sometimes it can be used to add additional traces to help make sure we
+ * distribute load effectively. In this version we don't do that!
+ */
+declare class NetToPointPairsSolver extends BaseSolver {
+    ogSrj: SimpleRouteJson;
+    colorMap: Record<string, string>;
+    unprocessedConnections: Array<SimpleRouteConnection>;
+    newConnections: Array<SimpleRouteConnection>;
+    constructor(ogSrj: SimpleRouteJson, colorMap?: Record<string, string>);
+    _step(): void;
+    getNewSimpleRouteJson(): SimpleRouteJson;
+    visualize(): GraphicsObject;
+}
+
 interface CapacityMeshSolverOptions {
     capacityDepth?: number;
     targetMinCapacity?: number;
@@ -778,7 +803,8 @@ interface CapacityMeshSolverOptions {
 declare class CapacityMeshSolver extends BaseSolver {
     srj: SimpleRouteJson;
     opts: CapacityMeshSolverOptions;
-    nodeSolver: CapacityMeshNodeSolver;
+    netToPointPairsSolver?: NetToPointPairsSolver;
+    nodeSolver?: CapacityMeshNodeSolver;
     nodeTargetMerger?: CapacityNodeTargetMerger;
     edgeSolver?: CapacityMeshEdgeSolver;
     pathingSolver?: CapacityPathingSolver;

package/dist/index.js

@@ -2896,6 +2896,9 @@ var CapacityPathingSolver = class extends BaseSolver {
       );
     }
   }
+  isConnectedToEndGoal(node, endGoal) {
+    return this.nodeEdgeMap.get(node.capacityMeshNodeId).some((edge) => edge.nodeIds.includes(endGoal.capacityMeshNodeId));
+  }
   _step() {
     const nextConnection = this.connectionsWithNodes[this.currentConnectionIndex];
     if (!nextConnection) {
@@ -2922,8 +2925,14 @@ var CapacityPathingSolver = class extends BaseSolver {
       this.visitedNodes = null;
       return;
     }
-    if (currentCandidate.node.capacityMeshNodeId === end.capacityMeshNodeId) {
-      nextConnection.path = this.getBacktrackedPath(currentCandidate);
+    if (this.isConnectedToEndGoal(currentCandidate.node, end)) {
+      nextConnection.path = this.getBacktrackedPath({
+        prevCandidate: currentCandidate,
+        node: end,
+        f: 0,
+        g: 0,
+        h: 0
+      });
       this.reduceCapacityAlongPath(nextConnection);
       this.currentConnectionIndex++;
       this.candidates = null;
@@ -3002,19 +3011,30 @@ ${node.width.toFixed(2)}x${node.height.toFixed(2)}`
         }
       }
     }
+    const nextConnection = this.connectionsWithNodes[this.currentConnectionIndex];
+    if (nextConnection) {
+      const [start, end] = nextConnection.connection.pointsToConnect;
+      graphics.lines.push({
+        points: [
+          { x: start.x, y: start.y },
+          { x: end.x, y: end.y }
+        ],
+        strokeColor: "red",
+        strokeDash: "10 5"
+      });
+    }
     if (this.candidates) {
-      const topCandidates = this.candidates.slice(0, 50);
+      const topCandidates = this.candidates.slice(0, 5);
       const connectionName = this.connectionsWithNodes[this.currentConnectionIndex].connection.name;
       topCandidates.forEach((candidate, index) => {
-        const opacity = 0.05 * (1 - index / 50);
+        const opacity = 0.5 * (1 - index / 5);
         const backtrackedPath = this.getBacktrackedPath(candidate);
         graphics.lines.push({
           points: backtrackedPath.map(({ center: { x, y } }) => ({ x, y })),
           strokeColor: safeTransparentize(
             this.colorMap[connectionName] ?? "red",
             1 - opacity
-          ),
-          strokeWidth: 0.5
+          )
         });
       });
     }
@@ -3964,6 +3984,308 @@ ${segment.nodePortSegmentId}`
   }
 };
 
+// lib/solvers/NetToPointPairsSolver/buildMinimumSpanningTree.ts
+var KDNode = class {
+  point;
+  left = null;
+  right = null;
+  constructor(point) {
+    this.point = point;
+  }
+};
+var KDTree = class {
+  root = null;
+  constructor(points) {
+    if (points.length > 0) {
+      this.root = this.buildTree(points, 0);
+    }
+  }
+  buildTree(points, depth) {
+    const axis = depth % 2 === 0 ? "x" : "y";
+    points.sort((a, b) => a[axis] - b[axis]);
+    const medianIndex = Math.floor(points.length / 2);
+    const node = new KDNode(points[medianIndex]);
+    if (medianIndex > 0) {
+      node.left = this.buildTree(points.slice(0, medianIndex), depth + 1);
+    }
+    if (medianIndex < points.length - 1) {
+      node.right = this.buildTree(points.slice(medianIndex + 1), depth + 1);
+    }
+    return node;
+  }
+  // Find the nearest neighbor to a query point
+  findNearestNeighbor(queryPoint) {
+    if (!this.root) {
+      throw new Error("Tree is empty");
+    }
+    const best = this.root.point;
+    const bestDistance = this.distance(queryPoint, best);
+    this.nearestNeighborSearch(this.root, queryPoint, 0, best, bestDistance);
+    return best;
+  }
+  nearestNeighborSearch(node, queryPoint, depth, best, bestDistance) {
+    if (!node) {
+      return best;
+    }
+    const axis = depth % 2 ? "x" : "y";
+    const currentDistance = this.distance(queryPoint, node.point);
+    if (currentDistance < bestDistance) {
+      best = node.point;
+      bestDistance = currentDistance;
+    }
+    const axisDiff = queryPoint[axis] - node.point[axis];
+    const firstBranch = axisDiff <= 0 ? node.left : node.right;
+    const secondBranch = axisDiff <= 0 ? node.right : node.left;
+    best = this.nearestNeighborSearch(
+      firstBranch,
+      queryPoint,
+      depth + 1,
+      best,
+      bestDistance
+    );
+    bestDistance = this.distance(queryPoint, best);
+    if (Math.abs(axisDiff) < bestDistance) {
+      best = this.nearestNeighborSearch(
+        secondBranch,
+        queryPoint,
+        depth + 1,
+        best,
+        bestDistance
+      );
+    }
+    return best;
+  }
+  // Find k nearest neighbors
+  findKNearestNeighbors(queryPoint, k) {
+    if (!this.root) {
+      return [];
+    }
+    const neighbors = [];
+    this.kNearestNeighborSearch(this.root, queryPoint, 0, neighbors, k);
+    return neighbors.sort((a, b) => a.distance - b.distance).slice(0, k).map((n) => n.point);
+  }
+  kNearestNeighborSearch(node, queryPoint, depth, neighbors, k) {
+    if (!node) {
+      return;
+    }
+    const axis = depth % 2 ? "x" : "y";
+    const currentDistance = this.distance(queryPoint, node.point);
+    neighbors.push({ point: node.point, distance: currentDistance });
+    const axisDiff = queryPoint[axis] - node.point[axis];
+    const firstBranch = axisDiff <= 0 ? node.left : node.right;
+    const secondBranch = axisDiff <= 0 ? node.right : node.left;
+    this.kNearestNeighborSearch(
+      firstBranch,
+      queryPoint,
+      depth + 1,
+      neighbors,
+      k
+    );
+    let kthDistance = Infinity;
+    if (neighbors.length >= k) {
+      neighbors.sort((a, b) => a.distance - b.distance);
+      kthDistance = neighbors[k - 1]?.distance || Infinity;
+    }
+    if (Math.abs(axisDiff) < kthDistance || neighbors.length < k) {
+      this.kNearestNeighborSearch(
+        secondBranch,
+        queryPoint,
+        depth + 1,
+        neighbors,
+        k
+      );
+    }
+  }
+  // Calculate Euclidean distance between two points
+  distance(a, b) {
+    return Math.sqrt((a.x - b.x) ** 2 + (a.y - b.y) ** 2);
+  }
+};
+var DisjointSet = class {
+  parent = /* @__PURE__ */ new Map();
+  rank = /* @__PURE__ */ new Map();
+  constructor(points) {
+    for (const point of points) {
+      const key = this.pointToKey(point);
+      this.parent.set(key, key);
+      this.rank.set(key, 0);
+    }
+  }
+  pointToKey(point) {
+    return `${point.x},${point.y}`;
+  }
+  find(point) {
+    const key = this.pointToKey(point);
+    if (!this.parent.has(key)) {
+      throw new Error(`Point ${key} not found in DisjointSet`);
+    }
+    let root = key;
+    while (root !== this.parent.get(root)) {
+      root = this.parent.get(root);
+    }
+    let current = key;
+    while (current !== root) {
+      const next = this.parent.get(current);
+      this.parent.set(current, root);
+      current = next;
+    }
+    return root;
+  }
+  union(pointA, pointB) {
+    const rootA = this.find(pointA);
+    const rootB = this.find(pointB);
+    if (rootA === rootB) {
+      return false;
+    }
+    const rankA = this.rank.get(rootA) || 0;
+    const rankB = this.rank.get(rootB) || 0;
+    if (rankA < rankB) {
+      this.parent.set(rootA, rootB);
+    } else if (rankA > rankB) {
+      this.parent.set(rootB, rootA);
+    } else {
+      this.parent.set(rootB, rootA);
+      this.rank.set(rootA, rankA + 1);
+    }
+    return true;
+  }
+};
+function buildMinimumSpanningTree(points) {
+  if (points.length <= 1) {
+    return [];
+  }
+  const kdTree = new KDTree(points);
+  const edges = [];
+  const k = Math.min(10, points.length - 1);
+  for (const point of points) {
+    const neighbors = kdTree.findKNearestNeighbors(point, k + 1);
+    for (const neighbor of neighbors) {
+      if (point.x === neighbor.x && point.y === neighbor.y) {
+        continue;
+      }
+      const distance3 = Math.sqrt(
+        (point.x - neighbor.x) ** 2 + (point.y - neighbor.y) ** 2
+      );
+      edges.push({
+        from: point,
+        to: neighbor,
+        weight: distance3
+      });
+    }
+  }
+  edges.sort((a, b) => a.weight - b.weight);
+  const disjointSet = new DisjointSet(points);
+  const mstEdges = [];
+  for (const edge of edges) {
+    if (disjointSet.union(edge.from, edge.to)) {
+      mstEdges.push(edge);
+      if (mstEdges.length === points.length - 1) {
+        break;
+      }
+    }
+  }
+  return mstEdges;
+}
+
+// lib/solvers/NetToPointPairsSolver/NetToPointPairsSolver.ts
+var NetToPointPairsSolver = class extends BaseSolver {
+  constructor(ogSrj, colorMap = {}) {
+    super();
+    this.ogSrj = ogSrj;
+    this.colorMap = colorMap;
+    this.unprocessedConnections = ogSrj.connections;
+    this.newConnections = [];
+  }
+  unprocessedConnections;
+  newConnections;
+  _step() {
+    if (this.unprocessedConnections.length === 0) {
+      this.solved = true;
+      return;
+    }
+    const connection = this.unprocessedConnections.pop();
+    if (connection.pointsToConnect.length === 2) {
+      this.newConnections.push(connection);
+      return;
+    }
+    const edges = buildMinimumSpanningTree(connection.pointsToConnect);
+    for (const edge of edges) {
+      this.newConnections.push({
+        pointsToConnect: [edge.from, edge.to],
+        name: connection.name
+      });
+    }
+  }
+  getNewSimpleRouteJson() {
+    return {
+      ...this.ogSrj,
+      connections: this.newConnections
+    };
+  }
+  visualize() {
+    const graphics = {
+      lines: [],
+      points: [],
+      rects: [],
+      circles: [],
+      coordinateSystem: "cartesian",
+      title: "Net To Point Pairs Visualization"
+    };
+    this.unprocessedConnections.forEach((connection) => {
+      connection.pointsToConnect.forEach((point) => {
+        graphics.points.push({
+          x: point.x,
+          y: point.y,
+          color: "red",
+          label: connection.name
+        });
+      });
+      const fullyConnectedEdgeCount = connection.pointsToConnect.length ** 2;
+      const random = seededRandom(0);
+      const alreadyPlacedEdges = /* @__PURE__ */ new Set();
+      for (let i = 0; i < Math.max(
+        fullyConnectedEdgeCount,
+        connection.pointsToConnect.length * 2
+      ); i++) {
+        const a = Math.floor(random() * connection.pointsToConnect.length);
+        const b = Math.floor(random() * connection.pointsToConnect.length);
+        if (alreadyPlacedEdges.has(`${a}-${b}`)) continue;
+        alreadyPlacedEdges.add(`${a}-${b}`);
+        graphics.lines.push({
+          points: [
+            connection.pointsToConnect[a],
+            connection.pointsToConnect[b]
+          ],
+          strokeColor: "rgba(255,0,0,0.25)"
+        });
+      }
+    });
+    this.newConnections.forEach((connection) => {
+      const color = this.colorMap?.[connection.name] || "blue";
+      connection.pointsToConnect.forEach((point) => {
+        graphics.points.push({
+          x: point.x,
+          y: point.y,
+          color,
+          label: connection.name
+        });
+      });
+      for (let i = 0; i < connection.pointsToConnect.length - 1; i++) {
+        for (let j = i + 1; j < connection.pointsToConnect.length; j++) {
+          graphics.lines.push({
+            points: [
+              connection.pointsToConnect[i],
+              connection.pointsToConnect[j]
+            ],
+            strokeColor: color
+          });
+        }
+      }
+    });
+    return graphics;
+  }
+};
+
 // lib/solvers/CapacityMeshSolver/CapacityMeshSolver.ts
 var CapacityMeshSolver = class extends BaseSolver {
   constructor(srj, opts = {}) {
@@ -3981,10 +4303,10 @@ var CapacityMeshSolver = class extends BaseSolver {
         targetMinCapacity
       );
     }
-    this.nodeSolver = new CapacityMeshNodeSolver(srj, this.opts);
     this.connMap = getConnectivityMapFromSimpleRouteJson(srj);
     this.colorMap = getColorMap(srj, this.connMap);
   }
+  netToPointPairsSolver;
   nodeSolver;
   nodeTargetMerger;
   edgeSolver;
@@ -4008,7 +4330,19 @@ var CapacityMeshSolver = class extends BaseSolver {
       }
       return;
     }
-    if (!this.nodeSolver.solved) {
+    if (!this.netToPointPairsSolver) {
+      this.netToPointPairsSolver = new NetToPointPairsSolver(
+        this.srj,
+        this.colorMap
+      );
+      this.activeSolver = this.netToPointPairsSolver;
+      return;
+    }
+    if (!this.nodeSolver) {
+      this.nodeSolver = new CapacityMeshNodeSolver(
+        this.netToPointPairsSolver.getNewSimpleRouteJson(),
+        this.opts
+      );
       this.activeSolver = this.nodeSolver;
       return;
     }
@@ -4029,7 +4363,7 @@ var CapacityMeshSolver = class extends BaseSolver {
     }
     if (!this.pathingSolver) {
       this.pathingSolver = new CapacityPathingSolver4_FlexibleNegativeCapacity({
-        simpleRouteJson: this.srj,
+        simpleRouteJson: this.netToPointPairsSolver.getNewSimpleRouteJson(),
         nodes,
         edges: this.edgeSolver.edges,
         colorMap: this.colorMap,
@@ -4086,7 +4420,8 @@ var CapacityMeshSolver = class extends BaseSolver {
   }
   visualize() {
     if (!this.solved && this.activeSolver) return this.activeSolver.visualize();
-    const nodeViz = this.nodeSolver.visualize();
+    const netToPPSolver = this.netToPointPairsSolver?.visualize();
+    const nodeViz = this.nodeSolver?.visualize();
     const edgeViz = this.edgeSolver?.visualize();
     const pathingViz = this.pathingSolver?.visualize();
     const edgeToPortSegmentViz = this.edgeToPortSegmentSolver?.visualize();
@@ -4094,11 +4429,17 @@ var CapacityMeshSolver = class extends BaseSolver {
     const segmentOptimizationViz = this.segmentToPointOptimizer?.visualize();
     const highDensityViz = this.highDensityRouteSolver?.visualize();
     const problemViz = {
-      points: [...nodeViz.points],
-      rects: [...nodeViz.rects?.filter((r) => r.label?.includes("obstacle"))]
+      points: [...this.srj.connections.flatMap((c) => c.pointsToConnect)],
+      rects: [
+        ...(this.srj.obstacles ?? []).map((o) => ({
+          ...o,
+          fill: "rgba(255,0,0,0.25)"
+        }))
+      ]
     };
     const visualizations = [
       problemViz,
+      netToPPSolver,
       nodeViz,
       edgeViz,
       pathingViz,