@tscircuit/schematic-trace-solver 0.0.40 → 0.0.42

package/lib/solvers/LongDistancePairSolver/LongDistancePairSolver.ts

@@ -0,0 +1,238 @@
+import { getConnectivityMapsFromInputProblem } from "lib/solvers/MspConnectionPairSolver/getConnectivityMapFromInputProblem"
+import type { MspConnectionPair } from "lib/solvers/MspConnectionPairSolver/MspConnectionPairSolver"
+import type {
+  InputProblem,
+  InputPin,
+  PinId,
+  InputChip,
+} from "lib/types/InputProblem"
+import { BaseSolver } from "../BaseSolver/BaseSolver"
+import { SchematicTraceSingleLineSolver2 } from "../SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/SchematicTraceSingleLineSolver2"
+import { doesTraceOverlapWithExistingTraces } from "lib/utils/does-trace-overlap-with-existing-traces"
+import { visualizeInputProblem } from "../SchematicTracePipelineSolver/visualizeInputProblem"
+import type { SolvedTracePath } from "../SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import type { ConnectivityMap } from "connectivity-map"
+
+const NEAREST_NEIGHBOR_COUNT = 3
+
+const distance = (p1: InputPin, p2: InputPin) => {
+  return Math.sqrt(Math.pow(p1.x - p2.x, 2) + Math.pow(p1.y - p2.y, 2))
+}
+
+export class LongDistancePairSolver extends BaseSolver {
+  public solvedLongDistanceTraces: SolvedTracePath[] = []
+  private queuedCandidatePairs: Array<
+    [InputPin & { chipId: string }, InputPin & { chipId: string }]
+  > = []
+  private currentCandidatePair:
+    | [InputPin & { chipId: string }, InputPin & { chipId: string }]
+    | null = null
+  private subSolver: SchematicTraceSingleLineSolver2 | null = null
+  private chipMap: Record<string, InputChip> = {}
+  private inputProblem: InputProblem
+  private netConnMap: ConnectivityMap
+  private newlyConnectedPinIds = new Set<PinId>()
+  private allSolvedTraces: SolvedTracePath[] = []
+
+  constructor(
+    private params: {
+      inputProblem: InputProblem
+      alreadySolvedTraces: SolvedTracePath[]
+      primaryMspConnectionPairs: MspConnectionPair[]
+    },
+  ) {
+    super()
+
+    const { inputProblem, primaryMspConnectionPairs, alreadySolvedTraces } =
+      this.params
+
+    this.inputProblem = inputProblem
+    this.allSolvedTraces = [...alreadySolvedTraces]
+
+    // 1. Create initial maps and sets for efficient lookup
+    const primaryConnectedPinIds = new Set<PinId>()
+    for (const pair of primaryMspConnectionPairs) {
+      primaryConnectedPinIds.add(pair.pins[0].pinId)
+      primaryConnectedPinIds.add(pair.pins[1].pinId)
+    }
+
+    const { netConnMap } = getConnectivityMapsFromInputProblem(inputProblem)
+    this.netConnMap = netConnMap
+    const pinMap = new Map<PinId, InputPin & { chipId: string }>()
+    for (const chip of inputProblem.chips) {
+      this.chipMap[chip.chipId] = chip
+      for (const pin of chip.pins) {
+        pinMap.set(pin.pinId, { ...pin, chipId: chip.chipId })
+      }
+    }
+
+    // 2. Generate candidate pairs using N-Nearest-Neighbors approach
+    const candidatePairs: Array<
+      [InputPin & { chipId: string }, InputPin & { chipId: string }]
+    > = []
+    const addedPairKeys = new Set<string>()
+
+    for (const netId of Object.keys(netConnMap.netMap)) {
+      const allPinIdsInNet = netConnMap.getIdsConnectedToNet(netId)
+      if (allPinIdsInNet.length < 2) continue
+
+      const unconnectedPinIds = allPinIdsInNet.filter(
+        (pinId) => !primaryConnectedPinIds.has(pinId),
+      )
+
+      for (const unconnectedPinId of unconnectedPinIds) {
+        const sourcePin = pinMap.get(unconnectedPinId)
+        if (!sourcePin) continue
+
+        const neighbors = allPinIdsInNet
+          .filter((otherPinId) => otherPinId !== unconnectedPinId)
+          .flatMap((otherPinId) => {
+            const targetPin = pinMap.get(otherPinId)
+            if (!targetPin) return [] // Gracefully handle missing pins
+            return [
+              {
+                pin: targetPin,
+                distance: distance(sourcePin, targetPin),
+              },
+            ]
+          })
+          .sort((a, b) => a.distance - b.distance)
+          .slice(0, NEAREST_NEIGHBOR_COUNT)
+
+        for (const neighbor of neighbors) {
+          const pair: [
+            InputPin & { chipId: string },
+            InputPin & { chipId: string },
+          ] = [sourcePin, neighbor.pin]
+          const pairKey = pair
+            .map((p) => p.pinId)
+            .sort()
+            .join("--")
+
+          if (!addedPairKeys.has(pairKey)) {
+            candidatePairs.push(pair)
+            addedPairKeys.add(pairKey)
+          }
+        }
+      }
+    }
+    this.queuedCandidatePairs = candidatePairs
+  }
+
+  override getConstructorParams() {
+    return this.params
+  }
+
+  override _step() {
+    // 1. Check if a sub-solver has finished and process its result
+    if (this.subSolver?.solved) {
+      const newTracePath = this.subSolver.solvedTracePath
+      if (newTracePath && this.currentCandidatePair) {
+        const isTraceClear = !doesTraceOverlapWithExistingTraces(
+          newTracePath,
+          this.allSolvedTraces,
+        )
+
+        if (isTraceClear) {
+          const [p1, p2] = this.currentCandidatePair
+          const globalConnNetId = this.netConnMap.getNetConnectedToId(p1.pinId)!
+          const mspPairId = `${p1.pinId}-${p2.pinId}`
+
+          const newSolvedTrace: SolvedTracePath = {
+            mspPairId,
+            dcConnNetId: globalConnNetId,
+            globalConnNetId,
+            pins: [p1, p2],
+            tracePath: newTracePath,
+            mspConnectionPairIds: [mspPairId],
+            pinIds: [p1.pinId, p2.pinId],
+          }
+
+          this.solvedLongDistanceTraces.push(newSolvedTrace)
+          this.allSolvedTraces.push(newSolvedTrace)
+
+          this.newlyConnectedPinIds.add(p1.pinId)
+          this.newlyConnectedPinIds.add(p2.pinId)
+        }
+      }
+      this.subSolver = null
+      this.currentCandidatePair = null
+    } else if (this.subSolver?.failed) {
+      this.subSolver = null
+      this.currentCandidatePair = null
+    }
+
+    // 2. If a sub-solver is already running, let it continue
+    if (this.subSolver) {
+      this.subSolver.step()
+      return
+    }
+
+    // 3. Find the next valid candidate pair and start a new sub-solver
+    while (this.queuedCandidatePairs.length > 0) {
+      const nextPair = this.queuedCandidatePairs.shift()!
+      const [p1, p2] = nextPair
+
+      if (
+        this.newlyConnectedPinIds.has(p1.pinId) ||
+        this.newlyConnectedPinIds.has(p2.pinId)
+      ) {
+        continue
+      }
+
+      this.currentCandidatePair = nextPair
+      this.subSolver = new SchematicTraceSingleLineSolver2({
+        inputProblem: this.params.inputProblem,
+        pins: this.currentCandidatePair,
+        chipMap: this.chipMap,
+      })
+      return
+    }
+
+    // 4. If we've exited the loop, there are no more valid pairs to process
+    this.solved = true
+  }
+
+  override visualize() {
+    if (this.subSolver) {
+      return this.subSolver.visualize()
+    }
+
+    const graphics = visualizeInputProblem(this.inputProblem)
+
+    // Draw solved long-distance traces
+    for (const trace of this.solvedLongDistanceTraces) {
+      graphics.lines!.push({
+        points: trace.tracePath,
+        strokeColor: "purple",
+      })
+    }
+
+    // Draw queued candidate pairs
+    for (const [p1, p2] of this.queuedCandidatePairs) {
+      graphics.lines!.push({
+        points: [p1, p2],
+        strokeColor: "gray",
+        strokeDash: "4 4",
+      })
+    }
+
+    return graphics
+  }
+
+  public getOutput(): {
+    newTraces: SolvedTracePath[]
+    allTracesMerged: SolvedTracePath[]
+  } {
+    if (!this.solved) {
+      return { newTraces: [], allTracesMerged: this.params.alreadySolvedTraces }
+    }
+    return {
+      newTraces: this.solvedLongDistanceTraces,
+      allTracesMerged: [
+        ...this.params.alreadySolvedTraces,
+        ...this.solvedLongDistanceTraces,
+      ],
+    }
+  }
+}

