@tscircuit/schematic-trace-solver 0.0.41 → 0.0.42

package/lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver.ts

@@ -7,16 +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
@@ -63,7 +66,9 @@ export class SchematicTracePipelineSolver extends BaseSolver {
   longDistancePairSolver?: LongDistancePairSolver
   traceOverlapShiftSolver?: TraceOverlapShiftSolver
   netLabelPlacementSolver?: NetLabelPlacementSolver
+  labelMergingSolver?: MergedNetLabelObstacleSolver
   traceLabelOverlapAvoidanceSolver?: TraceLabelOverlapAvoidanceSolver
+  traceCleanupSolver?: TraceCleanupSolver
 
   startTimeOfPhase: Record<string, number>
   endTimeOfPhase: Record<string, number>
@@ -182,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]),
+            ),
+          },
+        ]
       },
     ),
   ]
@@ -303,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
   }
 
   /**

package/lib/solvers/TraceLabelOverlapAvoidanceSolver/TraceLabelOverlapAvoidanceSolver.ts

@@ -1,16 +1,13 @@
 import { BaseSolver } from "../BaseSolver/BaseSolver"
-import { detectTraceLabelOverlap } from "./detectTraceLabelOverlap"
-import { rerouteCollidingTrace } from "./rerouteCollidingTrace"
 import type { SolvedTracePath } from "../SchematicTraceLinesSolver/SchematicTraceLinesSolver"
 import type { NetLabelPlacement } from "../NetLabelPlacementSolver/NetLabelPlacementSolver"
 import type { GraphicsObject } from "graphics-debug"
 import { visualizeInputProblem } from "../SchematicTracePipelineSolver/visualizeInputProblem"
-import { getRectBounds } from "../NetLabelPlacementSolver/SingleNetLabelPlacementSolver/geometry"
+import type { InputProblem } from "../../types/InputProblem"
+import { MergedNetLabelObstacleSolver } from "./sub-solvers/LabelMergingSolver/LabelMergingSolver"
+import { TraceCleanupSolver } from "./sub-solvers/TraceCleanupSolver/TraceCleanupSolver"
 import { getColorFromString } from "lib/utils/getColorFromString"
-import type { InputProblem } from "lib/types/InputProblem"
-import { minimizeTurnsWithFilteredLabels } from "./minimizeTurnsWithFilteredLabels"
-import { balanceLShapes } from "./balanceLShapes"
-import { NetLabelPlacementSolver } from "../NetLabelPlacementSolver/NetLabelPlacementSolver"
+import { OverlapAvoidanceStepSolver } from "./sub-solvers/OverlapAvoidanceStepSolver/OverlapAvoidanceStepSolver"
 
 interface TraceLabelOverlapAvoidanceSolverInput {
   inputProblem: InputProblem
@@ -18,222 +15,127 @@ interface TraceLabelOverlapAvoidanceSolverInput {
   netLabelPlacements: NetLabelPlacement[]
 }
 
+/**
+ * This solver is a pipeline that runs a series of sub-solvers to resolve
+ * trace-label overlaps and clean up the resulting traces.
+ */
 export class TraceLabelOverlapAvoidanceSolver extends BaseSolver {
-  private problem: InputProblem
-  private traces: SolvedTracePath[]
-  private netTempLabelPlacements: NetLabelPlacement[]
-  private netLabelPlacements: NetLabelPlacement[]
-  private updatedTraces: SolvedTracePath[]
-  private mergedLabelNetIdMap: Record<string, Set<string>>
-  private detourCountByLabel: Record<string, number>
-  private readonly PADDING_BUFFER = 0.1
+  inputProblem: InputProblem
+  traces: SolvedTracePath[]
+  netLabelPlacements: NetLabelPlacement[]
+
+  // sub-solver instances
+  labelMergingSolver?: MergedNetLabelObstacleSolver
+  overlapAvoidanceSolver?: OverlapAvoidanceStepSolver
+  traceCleanupSolver?: TraceCleanupSolver
+  pipelineStepIndex = 0
 
   constructor(solverInput: TraceLabelOverlapAvoidanceSolverInput) {
     super()
-    this.problem = solverInput.inputProblem
+    this.inputProblem = solverInput.inputProblem
     this.traces = solverInput.traces
-    this.updatedTraces = [...solverInput.traces]
-    this.mergedLabelNetIdMap = {}
-    this.detourCountByLabel = {}
-
-    const originalLabels = solverInput.netLabelPlacements
-    this.netLabelPlacements = originalLabels
-    if (!originalLabels || originalLabels.length === 0) {
-      this.netTempLabelPlacements = []
-      return
-    }
-
-    const labelGroups: Record<string, NetLabelPlacement[]> = {}
-
-    for (const p of originalLabels) {
-      if (p.pinIds.length === 0) continue
-      const chipId = p.pinIds[0].split(".")[0]
-      if (!chipId) continue
-      const key = `${chipId}-${p.orientation}`
-      if (!(key in labelGroups)) {
-        labelGroups[key] = []
-      }
-      labelGroups[key]!.push(p)
-    }
-
-    const finalPlacements: NetLabelPlacement[] = []
-    for (const [key, group] of Object.entries(labelGroups)) {
-      if (group.length <= 1) {
-        finalPlacements.push(...group)
-        continue
-      }
-
-      let minX = Infinity,
-        minY = Infinity,
-        maxX = -Infinity,
-        maxY = -Infinity
-      for (const p of group) {
-        const bounds = getRectBounds(p.center, p.width, p.height)
-        minX = Math.min(minX, bounds.minX)
-        minY = Math.min(minY, bounds.minY)
-        maxX = Math.max(maxX, bounds.maxX)
-        maxY = Math.max(maxY, bounds.maxY)
-      }
-
-      const newWidth = maxX - minX
-      const newHeight = maxY - minY
-      const template = group[0]!
-      const syntheticId = `merged-group-${key}`
-      const originalNetIds = new Set(group.map((p) => p.globalConnNetId))
-      this.mergedLabelNetIdMap[syntheticId] = originalNetIds
-
-      finalPlacements.push({
-        ...template,
-        globalConnNetId: syntheticId,
-        width: newWidth,
-        height: newHeight,
-        center: { x: minX + newWidth / 2, y: minY + newHeight / 2 },
-        pinIds: [...new Set(group.flatMap((p) => p.pinIds))],
-        mspConnectionPairIds: [
-          ...new Set(group.flatMap((p) => p.mspConnectionPairIds)),
-        ],
-      })
-    }
-
-    this.netTempLabelPlacements = finalPlacements
+    this.netLabelPlacements = solverInput.netLabelPlacements
   }
 
   override _step() {
-    if (
-      !this.traces ||
-      this.traces.length === 0 ||
-      !this.netTempLabelPlacements ||
-      this.netTempLabelPlacements.length === 0
-    ) {
-      this.solved = true
-      return
-    }
-
-    this.detourCountByLabel = {}
-
-    const overlaps = detectTraceLabelOverlap(
-      this.traces,
-      this.netTempLabelPlacements,
-    )
-
-    if (overlaps.length === 0) {
-      this.solved = true
-      return
-    }
-
-    const unfriendlyOverlaps = overlaps.filter((o) => {
-      const originalNetIds = this.mergedLabelNetIdMap[o.label.globalConnNetId]
-      if (originalNetIds) {
-        return !originalNetIds.has(o.trace.globalConnNetId)
+    // 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
       }
-      return o.trace.globalConnNetId !== o.label.globalConnNetId
-    })
-
-    if (unfriendlyOverlaps.length === 0) {
-      this.solved = true
-      return
+      return // Return to allow the sub-solver to run
     }
 
-    const updatedTracesMap: Record<string, SolvedTracePath> = {}
-    for (const trace of this.traces) {
-      updatedTracesMap[trace.mspPairId] = trace
+    // 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,
+          inputProblem: this.inputProblem,
+          traces: this.traces,
+        })
+        this.activeSubSolver = this.labelMergingSolver
+        break
+
+      case 1:
+        this.overlapAvoidanceSolver = new OverlapAvoidanceStepSolver({
+          inputProblem: this.inputProblem,
+          traces: this.traces,
+          netLabelPlacements:
+            this.labelMergingSolver!.getOutput().netLabelPlacements,
+          mergedLabelNetIdMap:
+            this.labelMergingSolver!.getOutput().mergedLabelNetIdMap,
+        })
+        this.activeSubSolver = this.overlapAvoidanceSolver
+        break
+
+      case 2:
+        this.traceCleanupSolver = new TraceCleanupSolver({
+          inputProblem: this.inputProblem,
+          allTraces: this.overlapAvoidanceSolver!.getOutput().allTraces,
+          targetTraceIds: new Set(
+            this.overlapAvoidanceSolver!.getOutput().modifiedTraces.map(
+              (t) => t.mspPairId,
+            ),
+          ),
+          allLabelPlacements:
+            this.labelMergingSolver!.getOutput().netLabelPlacements,
+          mergedLabelNetIdMap:
+            this.labelMergingSolver!.getOutput().mergedLabelNetIdMap,
+          paddingBuffer: 0.01,
+        })
+        this.activeSubSolver = this.traceCleanupSolver
+        break
+
+      default:
+        this.solved = true
+        break
     }
