@tscircuit/schematic-trace-solver 0.0.40 → 0.0.42

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]
 }

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

@@ -0,0 +1,205 @@
+import type { SolvedTracePath } from "../../../SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import { BaseSolver } from "lib/solvers/BaseSolver/BaseSolver"
+import type { NetLabelPlacement } from "../../../NetLabelPlacementSolver/NetLabelPlacementSolver"
+import { getRectBounds } from "../../../NetLabelPlacementSolver/SingleNetLabelPlacementSolver/geometry"
+import type { GraphicsObject, Line } from "graphics-debug"
+import { getColorFromString } from "lib/utils/getColorFromString"
+import { visualizeInputProblem } from "lib/solvers/SchematicTracePipelineSolver/visualizeInputProblem"
+import type { InputProblem } from "lib/types/InputProblem"
+
+interface LabelMergingSolverInput {
+  netLabelPlacements: NetLabelPlacement[]
+  inputProblem: InputProblem
+  traces: SolvedTracePath[]
+}
+
+interface LabelMergingSolverOutput {
+  netLabelPlacements: NetLabelPlacement[]
+  mergedLabelNetIdMap: Record<string, Set<string>>
+}
+
+/**
+ * Merges multiple net labels into a single, larger label if they are on the
+ * same side of the same chip, reducing schematic clutter.
+ */
+export class MergedNetLabelObstacleSolver extends BaseSolver {
+  private input: LabelMergingSolverInput
+  private output!: LabelMergingSolverOutput
+  private inputProblem: InputProblem
+  private traces: SolvedTracePath[]
+
+  constructor(solverInput: LabelMergingSolverInput) {
+    // console.log(JSON.stringify(solverInput));
+
+    super()
+    this.input = solverInput
+    this.inputProblem = solverInput.inputProblem
+    this.traces = solverInput.traces
+
+    // Initialize output to a default state to allow visualization before the first step
+    this.output = {
+      netLabelPlacements: solverInput.netLabelPlacements,
+      mergedLabelNetIdMap: {},
+    }
+  }
+
+  override _step() {
+    const originalLabels = this.input.netLabelPlacements
+    const mergedLabelNetIdMap: Record<string, Set<string>> = {}
+
+    if (!originalLabels || originalLabels.length === 0) {
+      this.output = {
+        netLabelPlacements: [],
+        mergedLabelNetIdMap: {},
+      }
+      this.solved = true
+      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
+      let minY = Infinity
+      let maxX = -Infinity
+      let 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))
+      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.output = {
+      netLabelPlacements: finalPlacements,
+      mergedLabelNetIdMap,
+    }
+    this.solved = true
+  }
+
+  getOutput(): LabelMergingSolverOutput {
+    return this.output
+  }
+
+  override visualize(): GraphicsObject {
+    const graphics = visualizeInputProblem(this.inputProblem, {
+      chipAlpha: 0.1,
+      connectionAlpha: 0.1,
+    })
+
+    if (!graphics.rects) graphics.rects = []
+    if (!graphics.lines) graphics.lines = []
+    if (!graphics.points) graphics.points = []
+    if (!graphics.texts) graphics.texts = []
+
+    const originalLabelsById = new Map<string, NetLabelPlacement>()
+    for (const label of this.input.netLabelPlacements) {
+      originalLabelsById.set(label.globalConnNetId, label)
+    }
+
+    for (const trace of this.traces) {
+      const line: Line = {
+        points: trace.tracePath.map((p) => ({ x: p.x, y: p.y })),
+        strokeColor: "blue",
+      }
+      graphics.lines!.push(line)
+    }
+
+    for (const finalLabel of this.output.netLabelPlacements) {
+      const isMerged = finalLabel.globalConnNetId.startsWith("merged-group-")
+      const color = getColorFromString(finalLabel.globalConnNetId)
+
+      if (isMerged) {
+        // Draw the new merged label
+        graphics.rects.push({
+          center: finalLabel.center,
+          width: finalLabel.width,
+          height: finalLabel.height,
+          fill: color.replace(/, 1\)/, ", 0.2)"), // semi-transparent
+          stroke: color,
+          label: finalLabel.globalConnNetId,
+        })
+
+        const originalNetIds =
+          this.output.mergedLabelNetIdMap[finalLabel.globalConnNetId]
+        if (originalNetIds) {
+          for (const originalNetId of originalNetIds) {
+            const originalLabel = originalLabelsById.get(originalNetId)
+            if (originalLabel) {
+              // Draw the original label as a dashed box
+              const bounds = getRectBounds(
+                originalLabel.center,
+                originalLabel.width,
+                originalLabel.height,
+              )
+              const p1 = { x: bounds.minX, y: bounds.minY }
+              const p2 = { x: bounds.maxX, y: bounds.minY }
+              const p3 = { x: bounds.maxX, y: bounds.maxY }
+              const p4 = { x: bounds.minX, y: bounds.maxY }
+              graphics.lines.push({
+                points: [p1, p2, p3, p4, p1],
+                strokeColor: color,
+                strokeDash: "4 4",
+              })
+              // Draw line from original to new center
+              graphics.lines.push({
+                points: [originalLabel.center, finalLabel.center],
+                strokeColor: color,
+                strokeDash: "2 2",
+              })
+            }
+          }
+        }
+      } else {
+        // Draw un-merged labels
+        graphics.rects.push({
+          center: finalLabel.center,
+          width: finalLabel.width,
+          height: finalLabel.height,
+          stroke: color,
+          label: finalLabel.globalConnNetId,
+        })
+      }
+    }
+
+    return graphics
+  }
+}