package/lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver.ts

@@ -7,15 +7,19 @@ import type { GraphicsObject } from "graphics-debug"
 import { BaseSolver } from "lib/solvers/BaseSolver/BaseSolver"
 import type { InputProblem } from "lib/types/InputProblem"
 import { MspConnectionPairSolver } from "../MspConnectionPairSolver/MspConnectionPairSolver"
-import { SchematicTraceLinesSolver } from "../SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import {
+  SchematicTraceLinesSolver,
+  type SolvedTracePath,
+} from "../SchematicTraceLinesSolver/SchematicTraceLinesSolver"
 import { TraceOverlapShiftSolver } from "../TraceOverlapShiftSolver/TraceOverlapShiftSolver"
 import { NetLabelPlacementSolver } from "../NetLabelPlacementSolver/NetLabelPlacementSolver"
 import { visualizeInputProblem } from "./visualizeInputProblem"
-import { GuidelinesSolver } from "../GuidelinesSolver/GuidelinesSolver"
 import { TraceLabelOverlapAvoidanceSolver } from "../TraceLabelOverlapAvoidanceSolver/TraceLabelOverlapAvoidanceSolver"
-import { getInputChipBounds } from "../GuidelinesSolver/getInputChipBounds"
 import { correctPinsInsideChips } from "./correctPinsInsideChip"
 import { expandChipsToFitPins } from "./expandChipsToFitPins"
