@tscircuit/schematic-trace-solver 0.0.41 → 0.0.43

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

@@ -0,0 +1,144 @@
+import type { GraphicsObject } from "graphics-debug"
+import { BaseSolver } from "lib/solvers/BaseSolver/BaseSolver"
+import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import { visualizeInputProblem } from "lib/solvers/SchematicTracePipelineSolver/visualizeInputProblem"
+import type { InputProblem } from "lib/types/InputProblem"
+import { detectTraceLabelOverlap } from "../../detectTraceLabelOverlap"
+import { SingleOverlapSolver } from "../SingleOverlapSolver/SingleOverlapSolver"
+
+type Overlap = ReturnType<typeof detectTraceLabelOverlap>[0]
+
+// Define a type for the input of the internal overlap solver to avoid conflicts
+interface OverlapCollectionSolverInput {
+  inputProblem: InputProblem
+  traces: SolvedTracePath[]
+  netLabelPlacements: NetLabelPlacement[]
+  mergedLabelNetIdMap: Record<string, Set<string>>
+}
+
+/**
+ * This is an internal solver that manages the step-by-step process of avoiding
+ * multiple overlaps. It follows the pattern of SchematicTraceLinesSolver.
+ */
+export class OverlapAvoidanceStepSolver extends BaseSolver {
+  inputProblem: InputProblem
+  netLabelPlacements: NetLabelPlacement[]
+  mergedLabelNetIdMap: Record<string, Set<string>>
+
+  allTraces: SolvedTracePath[]
+  modifiedTraces: SolvedTracePath[] = []
+
+  private detourCountByLabel: Record<string, number> = {}
+  private readonly PADDING_BUFFER = 0.1
+
+  public override activeSubSolver: SingleOverlapSolver | null = null
+  private overlapQueue: Overlap[] = []
+  private recentlyFailed: Set<string> = new Set()
+
+  constructor(solverInput: OverlapCollectionSolverInput) {
+    super()
+    this.inputProblem = solverInput.inputProblem
+    this.netLabelPlacements = solverInput.netLabelPlacements
+    this.mergedLabelNetIdMap = solverInput.mergedLabelNetIdMap
+    this.allTraces = [...solverInput.traces]
+  }
+
+  override _step() {
+    if (this.activeSubSolver) {
+      this.activeSubSolver.step()
+
+      if (this.activeSubSolver.solved) {
+        const solvedPath = this.activeSubSolver.solvedTracePath
+        if (solvedPath) {
+          const traceIndex = this.allTraces.findIndex(
+            (t) => t.mspPairId === this.activeSubSolver!.initialTrace.mspPairId,
+          )
+          if (traceIndex !== -1) {
+            this.allTraces[traceIndex].tracePath = solvedPath
+            this.modifiedTraces.push(this.allTraces[traceIndex])
+          }
+        }
+        this.activeSubSolver = null
+        this.recentlyFailed.clear()
+      } else if (this.activeSubSolver.failed) {
+        const overlapId = `${this.activeSubSolver.initialTrace.mspPairId}-${this.activeSubSolver.label.globalConnNetId}`
+        this.recentlyFailed.add(overlapId)
+        this.activeSubSolver = null
+      }
+      return
+    }
+
+    const overlaps = detectTraceLabelOverlap(
+      this.allTraces,
+      this.netLabelPlacements,
+    ).filter((o) => {
+      const originalNetIds = this.mergedLabelNetIdMap[o.label.globalConnNetId]
+      if (originalNetIds) {
+        return !originalNetIds.has(o.trace.globalConnNetId)
+      }
+      return o.trace.globalConnNetId !== o.label.globalConnNetId
+    })
+
+    if (overlaps.length === 0) {
+      this.solved = true
+      return
+    }
+
+    const nonFailedOverlaps = overlaps.filter((o) => {
+      const overlapId = `${o.trace.mspPairId}-${o.label.globalConnNetId}`
+      return !this.recentlyFailed.has(overlapId)
+    })
+
+    if (nonFailedOverlaps.length === 0) {
+      this.solved = true // No more progress can be made
+      return
+    }
+
+    this.overlapQueue = nonFailedOverlaps
+
+    const nextOverlap = this.overlapQueue.shift()
+
+    if (nextOverlap) {
+      const traceToFix = this.allTraces.find(
+        (t) => t.mspPairId === nextOverlap.trace.mspPairId,
+      )
+      if (traceToFix) {
+        const labelId = nextOverlap.label.globalConnNetId
+        const detourCount = this.detourCountByLabel[labelId] || 0
+        this.detourCountByLabel[labelId] = detourCount + 1
+
+        this.activeSubSolver = new SingleOverlapSolver({
+          trace: traceToFix,
+          label: nextOverlap.label,
+          problem: this.inputProblem,
+          paddingBuffer: this.PADDING_BUFFER,
+          detourCount,
+        })
+      }
+    }
+  }
+
+  getOutput() {
+    return {
+      allTraces: this.allTraces,
+      modifiedTraces: this.modifiedTraces,
+    }
+  }
+
+  override visualize(): GraphicsObject {
+    if (this.activeSubSolver) {
+      return this.activeSubSolver.visualize()
+    }
+    // When idle, show all the traces
+    const graphics = visualizeInputProblem(this.inputProblem)
+    if (!graphics.lines) graphics.lines = []
+    for (const trace of this.allTraces) {
+      graphics.lines!.push({
+        points: trace.tracePath,
+        strokeColor: "purple",
+      })
+    }
+    return graphics
+  }
+}

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