-
-    const processedTraceIds = new Set<string>()
-
-    for (const overlap of unfriendlyOverlaps) {
-      if (processedTraceIds.has(overlap.trace.mspPairId)) {
-        continue
-      }
-
-      const currentTraceState = updatedTracesMap[overlap.trace.mspPairId]!
-      const labelId = overlap.label.globalConnNetId
-      const detourCount = this.detourCountByLabel[labelId] || 0
-
-      const newTrace = rerouteCollidingTrace({
-        trace: currentTraceState,
-        label: overlap.label,
-        problem: this.problem,
-        paddingBuffer: this.PADDING_BUFFER,
-        detourCount,
-      })
-
-      if (newTrace.tracePath !== currentTraceState.tracePath) {
-        this.detourCountByLabel[labelId] = detourCount + 1
-      }
-
-      updatedTracesMap[currentTraceState.mspPairId] = newTrace
-      processedTraceIds.add(currentTraceState.mspPairId)
-    }
-
-    this.updatedTraces = Object.values(updatedTracesMap)
-
-    const minimizedTraces = minimizeTurnsWithFilteredLabels({
-      traces: this.updatedTraces,
-      problem: this.problem,
-      allLabelPlacements: this.netTempLabelPlacements, // Use temp labels which include merged ones
-      mergedLabelNetIdMap: this.mergedLabelNetIdMap,
-      paddingBuffer: this.PADDING_BUFFER,
-    })
-    if (minimizedTraces) {
-      this.updatedTraces = minimizedTraces
-    }
-    const balancedTraces = balanceLShapes({
-      traces: this.updatedTraces,
-      problem: this.problem,
-      allLabelPlacements: this.netLabelPlacements,
-    })
-    if (balancedTraces) {
-      this.updatedTraces = balancedTraces
-    }
-
-    const finalLabelPlacementSolver = new NetLabelPlacementSolver({
-      inputProblem: this.problem,
-      inputTraceMap: Object.fromEntries(
-        this.updatedTraces.map((trace) => [trace.mspPairId, trace]),
-      ),
-    })
-    finalLabelPlacementSolver.solve()
-    if (!finalLabelPlacementSolver.failed) {
-      this.netLabelPlacements = finalLabelPlacementSolver.netLabelPlacements
-    }
-
-    this.solved = true
   }
 
   getOutput() {
     return {
-      traces: this.updatedTraces,
-      netLabelPlacements: this.netLabelPlacements,
+      traces: this.traceCleanupSolver?.getOutput().traces ?? this.traces,
+      netLabelPlacements:
+        this.labelMergingSolver?.getOutput().netLabelPlacements ??
+        this.netLabelPlacements,
     }
   }
 
   override visualize(): GraphicsObject {
-    const graphics = visualizeInputProblem(this.problem)
+    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.circles) graphics.circles = []
-    if (!graphics.texts) graphics.texts = []
     if (!graphics.rects) graphics.rects = []
 