+import { LongDistancePairSolver } from "../LongDistancePairSolver/LongDistancePairSolver"
+import { MergedNetLabelObstacleSolver } from "../TraceLabelOverlapAvoidanceSolver/sub-solvers/LabelMergingSolver/LabelMergingSolver"
+import { TraceCleanupSolver } from "../TraceLabelOverlapAvoidanceSolver/sub-solvers/TraceCleanupSolver/TraceCleanupSolver"
 
 type PipelineStep<T extends new (...args: any[]) => BaseSolver> = {
   solverName: string
@@ -24,6 +28,7 @@ type PipelineStep<T extends new (...args: any[]) => BaseSolver> = {
     instance: SchematicTracePipelineSolver,
   ) => ConstructorParameters<T>
   onSolved?: (instance: SchematicTracePipelineSolver) => void
+  shouldSkip?: (instance: SchematicTracePipelineSolver) => boolean
 }
 
 function definePipelineStep<
@@ -37,6 +42,7 @@ function definePipelineStep<
   getConstructorParams: (instance: SchematicTracePipelineSolver) => P,
   opts: {
     onSolved?: (instance: SchematicTracePipelineSolver) => void
+    shouldSkip?: (instance: SchematicTracePipelineSolver) => boolean
   } = {},
 ): PipelineStep<T> {
   return {
@@ -44,16 +50,25 @@ function definePipelineStep<
     solverClass,
     getConstructorParams,
     onSolved: opts.onSolved,
+    shouldSkip: opts.shouldSkip,
   }
 }
 
+export interface SchematicTracePipelineSolverParams {
+  inputProblem: InputProblem
+  allowLongDistanceTraces?: boolean
+}
+
 export class SchematicTracePipelineSolver extends BaseSolver {
   mspConnectionPairSolver?: MspConnectionPairSolver
   // guidelinesSolver?: GuidelinesSolver
   schematicTraceLinesSolver?: SchematicTraceLinesSolver
+  longDistancePairSolver?: LongDistancePairSolver
   traceOverlapShiftSolver?: TraceOverlapShiftSolver
   netLabelPlacementSolver?: NetLabelPlacementSolver
+  labelMergingSolver?: MergedNetLabelObstacleSolver
   traceLabelOverlapAvoidanceSolver?: TraceLabelOverlapAvoidanceSolver
+  traceCleanupSolver?: TraceCleanupSolver
 
   startTimeOfPhase: Record<string, number>
   endTimeOfPhase: Record<string, number>
@@ -96,6 +111,19 @@ export class SchematicTracePipelineSolver extends BaseSolver {
           chipMap: this.mspConnectionPairSolver!.chipMap,
         },
       ],