@@ -0,0 +1,117 @@
+import type { Point } from "@tscircuit/math-utils"
+import { BaseSolver } from "lib/solvers/BaseSolver/BaseSolver"
+import type { NetLabelPlacement } from "../../../NetLabelPlacementSolver/NetLabelPlacementSolver"
+import type { InputProblem } from "lib/types/InputProblem"
+import type { GraphicsObject } from "graphics-debug"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import { isPathCollidingWithObstacles } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions"
+import { getObstacleRects } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/rect"
+import { visualizeInputProblem } from "lib/solvers/SchematicTracePipelineSolver/visualizeInputProblem"
+import { generateRerouteCandidates } from "../../rerouteCollidingTrace"
+import { simplifyPath } from "lib/solvers/TraceCleanupSolver/simplifyPath"
+
+interface SingleOverlapSolverInput {
+  trace: SolvedTracePath
+  label: NetLabelPlacement
+  problem: InputProblem
+  paddingBuffer: number
+  detourCount: number
+}
+
+/**
+ * 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
+ * finds one that does not introduce new collisions.
+ */
+export class SingleOverlapSolver extends BaseSolver {
+  queuedCandidatePaths: Point[][]
+  solvedTracePath: Point[] | null = null
+  initialTrace: SolvedTracePath
+  problem: InputProblem
+  obstacles: ReturnType<typeof getObstacleRects>
+  label: NetLabelPlacement
+
+  constructor(solverInput: SingleOverlapSolverInput) {
+    super()
+    this.initialTrace = solverInput.trace
+    this.problem = solverInput.problem
+    this.label = solverInput.label
+
+    const candidates = generateRerouteCandidates({
+      ...solverInput,
+    })
+
+    const getPathLength = (pts: Point[]) => {
+      let len = 0
+      for (let i = 0; i < pts.length - 1; i++) {
+        const dx = pts[i + 1].x - pts[i].x
+        const dy = pts[i + 1].y - pts[i].y
+        len += Math.sqrt(dx * dx + dy * dy)
+      }
+      return len
+    }
+
+    this.queuedCandidatePaths = candidates.sort(
+      (a, b) => getPathLength(a) - getPathLength(b),
+    )
+    this.obstacles = getObstacleRects(this.problem)
+  }
+
+  override _step() {
+    if (this.queuedCandidatePaths.length === 0) {
+      this.failed = true
+      return
+    }
+
+    const nextCandidatePath = this.queuedCandidatePaths.shift()!
+    const simplifiedPath = simplifyPath(nextCandidatePath)
+
+    if (!isPathCollidingWithObstacles(simplifiedPath, this.obstacles)) {
+      this.solvedTracePath = simplifiedPath
+      this.solved = true
+    }
+  }
+
+  override visualize(): GraphicsObject {
+    const graphics = visualizeInputProblem(this.problem, {
+      chipAlpha: 0.1,
+      connectionAlpha: 0.1,
+    })
+
+    if (!graphics.lines) graphics.lines = []
+    if (!graphics.rects) graphics.rects = []
+
+    // Draw initial trace
+    graphics.lines.push({
+      points: this.initialTrace.tracePath,
+      strokeColor: "red",
+      strokeDash: "4 4",
+    })
+
+    // Draw label
+    graphics.rects.push({
+      center: this.label.center,
+      width: this.label.width,
+      height: this.label.height,
+      fill: "rgba(255, 0, 0, 0.2)",
+    })
+
+    // Draw next candidate
+    if (this.queuedCandidatePaths.length > 0) {
+      graphics.lines.push({
+        points: this.queuedCandidatePaths[0],
+        strokeColor: "orange",
+      })
+    }
+
+    // Draw solved path
+    if (this.solvedTracePath) {
+      graphics.lines.push({
+        points: this.solvedTracePath,
+        strokeColor: "green",
+      })
+    }
+
+    return graphics
+  }
+}

