@tscircuit/schematic-trace-solver 0.0.46 → 0.0.48

package/lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/SingleNetLabelPlacementSolver_visualize.ts

@@ -47,6 +47,14 @@ export function visualizeSingleNetLabelPlacementSolver(
           : c.status === "trace-collision"
             ? "orange"
             : "gray"
+    const candidateLabel =
+      c.status === "ok"
+        ? "status: ok(valid net label candidate)"
+        : c.status === "chip-collision"
+          ? "status: chip-collision"
+          : c.status === "trace-collision"
+            ? "status: trace-collision"
+            : "status: parallel-to-segment"
 
     graphics.rects!.push({
       center: {
@@ -57,12 +65,14 @@ export function visualizeSingleNetLabelPlacementSolver(
       height: c.height,
       fill,
       strokeColor: stroke,
+      label: `${candidateLabel}\norientation: ${c.orientation}`,
     } as any)
 
     graphics.points!.push({
       x: c.anchor.x,
       y: c.anchor.y,
       color: stroke,
+      label: `anchor\norientation: ${c.orientation}`,
     } as any)
   }
 
@@ -75,11 +85,13 @@ export function visualizeSingleNetLabelPlacementSolver(
       height: p.height,
       fill: "rgba(0, 128, 255, 0.35)",
       strokeColor: "blue",
+      label: `netId: ${p.netId}\nglobalConnNetId: ${p.globalConnNetId}`,
     } as any)
     graphics.points!.push({
       x: p.anchorPoint.x,
       y: p.anchorPoint.y,
       color: "blue",
+      label: `anchor\norientation: ${p.orientation}`,
     } as any)
   }
 

package/lib/solvers/TraceLabelOverlapAvoidanceSolver/TraceLabelOverlapAvoidanceSolver.ts

@@ -7,6 +7,7 @@ import type { InputProblem } from "../../types/InputProblem"
 import { MergedNetLabelObstacleSolver } from "./sub-solvers/LabelMergingSolver/LabelMergingSolver"
 import { getColorFromString } from "lib/utils/getColorFromString"
 import { OverlapAvoidanceStepSolver } from "./sub-solvers/OverlapAvoidanceStepSolver/OverlapAvoidanceStepSolver"