-    for (const trace of this.updatedTraces) {
+    const output = this.getOutput()
+
+    for (const trace of output.traces) {
       graphics.lines!.push({
         points: trace.tracePath,
         strokeColor: "purple",
       })
     }
 
-    for (const p of this.netLabelPlacements) {
+    for (const label of output.netLabelPlacements) {
+      const color = getColorFromString(label.globalConnNetId, 0.3)
       graphics.rects!.push({
-        center: p.center,
-        width: p.width,
-        height: p.height,
-        fill: getColorFromString(p.globalConnNetId, 0.35),
-      })
-      graphics.points!.push({
-        x: p.anchorPoint.x,
-        y: p.anchorPoint.y,
-        color: getColorFromString(p.globalConnNetId, 0.9),
+        center: label.center,
+        width: label.width,
+        height: label.height,
+        fill: color,
+        stroke: color.replace("0.3", "1"),
+        label: label.globalConnNetId,
       })
     }
 

package/lib/solvers/TraceLabelOverlapAvoidanceSolver/rerouteCollidingTrace.ts

@@ -1,16 +1,16 @@
+import type { Point } from "@tscircuit/math-utils"
 import type { SolvedTracePath } from "../SchematicTraceLinesSolver/SchematicTraceLinesSolver"
 import type { NetLabelPlacement } from "../NetLabelPlacementSolver/NetLabelPlacementSolver"
 import { getRectBounds } from "../NetLabelPlacementSolver/SingleNetLabelPlacementSolver/geometry"
-import { getObstacleRects } from "../SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/rect"
 import type { InputProblem } from "lib/types/InputProblem"
 import { findTraceViolationZone } from "./violation"
-import { tryFourPointDetour, trySnipAndReconnect } from "./trySnipAndReconnect"
-import { simplifyPath } from "./simplifyPath"
+import { generateSnipAndReconnectCandidates } from "./trySnipAndReconnect"
+import { simplifyPath } from "./sub-solvers/TraceCleanupSolver/simplifyPath"
+import { generateFourPointDetourCandidates } from "./tryFourPointDetour"
 
-export const rerouteCollidingTrace = ({
+export const generateRerouteCandidates = ({
   trace,
   label,
-  problem,
   paddingBuffer,
   detourCount,
 }: {
@@ -19,14 +19,13 @@ export const rerouteCollidingTrace = ({
   problem: InputProblem
   paddingBuffer: number
   detourCount: number
-}): SolvedTracePath => {
+}): Point[][] => {
   const initialTrace = { ...trace, tracePath: simplifyPath(trace.tracePath) }
 
   if (trace.globalConnNetId === label.globalConnNetId) {
-    return initialTrace
+    return [initialTrace.tracePath]
   }
 
-  const obstacles = getObstacleRects(problem)
   const labelPadding = paddingBuffer
   const labelBoundsRaw = getRectBounds(label.center, label.width, label.height)
   const labelBounds = {
@@ -37,37 +36,27 @@ export const rerouteCollidingTrace = ({
     chipId: `netlabel-${label.netId}`,
   }
 
-  const fourPointResult = tryFourPointDetour({
+  const fourPointCandidates = generateFourPointDetourCandidates({
     initialTrace,
     label,
     labelBounds,
-    obstacles,
     paddingBuffer,
     detourCount,
   })
-  if (fourPointResult) {
-    initialTrace.tracePath = fourPointResult.tracePath
-  }
+
   const { firstInsideIndex, lastInsideIndex } = findTraceViolationZone(
     initialTrace.tracePath,
     labelBounds,
   )
 
-  const snipReconnectResult = trySnipAndReconnect({
+  const snipReconnectCandidates = generateSnipAndReconnectCandidates({
     initialTrace,
     firstInsideIndex,
     lastInsideIndex,
     labelBounds,
-    obstacles,
+    paddingBuffer,
+    detourCount,
   })
 
-  if (snipReconnectResult) {
-    return snipReconnectResult
-  }
-
-  if (fourPointResult) {
-    return fourPointResult
-  }
-
-  return initialTrace
+  return [...fourPointCandidates, ...snipReconnectCandidates]
 }