package/lib/solvers/TraceLabelOverlapAvoidanceSolver/tryFourPointDetour.ts

@@ -0,0 +1,104 @@
+import type { Point } from "graphics-debug"
+import type { NetLabelPlacement } from "../NetLabelPlacementSolver/NetLabelPlacementSolver"
+import { getRectBounds } from "../NetLabelPlacementSolver/SingleNetLabelPlacementSolver/geometry"
+import type { SolvedTracePath } from "../SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import {
+  segmentIntersectsRect,
+  isVertical,
+} from "../SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions"
+
+export const generateFourPointDetourCandidates = ({
+  initialTrace,
+  label,
+  labelBounds,
+  paddingBuffer,
+  detourCount,
+}: {
+  initialTrace: SolvedTracePath
+  label: NetLabelPlacement
+  labelBounds: any
+  paddingBuffer: number
+  detourCount: number
+}): Point[][] => {
+  let collidingSegIndex = -1
+  for (let i = 0; i < initialTrace.tracePath.length - 1; i++) {
+    if (
+      segmentIntersectsRect(
+        initialTrace.tracePath[i],
+        initialTrace.tracePath[i + 1],
+        labelBounds,
+      )
+    ) {
+      collidingSegIndex = i
+      break
+    }
+  }
+
+  if (collidingSegIndex === -1) return []
+
+  const pA = initialTrace.tracePath[collidingSegIndex]
+  const pB = initialTrace.tracePath[collidingSegIndex + 1]
+
+  if (!pA || !pB) return []
+
+  const candidateDetours: Point[][] = []
+  const paddedLabelBounds = getRectBounds(
+    label.center,
+    label.width,
+    label.height,
+  )
+
+  const effectivePadding = paddingBuffer + detourCount * paddingBuffer
+
+  if (isVertical(pA, pB)) {
+    const xCandidates = [
+      paddedLabelBounds.maxX + effectivePadding,
+      paddedLabelBounds.minX - effectivePadding,
+    ]
+    for (const newX of xCandidates) {
+      candidateDetours.push(
+        pB.y > pA.y
+          ? [
+              { x: pA.x, y: paddedLabelBounds.minY - effectivePadding },
+              { x: newX, y: paddedLabelBounds.minY - effectivePadding },
+              { x: newX, y: paddedLabelBounds.maxY + effectivePadding },
+              { x: pB.x, y: paddedLabelBounds.maxY + effectivePadding },
+            ]
+          : [
+              { x: pA.x, y: paddedLabelBounds.maxY + effectivePadding },
+              { x: newX, y: paddedLabelBounds.maxY + effectivePadding },
+              { x: newX, y: paddedLabelBounds.minY - effectivePadding },
+              { x: pB.x, y: paddedLabelBounds.minY - effectivePadding },
+            ],
+      )
+    }
+  } else {
+    const yCandidates = [
+      paddedLabelBounds.maxY + effectivePadding,
+      paddedLabelBounds.minY - effectivePadding,
+    ]
+    for (const newY of yCandidates) {
+      candidateDetours.push(
+        pB.x > pA.x
+          ? [
+              { x: paddedLabelBounds.minX - effectivePadding, y: pA.y },
+              { x: paddedLabelBounds.minX - effectivePadding, y: newY },
+              { x: paddedLabelBounds.maxX + effectivePadding, y: newY },
+              { x: paddedLabelBounds.maxX + effectivePadding, y: pB.y },
+            ]
+          : [
+              { x: paddedLabelBounds.maxX + effectivePadding, y: pA.y },
+              { x: paddedLabelBounds.maxX + effectivePadding, y: newY },
+              { x: paddedLabelBounds.minX - effectivePadding, y: newY },
+              { x: paddedLabelBounds.minX - effectivePadding, y: pB.y },
+            ],
+      )
+    }
+  }
+
+  return candidateDetours.map((detourPoints) => [
+    ...initialTrace.tracePath.slice(0, collidingSegIndex + 1),
+    ...detourPoints,
+    ...initialTrace.tracePath.slice(collidingSegIndex + 1),
+  ])
+}