+import { detectTraceLabelOverlap } from "./detectTraceLabelOverlap"
 
 interface TraceLabelOverlapAvoidanceSolverInput {
   inputProblem: InputProblem
@@ -15,87 +16,110 @@ interface TraceLabelOverlapAvoidanceSolverInput {
 }
 
 /**
- * A pipeline solver responsible for resolving overlaps between schematic traces and net labels.
+ * Resolves overlaps between schematic traces and net labels using a two-phase,
+ * "fire-and-forget" dispatching strategy.
  *
- * This solver orchestrates a sequence of sub-solvers to achieve its goal:
- * 1. **MergedNetLabelObstacleSolver**: This solver first merges labels that are
- *    close to each other to form larger "obstacle" groups. This simplifies the
- *    problem by reducing the number of individual obstacles the traces need to avoid.
- * 2. **OverlapAvoidanceStepSolver**: This solver then takes the output of the merging
- *    step and iteratively attempts to reroute traces to avoid the merged label obstacles.
- *    It handles one overlap at a time, making it a step-by-step process.
+ * This solver operates in two distinct phases:
  *
- * The final output is a set of modified traces that have been rerouted to avoid
- * labels, and the set of merged labels that were used as obstacles.
+ * 1.  **Dispatch Phase**: Iterates through traces, identifying clean ones and dispatching
+ *     colliding ones to dedicated `OverlapAvoidanceStepSolver` instances.
  *
- * @param {TraceLabelOverlapAvoidanceSolverInput} solverInput - The input for the solver,
- *   containing the initial traces, label placements, and the input problem definition.
+ * 2.  **Execution Phase**: Steps through all dispatched sub-solvers until they complete.
+ *
+ * The final output combines clean traces with results from sub-solvers. A final
+ * `MergedNetLabelObstacleSolver` ensures pipeline compatibility.
  */
 export class TraceLabelOverlapAvoidanceSolver extends BaseSolver {
   inputProblem: InputProblem
-  traces: SolvedTracePath[]
   netLabelPlacements: NetLabelPlacement[]
 
-  // sub-solver instances
+  unprocessedTraces: SolvedTracePath[] = []
+  cleanTraces: SolvedTracePath[] = []
+  subSolvers: OverlapAvoidanceStepSolver[] = []
+  private phase: "searching_for_overlaps" | "fixing_overlaps" =
+    "searching_for_overlaps"
+  detourCounts: Map<string, number> = new Map()
+
   labelMergingSolver?: MergedNetLabelObstacleSolver
-  overlapAvoidanceSolver?: OverlapAvoidanceStepSolver
-  pipelineStepIndex = 0
 
   constructor(solverInput: TraceLabelOverlapAvoidanceSolverInput) {
     super()
     this.inputProblem = solverInput.inputProblem
-    this.traces = solverInput.traces
+    this.unprocessedTraces = [...solverInput.traces]
     this.netLabelPlacements = solverInput.netLabelPlacements
+    this.cleanTraces = []
+    this.subSolvers = []
   }
 
   override _step() {
-    // If a sub-solver is active, step it and check for completion.
-    if (this.activeSubSolver) {
-      this.activeSubSolver.step()
-
-      if (this.activeSubSolver.solved) {
-        this.activeSubSolver = null
-        this.pipelineStepIndex++
-      } else if (this.activeSubSolver.failed) {
-        this.failed = true // If any sub-solver fails, the whole thing fails
-        this.activeSubSolver = null
+    if (this.phase === "searching_for_overlaps") {
+      if (this.unprocessedTraces.length === 0) {
+        console.log(
+          `Dispatch phase complete. Created ${this.subSolvers.length} sub-solvers.`,
+        )
+        this.phase = "fixing_overlaps"
+        return
       }
-      return // Return to allow the sub-solver to run
-    }
 
-    // If no sub-solver is active, create the next one in the pipeline.
-    switch (this.pipelineStepIndex) {
-      case 0:
-        this.labelMergingSolver = new MergedNetLabelObstacleSolver({
-          netLabelPlacements: this.netLabelPlacements,
+      const currentTargetTrace = this.unprocessedTraces.shift()!
+
+      const localOverlaps = detectTraceLabelOverlap({
+        traces: [currentTargetTrace],
+        netLabels: this.netLabelPlacements,
+      })
+
+      if (localOverlaps.length === 0) {
+        this.cleanTraces.push(currentTargetTrace)
+      } else {
+        // Dispatch a new sub-solver for this dirty trace
+        const collidingLabels = localOverlaps.map((o) => o.label)
+        const labelMerger = new MergedNetLabelObstacleSolver({
+          netLabelPlacements: collidingLabels,
           inputProblem: this.inputProblem,
-          traces: this.traces,
+          traces: [currentTargetTrace],
         })
-        this.activeSubSolver = this.labelMergingSolver
-        break
+        labelMerger.solve()
+        const mergingOutput = labelMerger.getOutput()
 
-      case 1:
-        this.overlapAvoidanceSolver = new OverlapAvoidanceStepSolver({
+        const subSolver = new OverlapAvoidanceStepSolver({
           inputProblem: this.inputProblem,
-          traces: this.traces,
-          initialNetLabelPlacements: this.netLabelPlacements, // The original, unfiltered list
-          mergedNetLabelPlacements:
-            this.labelMergingSolver!.getOutput().netLabelPlacements,
-          mergedLabelNetIdMap:
-            this.labelMergingSolver!.getOutput().mergedLabelNetIdMap,
+          traces: [currentTargetTrace],
+          initialNetLabelPlacements: this.netLabelPlacements,
+          mergedNetLabelPlacements: mergingOutput.netLabelPlacements,
+          mergedLabelNetIdMap: mergingOutput.mergedLabelNetIdMap,
+          detourCounts: this.detourCounts,
         })
-        this.activeSubSolver = this.overlapAvoidanceSolver
-        break
-
-      default:
+        this.subSolvers.push(subSolver)
+      }
+    } else if (this.phase === "fixing_overlaps") {
+      if (this.subSolvers.every((s) => s.solved || s.failed)) {
+        console.log("All sub-solvers finished.")
+        // Final merge for pipeline compatibility
+        if (!this.labelMergingSolver) {
+          this.labelMergingSolver = new MergedNetLabelObstacleSolver({
+            netLabelPlacements: this.netLabelPlacements,
+            inputProblem: this.inputProblem,
+            traces: this.getOutput().traces,
+          })
+          this.labelMergingSolver.solve()
+        }
         this.solved = true
-        break
+        return
+      }
+
+      // Step through all active sub-solvers
+      for (const solver of this.subSolvers) {
+        if (!solver.solved && !solver.failed) {
+          solver.step()
+        }
+      }
     }
   }
 
   getOutput() {
+    const solvedTraces = this.subSolvers.flatMap((s) => s.getOutput().allTraces)
     return {
-      traces: this.overlapAvoidanceSolver?.getOutput().allTraces ?? this.traces,
+      traces: [...this.cleanTraces, ...solvedTraces],
       netLabelPlacements:
         this.labelMergingSolver?.getOutput().netLabelPlacements ??
         this.netLabelPlacements,
@@ -103,26 +127,30 @@ export class TraceLabelOverlapAvoidanceSolver extends BaseSolver {
   }
 
   override visualize(): GraphicsObject {
-    if (this.activeSubSolver) {
-      return this.activeSubSolver.visualize()
-    }
-
-    // When no sub-solver is active, show the current state of the pipeline
     const graphics = visualizeInputProblem(this.inputProblem)
     if (!graphics.lines) graphics.lines = []
     if (!graphics.rects) graphics.rects = []
 
-    const output = this.getOutput()
-
-    for (const trace of output.traces) {
+    // Show clean traces in purple
+    for (const trace of this.cleanTraces) {
       graphics.lines!.push({
         points: trace.tracePath,
         strokeColor: "purple",
       })
     }
 
-    for (const label of output.netLabelPlacements) {
-      const color = getColorFromString(label.globalConnNetId, 0.3)
+    // Delegate visualization to sub-solvers
+    for (const solver of this.subSolvers) {
+      const solverGraphics = solver.visualize()
+      graphics.lines!.push(...(solverGraphics.lines ?? []))
+      graphics.rects!.push(...(solverGraphics.rects ?? []))
+      // graphics.texts!.push(...(solverGraphics.texts ?? []))
+      graphics.points!.push(...(solverGraphics.points ?? []))
+    }
+
+    // Also show original labels
+    for (const label of this.netLabelPlacements) {
+      const color = getColorFromString(label.globalConnNetId, 0.3) // Make fill opaque
       graphics.rects!.push({
         center: label.center,
         width: label.width,

package/lib/solvers/TraceLabelOverlapAvoidanceSolver/rerouteCollidingTrace.ts

@@ -8,6 +8,18 @@ import { generateSnipAndReconnectCandidates } from "./trySnipAndReconnect"
 import { generateFourPointDetourCandidates } from "./tryFourPointDetour"
 import { simplifyPath } from "../TraceCleanupSolver/simplifyPath"
 
+/**
+ * Generates a list of candidate rerouted paths for a given trace that is
+ * colliding with a net label.
+ *
+ * This function employs multiple strategies to propose alternative paths:
+ * 1.  **Four-Point Detour:** Creates a rectangular detour around the label.
+ * 2.  **Snip and Reconnect:** Attempts to remove the colliding segment and
+ *     reconnect the trace around the obstacle.
+ *
+ * The candidates are generated with increasing padding based on `detourCount`
+ * to explore progressively wider detours.
+ */
 export const generateRerouteCandidates = ({
   trace,
   label,
@@ -26,13 +38,12 @@ export const generateRerouteCandidates = ({
     return [initialTrace.tracePath]
   }
 
-  const labelPadding = paddingBuffer
   const labelBoundsRaw = getRectBounds(label.center, label.width, label.height)
   const labelBounds = {
-    minX: labelBoundsRaw.minX - labelPadding,
-    minY: labelBoundsRaw.minY - labelPadding,
-    maxX: labelBoundsRaw.maxX + labelPadding,
-    maxY: labelBoundsRaw.maxY + labelPadding,
+    minX: labelBoundsRaw.minX,
+    minY: labelBoundsRaw.minY,
+    maxX: labelBoundsRaw.maxX,
+    maxY: labelBoundsRaw.maxY,
     chipId: `netlabel-${label.netId}`,
   }
 

package/lib/solvers/TraceLabelOverlapAvoidanceSolver/sub-solvers/OverlapAvoidanceStepSolver/OverlapAvoidanceStepSolver.ts

@@ -6,7 +6,7 @@ import { visualizeInputProblem } from "lib/solvers/SchematicTracePipelineSolver/
 import type { InputProblem } from "lib/types/InputProblem"
 import { detectTraceLabelOverlap } from "../../detectTraceLabelOverlap"
 import { SingleOverlapSolver } from "../SingleOverlapSolver/SingleOverlapSolver"
-import { isPointInsideLabel } from "./isPointInsideLabel"
+import { doesTraceStartOrEndInLabel } from "./doesTraceStartOrEndInLabel"
 import { visualizeDecomposition } from "./visualizeDecomposition"
 
 type Overlap = ReturnType<typeof detectTraceLabelOverlap>[0]
@@ -18,6 +18,7 @@ export interface OverlapCollectionSolverInput {
   initialNetLabelPlacements: NetLabelPlacement[]
   mergedNetLabelPlacements: NetLabelPlacement[]
   mergedLabelNetIdMap: Record<string, Set<string>>
+  detourCounts: Map<string, number>
 }
 
 /**
@@ -33,8 +34,8 @@ export class OverlapAvoidanceStepSolver extends BaseSolver {
   allTraces: SolvedTracePath[]
   modifiedTraces: SolvedTracePath[] = []
 
-  private detourCountByLabel: Record<string, number> = {}
   private readonly PADDING_BUFFER = 0.1
+  private detourCounts: Map<string, number> = new Map()
 
   public override activeSubSolver: SingleOverlapSolver | null = null
   private overlapQueue: Overlap[] = []
@@ -50,6 +51,7 @@ export class OverlapAvoidanceStepSolver extends BaseSolver {
     this.mergedNetLabelPlacements = solverInput.mergedNetLabelPlacements
     this.mergedLabelNetIdMap = solverInput.mergedLabelNetIdMap
     this.allTraces = [...solverInput.traces]
+    this.detourCounts = solverInput.detourCounts
   }
 
   override _step() {
@@ -111,7 +113,6 @@ export class OverlapAvoidanceStepSolver extends BaseSolver {
         (t) => t.mspPairId === nextOverlap.trace.mspPairId,
       )!
       const labelToAvoid = nextOverlap.label
-      const traceStartPoint = traceToFix.tracePath[0]
 
       const originalNetIds =
         this.mergedLabelNetIdMap[labelToAvoid.globalConnNetId]
@@ -136,15 +137,19 @@ export class OverlapAvoidanceStepSolver extends BaseSolver {
         }
 
         if (actualOverlapLabel) {
-          const labelId = actualOverlapLabel.globalConnNetId
-          const detourCount = this.detourCountByLabel[labelId] || 0
-          this.detourCountByLabel[labelId] = detourCount + 1
+          const detourCount =
+            this.detourCounts.get(actualOverlapLabel.globalConnNetId) ?? 0
+          this.detourCounts.set(
+            actualOverlapLabel.globalConnNetId,
+            detourCount + 1,
+          )
+
           this.activeSubSolver = new SingleOverlapSolver({
             trace: traceToFix,
             label: actualOverlapLabel,
             problem: this.inputProblem,
             paddingBuffer: this.PADDING_BUFFER,
-            detourCount,
+            detourCount: detourCount,
           })
         } else {
           const overlapId = `${traceToFix.mspPairId}-${labelToAvoid.globalConnNetId}`
@@ -155,7 +160,7 @@ export class OverlapAvoidanceStepSolver extends BaseSolver {
 
       if (
         originalNetIds &&
-        isPointInsideLabel({ point: traceStartPoint, label: labelToAvoid })
+        doesTraceStartOrEndInLabel({ trace: traceToFix, label: labelToAvoid })
       ) {
         const childLabels = this.initialNetLabelPlacements.filter((l) =>
           originalNetIds.has(l.globalConnNetId),
@@ -175,15 +180,18 @@ export class OverlapAvoidanceStepSolver extends BaseSolver {
         }
 
         if (actualOverlapLabel) {
-          const labelId = actualOverlapLabel.globalConnNetId
-          const detourCount = this.detourCountByLabel[labelId] || 0
-          this.detourCountByLabel[labelId] = detourCount + 1
+          const detourCount =
+            this.detourCounts.get(actualOverlapLabel.globalConnNetId) ?? 0
+          this.detourCounts.set(
+            actualOverlapLabel.globalConnNetId,
+            detourCount + 1,
+          )
           this.activeSubSolver = new SingleOverlapSolver({
             trace: traceToFix,
             label: actualOverlapLabel,
             problem: this.inputProblem,
             paddingBuffer: this.PADDING_BUFFER,
-            detourCount,
+            detourCount: detourCount,
           })
         } else {
           const overlapId = `${traceToFix.mspPairId}-${labelToAvoid.globalConnNetId}`
@@ -192,15 +200,17 @@ export class OverlapAvoidanceStepSolver extends BaseSolver {
         return
       }
 
-      const labelId = labelToAvoid.globalConnNetId
-      const detourCount = this.detourCountByLabel[labelId] || 0
-      this.detourCountByLabel[labelId] = detourCount + 1
+      // STRATEGY 3: Real collision between different nets.
+      // We must reroute around the entire merged label.
+      const detourCount =
+        this.detourCounts.get(labelToAvoid.globalConnNetId) ?? 0
+      this.detourCounts.set(labelToAvoid.globalConnNetId, detourCount + 1)
       this.activeSubSolver = new SingleOverlapSolver({
         trace: traceToFix,
         label: labelToAvoid,
         problem: this.inputProblem,
         paddingBuffer: this.PADDING_BUFFER,
-        detourCount,
+        detourCount: detourCount,
       })
     }
   }
@@ -209,6 +219,7 @@ export class OverlapAvoidanceStepSolver extends BaseSolver {
     return {
       allTraces: this.allTraces,
       modifiedTraces: this.modifiedTraces,
+      detourCounts: this.detourCounts,
     }
   }
 

package/lib/solvers/TraceLabelOverlapAvoidanceSolver/sub-solvers/OverlapAvoidanceStepSolver/doesTraceStartOrEndInLabel.ts

@@ -0,0 +1,58 @@
+import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import { detectTraceLabelOverlap } from "../../detectTraceLabelOverlap"
+
+interface Props {
+  trace: SolvedTracePath
+  label: NetLabelPlacement
+}
+
+/**
+ * Checks if the first or last segment of a given trace overlaps with a specified net label.
+ * This is useful for determining if a trace begins or ends within an obstacle.
+ */
+export const doesTraceStartOrEndInLabel = ({ trace, label }: Props) => {
+  if (trace.tracePath.length < 2) {
+    return false // Not a valid trace with segments
+  }
+
+  // Create a mini-trace for the first segment
+  const firstSegmentTrace: SolvedTracePath = {
+    ...trace,
+    tracePath: [trace.tracePath[0], trace.tracePath[1]],
+  }
+
+  // Check for overlap with the first segment
+  const firstSegmentOverlap = detectTraceLabelOverlap({
+    traces: [firstSegmentTrace],
+    netLabels: [label],
+  })
+
+  if (firstSegmentOverlap.length > 0) {
+    return true
+  }
+
+  // If the trace has more than one segment, check the last one
+  if (trace.tracePath.length > 2) {
+    const lastPoint = trace.tracePath[trace.tracePath.length - 1]
+    const secondToLastPoint = trace.tracePath[trace.tracePath.length - 2]
+
+    // Create a mini-trace for the last segment
+    const lastSegmentTrace: SolvedTracePath = {
+      ...trace,
+      tracePath: [secondToLastPoint, lastPoint],
+    }
+
+    // Check for overlap with the last segment
+    const lastSegmentOverlap = detectTraceLabelOverlap({
+      traces: [lastSegmentTrace],
+      netLabels: [label],
+    })
+
+    if (lastSegmentOverlap.length > 0) {
+      return true
+    }
+  }
+
+  return false
+}

package/lib/solvers/TraceLabelOverlapAvoidanceSolver/sub-solvers/SingleOverlapSolver/SingleOverlapSolver.ts

@@ -18,6 +18,8 @@ interface SingleOverlapSolverInput {
   detourCount: number
 }
 
+const MAX_TRIES = 5
+
 /**
  * This solver attempts to find a valid rerouting for a single trace that is
  * overlapping with a net label. It tries various candidate paths until it
@@ -30,6 +32,7 @@ export class SingleOverlapSolver extends BaseSolver {
   problem: InputProblem
   obstacles: ReturnType<typeof getObstacleRects>
   label: NetLabelPlacement
+  _tried: number = 0
 
   constructor(solverInput: SingleOverlapSolverInput) {
     super()
@@ -37,8 +40,14 @@ export class SingleOverlapSolver extends BaseSolver {
     this.problem = solverInput.problem
     this.label = solverInput.label
 
+    // Calculate an effective padding for this specific run based on the detourCount.
+    const effectivePadding =
+      solverInput.paddingBuffer +
+      solverInput.detourCount * solverInput.paddingBuffer
+
     const candidates = generateRerouteCandidates({
       ...solverInput,
+      paddingBuffer: effectivePadding, // Use the calculated, larger padding
     })
 
     const getPathLength = (pts: Point[]) => {
@@ -58,11 +67,13 @@ export class SingleOverlapSolver extends BaseSolver {
   }
 
   override _step() {
-    if (this.queuedCandidatePaths.length === 0) {
+    // Failure conditions: no more candidates or exceeded max tries
+    if (this.queuedCandidatePaths.length === 0 || this._tried >= MAX_TRIES) {
       this.failed = true
       return
     }
 
+    this._tried++
     const nextCandidatePath = this.queuedCandidatePaths.shift()!
     const simplifiedPath = simplifyPath(nextCandidatePath)
 
@@ -70,6 +81,7 @@ export class SingleOverlapSolver extends BaseSolver {
       this.solvedTracePath = simplifiedPath
       this.solved = true
     }
+    // If the path collides, we simply do nothing and let the next step try another candidate.
   }
 
   override visualize(): GraphicsObject {