+    ),
+    definePipelineStep(
+      "longDistancePairSolver",
+      LongDistancePairSolver,
+      (instance) => [
+        {
+          inputProblem: instance.inputProblem,
+          primaryMspConnectionPairs:
+            instance.mspConnectionPairSolver!.mspConnectionPairs,
+          alreadySolvedTraces:
+            instance.schematicTraceLinesSolver!.solvedTracePaths,
+        },
+      ],
       {
         onSolved: (schematicTraceLinesSolver) => {},
       },
@@ -106,7 +134,8 @@ export class SchematicTracePipelineSolver extends BaseSolver {
       () => [
         {
           inputProblem: this.inputProblem,
-          inputTracePaths: this.schematicTraceLinesSolver!.solvedTracePaths,
+          inputTracePaths:
+            this.longDistancePairSolver?.getOutput().allTracesMerged!,
           globalConnMap: this.mspConnectionPairSolver!.globalConnMap,
         },
       ],
@@ -123,10 +152,9 @@ export class SchematicTracePipelineSolver extends BaseSolver {
           inputTraceMap:
             this.traceOverlapShiftSolver?.correctedTraceMap ??
             Object.fromEntries(
-              this.schematicTraceLinesSolver!.solvedTracePaths.map((p) => [
-                p.mspPairId,
-                p,
-              ]),
+              this.longDistancePairSolver!.getOutput().allTracesMerged.map(
+                (p) => [p.mspPairId, p],
+              ),
             ),
         },
       ],
@@ -143,10 +171,9 @@ export class SchematicTracePipelineSolver extends BaseSolver {
         const traceMap =
           instance.traceOverlapShiftSolver?.correctedTraceMap ??
           Object.fromEntries(
-            instance.schematicTraceLinesSolver!.solvedTracePaths.map((p) => [
-              p.mspPairId,
-              p,
-            ]),
+            instance
+              .longDistancePairSolver!.getOutput()
+              .allTracesMerged.map((p) => [p.mspPairId, p]),
           )
         const traces = Object.values(traceMap)
         const netLabelPlacements =
@@ -160,18 +187,23 @@ export class SchematicTracePipelineSolver extends BaseSolver {
           },
         ]
       },
-      {
-        onSolved: (instance) => {
-          if (
-            instance.traceLabelOverlapAvoidanceSolver &&
-            instance.netLabelPlacementSolver
-          ) {
-            const { netLabelPlacements } =
-              instance.traceLabelOverlapAvoidanceSolver.getOutput()
-            instance.netLabelPlacementSolver.netLabelPlacements =
-              netLabelPlacements
-          }
-        },
+    ),
+    definePipelineStep(
+      "netLabelPlacementSolver",
+      NetLabelPlacementSolver,
+      (instance) => {
+        const traces =
+          instance.traceCleanupSolver?.getOutput().traces ??
+          instance.traceLabelOverlapAvoidanceSolver!.getOutput().traces
+
+        return [
+          {
+            inputProblem: instance.inputProblem,
+            inputTraceMap: Object.fromEntries(
+              traces.map((trace: SolvedTracePath) => [trace.mspPairId, trace]),
+            ),
+          },
+        ]
       },
     ),
   ]
@@ -281,16 +313,19 @@ export class SchematicTracePipelineSolver extends BaseSolver {
         }) as GraphicsObject[]),
     ]
 
-    if (visualizations.length === 1) return visualizations[0]!
+    if (visualizations.length === 1) {
+      return visualizations[0]!
+    }
 
     // Simple combination of visualizations
-    return {
+    const finalGraphics = {
       points: visualizations.flatMap((v) => v.points || []),
       rects: visualizations.flatMap((v) => v.rects || []),
       lines: visualizations.flatMap((v) => v.lines || []),
       circles: visualizations.flatMap((v) => v.circles || []),
       texts: visualizations.flatMap((v) => v.texts || []),
     }
+    return finalGraphics
   }
 
   /**