package/lib/solvers/TraceLabelOverlapAvoidanceSolver/trySnipAndReconnect.ts

@@ -1,32 +1,26 @@
 import type { Point } from "@tscircuit/math-utils"
-import { getRectBounds } from "../NetLabelPlacementSolver/SingleNetLabelPlacementSolver/geometry"
 import type { SolvedTracePath } from "../SchematicTraceLinesSolver/SchematicTraceLinesSolver"
-import {
-  isPathCollidingWithObstacles,
-  isVertical,
-  segmentIntersectsRect,
-} from "../SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions"
-import type { NetLabelPlacement } from "../NetLabelPlacementSolver/NetLabelPlacementSolver"
-import { simplifyPath } from "./simplifyPath"
 
-export const trySnipAndReconnect = ({
+export const generateSnipAndReconnectCandidates = ({
   initialTrace,
   firstInsideIndex,
   lastInsideIndex,
   labelBounds,
-  obstacles,
+  paddingBuffer,
+  detourCount,
 }: {
   initialTrace: SolvedTracePath
   firstInsideIndex: number
   lastInsideIndex: number
   labelBounds: any
-  obstacles: any[]
-}): SolvedTracePath | null => {
+  paddingBuffer: number
+  detourCount: number
+}): Point[][] => {
   if (
     firstInsideIndex <= 0 ||
     lastInsideIndex >= initialTrace.tracePath.length - 1
   ) {
-    return null
+    return []
   }
 
   const entryPoint = initialTrace.tracePath[firstInsideIndex - 1]
@@ -35,32 +29,19 @@ export const trySnipAndReconnect = ({
   const pathToEntry = initialTrace.tracePath.slice(0, firstInsideIndex)
   const pathFromExit = initialTrace.tracePath.slice(lastInsideIndex + 1)
 
-  const candidateDetours: Point[][] = []
+  const allCandidateDetours: Point[][] = []
 
+  // Candidate type 1: simple elbow
   if (entryPoint.x !== exitPoint.x && entryPoint.y !== exitPoint.y) {
-    candidateDetours.push([{ x: exitPoint.x, y: entryPoint.y }])
-    candidateDetours.push([{ x: entryPoint.x, y: exitPoint.y }])
+    allCandidateDetours.push([{ x: exitPoint.x, y: entryPoint.y }])
+    allCandidateDetours.push([{ x: entryPoint.x, y: exitPoint.y }])
   } else if (entryPoint.x === exitPoint.x || entryPoint.y === exitPoint.y) {
-    const newPath = [...pathToEntry, ...pathFromExit]
-    const simplified = simplifyPath(newPath)
-    if (!isPathCollidingWithObstacles(simplified, obstacles)) {
-      return { ...initialTrace, tracePath: simplified }
-    }
+    // Candidate type 2: direct connection (if points are aligned)
+    allCandidateDetours.push([]) // No detour points needed
   }
 
-  for (let i = 0; i < candidateDetours.length; i++) {
-    const detour = candidateDetours[i]
-    const newFullPath = [...pathToEntry, ...detour, ...pathFromExit]
-    const simplified = simplifyPath(newFullPath)
-
-    if (!isPathCollidingWithObstacles(simplified, obstacles)) {
-      return { ...initialTrace, tracePath: simplified }
-    }
-  }
-
-  candidateDetours.length = 0
-
-  const buffer = 0.1
+  // Candidate type 3: routing around the label bounds
+  const buffer = paddingBuffer + detourCount * paddingBuffer
   const leftX = labelBounds.minX - buffer
   const rightX = labelBounds.maxX + buffer
   const topY = labelBounds.maxY + buffer
@@ -71,7 +52,7 @@ export const trySnipAndReconnect = ({
     entryPoint.x < labelBounds.maxX &&
     exitPoint.x < labelBounds.maxX
   ) {
-    candidateDetours.push([
+    allCandidateDetours.push([
       { x: leftX, y: entryPoint.y },
       { x: leftX, y: exitPoint.y },
     ])
@@ -82,7 +63,7 @@ export const trySnipAndReconnect = ({
     entryPoint.x > labelBounds.minX &&
     exitPoint.x > labelBounds.minX
   ) {
-    candidateDetours.push([
+    allCandidateDetours.push([
       { x: rightX, y: entryPoint.y },
       { x: rightX, y: exitPoint.y },
     ])
@@ -93,7 +74,7 @@ export const trySnipAndReconnect = ({
     entryPoint.y > labelBounds.minY &&
     exitPoint.y > labelBounds.minY
   ) {
-    candidateDetours.push([
+    allCandidateDetours.push([
       { x: entryPoint.x, y: topY },
       { x: exitPoint.x, y: topY },
     ])
@@ -104,126 +85,15 @@ export const trySnipAndReconnect = ({
     entryPoint.y < labelBounds.maxY &&
     exitPoint.y < labelBounds.maxY
   ) {
-    candidateDetours.push([
+    allCandidateDetours.push([
       { x: entryPoint.x, y: bottomY },
       { x: exitPoint.x, y: bottomY },
     ])
   }
 
-  for (let i = 0; i < candidateDetours.length; i++) {
-    const detour = candidateDetours[i]
-    const newFullPath = [...pathToEntry, ...detour, ...pathFromExit]
-    const simplified = simplifyPath(newFullPath)
-
-    if (!isPathCollidingWithObstacles(simplified, obstacles)) {
-      return { ...initialTrace, tracePath: simplified }
-    }
-  }
-
-  return null
-}
-
-export const tryFourPointDetour = ({
-  initialTrace,
-  label,
-  labelBounds,
-  obstacles,
-  paddingBuffer,
-  detourCount,
-}: {
-  initialTrace: SolvedTracePath
-  label: NetLabelPlacement
-  labelBounds: any
-  obstacles: any[]
-  paddingBuffer: number
-  detourCount: number
-}): SolvedTracePath | null => {
-  let collidingSegIndex = -1
-  for (let i = 0; i < initialTrace.tracePath.length - 1; i++) {
-    if (
-      segmentIntersectsRect(
-        initialTrace.tracePath[i],
-        initialTrace.tracePath[i + 1],
-        labelBounds,
-      )
-    ) {
-      collidingSegIndex = i
-      break
-    }
-  }
-
-  if (collidingSegIndex === -1) return initialTrace
-
-  const pA = initialTrace.tracePath[collidingSegIndex]
-  const pB = initialTrace.tracePath[collidingSegIndex + 1]
-
-  if (!pA || !pB) return null
-
-  const candidateDetours: Point[][] = []
-  const paddedLabelBounds = getRectBounds(
-    label.center,
-    label.width,
-    label.height,
-  )
-
-  const effectivePadding = paddingBuffer + detourCount * paddingBuffer
-
-  if (isVertical(pA, pB)) {
-    const xCandidates = [
-      paddedLabelBounds.maxX + effectivePadding,
-      paddedLabelBounds.minX - effectivePadding,
-    ]
-    for (const newX of xCandidates) {
-      candidateDetours.push(
-        pB.y > pA.y
-          ? [
-              { x: pA.x, y: paddedLabelBounds.minY - effectivePadding },
-              { x: newX, y: paddedLabelBounds.minY - effectivePadding },
-              { x: newX, y: paddedLabelBounds.maxY + effectivePadding },
-              { x: pB.x, y: paddedLabelBounds.maxY + effectivePadding },
-            ]
-          : [
-              { x: pA.x, y: paddedLabelBounds.maxY + effectivePadding },
-              { x: newX, y: paddedLabelBounds.maxY + effectivePadding },
-              { x: newX, y: paddedLabelBounds.minY - effectivePadding },
-              { x: pB.x, y: paddedLabelBounds.minY - effectivePadding },
-            ],
-      )
-    }
-  } else {
-    const yCandidates = [
-      paddedLabelBounds.maxY + effectivePadding,
-      paddedLabelBounds.minY - effectivePadding,
-    ]
-    for (const newY of yCandidates) {
-      candidateDetours.push(
-        pB.x > pA.x
-          ? [
-              { x: paddedLabelBounds.minX - effectivePadding, y: pA.y },
-              { x: paddedLabelBounds.minX - effectivePadding, y: newY },
-              { x: paddedLabelBounds.maxX + effectivePadding, y: newY },
-              { x: paddedLabelBounds.maxX + effectivePadding, y: pB.y },
-            ]
-          : [
-              { x: paddedLabelBounds.maxX + effectivePadding, y: pA.y },
-              { x: paddedLabelBounds.maxX + effectivePadding, y: newY },
-              { x: paddedLabelBounds.minX - effectivePadding, y: newY },
-              { x: paddedLabelBounds.minX - effectivePadding, y: pB.y },
-            ],
-      )
-    }
-  }
-
-  for (const detourPoints of candidateDetours) {
-    const finalPath = [
-      ...initialTrace.tracePath.slice(0, collidingSegIndex + 1),
-      ...detourPoints,
-      ...initialTrace.tracePath.slice(collidingSegIndex + 1),
-    ]
-    const simplifiedFinalPath = simplifyPath(finalPath)
-    if (!isPathCollidingWithObstacles(simplifiedFinalPath, obstacles)) {
-      return { ...initialTrace, tracePath: simplifiedFinalPath }
-    }
-  }
-  return null
+  return allCandidateDetours.map((detour) => [
+    ...pathToEntry,
+    ...detour,
+    ...pathFromExit,
+  ])
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tscircuit/schematic-trace-solver",
   "main": "dist/index.js",
-  "version": "0.0.41",
+  "version": "0.0.43",
   "type": "module",
   "scripts": {
     "start": "cosmos",

package/site/examples/example26.page.tsx

@@ -0,0 +1,4 @@
+import { PipelineDebugger } from "site/components/PipelineDebugger"
+import inputProblem from "../../tests/assets/example26.json"
+
+export default () => <PipelineDebugger inputProblem={inputProblem as any} />