@tscircuit/schematic-trace-solver 0.0.54 → 0.0.56

package/lib/solvers/NetLabelTraceCollisionSolver/NetLabelTraceCollisionSolver.ts

@@ -0,0 +1,294 @@
+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 { SingleOverlapSolver } from "lib/solvers/TraceLabelOverlapAvoidanceSolver/sub-solvers/SingleOverlapSolver/SingleOverlapSolver"
+import { getRectBounds } from "lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/geometry"
+import { segmentIntersectsRect } from "lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/collisions"
+import { getColorFromString } from "lib/utils/getColorFromString"
+import type { InputProblem } from "lib/types/InputProblem"
+
+/**
+ * Merges all labels that touch/overlap with each other (transitively) around
+ * a seed label into a single bounding-box label. This prevents the situation
+ * where fixing one label collision re-routes the trace into an adjacent label.
+ */
+function buildMergedObstacleLabel(
+  seedLabel: NetLabelPlacement,
+  allLabels: NetLabelPlacement[],
+): NetLabelPlacement {
+  const TOUCH_MARGIN = 0.01
+
+  const getBounds = (l: NetLabelPlacement) =>
+    getRectBounds(l.center, l.width, l.height)
+
+  const touches = (a: NetLabelPlacement, b: NetLabelPlacement) => {
+    const ba = getBounds(a)
+    const bb = getBounds(b)
+    return (
+      ba.minX <= bb.maxX + TOUCH_MARGIN &&
+      ba.maxX >= bb.minX - TOUCH_MARGIN &&
+      ba.minY <= bb.maxY + TOUCH_MARGIN &&
+      ba.maxY >= bb.minY - TOUCH_MARGIN
+    )
+  }
+
+  const group = new Set<NetLabelPlacement>([seedLabel])
+  let changed = true
+  while (changed) {
+    changed = false
+    for (const l of allLabels) {
+      if (group.has(l)) continue
+      if ([...group].some((g) => touches(g, l))) {
+        group.add(l)
+        changed = true
+      }
+    }
+  }
+
+  let minX = Infinity,
+    minY = Infinity,
+    maxX = -Infinity,
+    maxY = -Infinity
+  for (const l of group) {
+    const b = getBounds(l)
+    if (b.minX < minX) minX = b.minX
+    if (b.minY < minY) minY = b.minY
+    if (b.maxX > maxX) maxX = b.maxX
+    if (b.maxY > maxY) maxY = b.maxY
+  }
+
+  const cx = (minX + maxX) / 2
+  const cy = (minY + maxY) / 2
+  const w = maxX - minX
+  const h = maxY - minY
+
+  return {
+    ...seedLabel,
+    center: { x: cx, y: cy },
+    width: w,
+    height: h,
+  }
+}
+
+interface TraceInnerLabelOverlap {
+  trace: SolvedTracePath
+  label: NetLabelPlacement
+}
+
+/**
+ * Detects overlaps where a trace's INTERIOR (non-endpoint) segments cross a label.
+ * Traces are allowed to boundary a label at their endpoints (pin locations),
+ * just not allowed to cross through it in the middle.
+ */
+function detectInnerTraceLabelOverlaps(
+  traces: SolvedTracePath[],
+  labels: NetLabelPlacement[],
+): TraceInnerLabelOverlap[] {
+  const overlaps: TraceInnerLabelOverlap[] = []
+  for (const trace of traces) {
+    for (const label of labels) {
+      if (trace.globalConnNetId === label.globalConnNetId) continue
+      const bounds = getRectBounds(label.center, label.width, label.height)
+      const path = trace.tracePath
+      // Skip first and last segments — trace endpoints (pins) may legitimately
+      // sit inside or adjacent to labels of neighbouring nets.
+      const innerStart = 1
+      const innerEnd = path.length - 2
+      for (let i = innerStart; i < innerEnd; i++) {
+        if (segmentIntersectsRect(path[i]!, path[i + 1]!, bounds)) {
+          overlaps.push({ trace, label })
+          break
+        }
+      }
+    }
+  }
+  return overlaps
+}
+
+export interface NetLabelTraceCollisionSolverParams {
+  inputProblem: InputProblem
+  traces: SolvedTracePath[]
+  netLabelPlacements: NetLabelPlacement[]
+}
+
+const PADDING_BUFFER = 0.1
+const MAX_DETOUR_ATTEMPTS = 3
+
+export class NetLabelTraceCollisionSolver extends BaseSolver {
+  inputProblem: InputProblem
+  traces: SolvedTracePath[]
+  netLabelPlacements: NetLabelPlacement[]
+
+  outputTraces: SolvedTracePath[]
+  outputNetLabelPlacements: NetLabelPlacement[]
+
+  override activeSubSolver: SingleOverlapSolver | null = null
+  private recentlyFailed = new Set<string>()
+  private detourCounts = new Map<string, number>()
+
+  private currentOverlap: {
+    trace: SolvedTracePath
+    label: NetLabelPlacement
+  } | null = null
+
+  constructor(params: NetLabelTraceCollisionSolverParams) {
+    super()
+    this.inputProblem = params.inputProblem
+    this.traces = params.traces
+    this.netLabelPlacements = params.netLabelPlacements
+    this.outputTraces = [...params.traces]
+    this.outputNetLabelPlacements = [...params.netLabelPlacements]
+  }
+
+  override getConstructorParams(): ConstructorParameters<
+    typeof NetLabelTraceCollisionSolver
+  >[0] {
+    return {
+      inputProblem: this.inputProblem,
+      traces: this.traces,
+      netLabelPlacements: this.netLabelPlacements,
+    }
+  }
+
+  override _step() {
+    if (this.activeSubSolver) {
+      this.activeSubSolver.step()
+
+      if (this.activeSubSolver.solved) {
+        const solvedPath = this.activeSubSolver.solvedTracePath
+        if (solvedPath) {
+          const idx = this.outputTraces.findIndex(
+            (t) => t.mspPairId === this.activeSubSolver!.initialTrace.mspPairId,
+          )
+          if (idx !== -1) {
+            this.outputTraces[idx] = {
+              ...this.outputTraces[idx],
+              tracePath: solvedPath,
+            }
+          }
+        }
+        this.activeSubSolver = null
+        this.currentOverlap = null
+      } else if (this.activeSubSolver.failed) {
+        const key = this.getOverlapKey(
+          this.activeSubSolver.initialTrace,
+          this.activeSubSolver.label,
+        )
+        this.recentlyFailed.add(key)
+        this.activeSubSolver = null
+        this.currentOverlap = null
+      }
+      return
+    }
+
+    const overlaps = detectInnerTraceLabelOverlaps(
+      this.outputTraces,
+      this.outputNetLabelPlacements,
+    )
+
+    const actionable = overlaps.filter((o) => {
+      const key = this.getOverlapKey(o.trace, o.label)
+      return !this.recentlyFailed.has(key)
+    })
+
+    if (actionable.length === 0) {
+      this.solved = true
+      return
+    }
+
+    const next = actionable[0]
+
+    const traceToFix = this.outputTraces.find(
+      (t) => t.mspPairId === next.trace.mspPairId,
+    )!
+
+    this.currentOverlap = next
+
+    // Merge all touching/overlapping labels into one obstacle so that fixing
+    // one collision doesn't immediately create another with an adjacent label.
+    const mergedLabel = buildMergedObstacleLabel(
+      next.label,
+      this.outputNetLabelPlacements.filter(
+        (l) => l.globalConnNetId !== traceToFix.globalConnNetId,
+      ),
+    )
+
+    const mergeKey = `${next.trace.mspPairId}::merged::${mergedLabel.center.x},${mergedLabel.center.y},${mergedLabel.width},${mergedLabel.height}`
+    const detourCount = this.detourCounts.get(mergeKey) ?? 0
+    if (detourCount >= MAX_DETOUR_ATTEMPTS) {
+      this.recentlyFailed.add(this.getOverlapKey(next.trace, next.label))
+      this.currentOverlap = null
+      return
+    }
+    this.detourCounts.set(mergeKey, detourCount + 1)
+
+    this.activeSubSolver = new SingleOverlapSolver({
+      trace: traceToFix,
+      label: mergedLabel,
+      problem: this.inputProblem,
+      paddingBuffer: PADDING_BUFFER,
+      detourCount,
+    })
+  }
+
+  getOutput() {
+    return {
+      traces: this.outputTraces,
+      netLabelPlacements: this.outputNetLabelPlacements,
+    }
+  }
+
+  private getOverlapKey(trace: SolvedTracePath, label: NetLabelPlacement) {
+    return `${trace.mspPairId}::${label.globalConnNetId}`
+  }
+
+  override visualize(): GraphicsObject {
+    if (this.activeSubSolver) return this.activeSubSolver.visualize()
+
+    const graphics = visualizeInputProblem(this.inputProblem)
+    if (!graphics.lines) graphics.lines = []
+    if (!graphics.rects) graphics.rects = []
+    if (!graphics.points) graphics.points = []
+
+    for (const trace of this.outputTraces) {
+      graphics.lines.push({
+        points: trace.tracePath,
+        strokeColor: "purple",
+      } as any)
+    }
+
+    for (const label of this.outputNetLabelPlacements) {
+      graphics.rects.push({
+        center: label.center,
+        width: label.width,
+        height: label.height,
+        fill: getColorFromString(label.globalConnNetId, 0.35),
+        strokeColor: getColorFromString(label.globalConnNetId, 0.9),
+        label: `netId: ${label.netId}\nglobalConnNetId: ${label.globalConnNetId}`,
+      } as any)
+      graphics.points.push({
+        x: label.anchorPoint.x,
+        y: label.anchorPoint.y,
+        color: getColorFromString(label.globalConnNetId, 0.9),
+      } as any)
+    }
+
+    if (this.currentOverlap) {
+      graphics.lines.push({
+        points: this.currentOverlap.trace.tracePath,
+        strokeColor: "red",
+      } as any)
+      graphics.rects.push({
+        center: this.currentOverlap.label.center,
+        width: this.currentOverlap.label.width,
+        height: this.currentOverlap.label.height,
+        fill: "rgba(255,0,0,0.3)",
+        strokeColor: "red",
+      } as any)
+    }
+
+    return graphics
+  }
+}

package/lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver.ts

@@ -25,6 +25,7 @@ import { Example28Solver } from "../Example28Solver/Example28Solver"
 import { AvailableNetOrientationSolver } from "../AvailableNetOrientationSolver/AvailableNetOrientationSolver"
 import { VccNetLabelCornerPlacementSolver } from "../VccNetLabelCornerPlacementSolver/VccNetLabelCornerPlacementSolver"
 import { TraceAnchoredNetLabelOverlapSolver } from "../TraceAnchoredNetLabelOverlapSolver/TraceAnchoredNetLabelOverlapSolver"
+import { NetLabelTraceCollisionSolver } from "../NetLabelTraceCollisionSolver/NetLabelTraceCollisionSolver"
 
 type PipelineStep<T extends new (...args: any[]) => BaseSolver> = {
   solverName: string
@@ -78,6 +79,7 @@ export class SchematicTracePipelineSolver extends BaseSolver {
   availableNetOrientationSolver?: AvailableNetOrientationSolver
   vccNetLabelCornerPlacementSolver?: VccNetLabelCornerPlacementSolver
   traceAnchoredNetLabelOverlapSolver?: TraceAnchoredNetLabelOverlapSolver
+  netLabelTraceCollisionSolver?: NetLabelTraceCollisionSolver
 
   startTimeOfPhase: Record<string, number>
   endTimeOfPhase: Record<string, number>
@@ -285,6 +287,19 @@ export class SchematicTracePipelineSolver extends BaseSolver {
         },
       ],
     ),
+    definePipelineStep(
+      "netLabelTraceCollisionSolver",
+      NetLabelTraceCollisionSolver,
+      (instance) => [
+        {
+          inputProblem: instance.inputProblem,
+          traces: instance.availableNetOrientationSolver!.traces,
+          netLabelPlacements:
+            instance.traceAnchoredNetLabelOverlapSolver!
+              .outputNetLabelPlacements,
+        },
+      ],
+    ),
   ]
 
   constructor(inputProblem: InputProblem) {

package/lib/solvers/SchematicTracePipelineSolver/visualizeInputProblem.ts

@@ -2,6 +2,7 @@ import type { GraphicsObject } from "graphics-debug"
 import type { PinId, InputPin, InputProblem } from "lib/types/InputProblem"
 import { getColorFromString } from "lib/utils/getColorFromString"
 import { getPinDirection } from "../SchematicTraceLinesSolver/SchematicTraceSingleLineSolver/getPinDirection"
+import { arePinsInDifferentSchematicSections } from "../../utils/arePinsInDifferentSchematicSections"
 
 export const visualizeInputProblem = (
   inputProblem: InputProblem,
@@ -50,6 +51,9 @@ export const visualizeInputProblem = (
     const [pinId1, pinId2] = directConn.pinIds
     const pin1 = pinIdMap.get(pinId1)!
     const pin2 = pinIdMap.get(pinId2)!
+    if (arePinsInDifferentSchematicSections(inputProblem, pin1, pin2)) {
+      continue
+    }
     graphics.lines.push({
       points: [
         {
@@ -74,6 +78,9 @@ export const visualizeInputProblem = (
       for (let j = i + 1; j < pins.length; j++) {
         const pin1 = pins[i]!
         const pin2 = pins[j]!
+        if (arePinsInDifferentSchematicSections(inputProblem, pin1, pin2)) {
+          continue
+        }
         graphics.lines.push({
           points: [
             { x: pin1.x, y: pin1.y },

package/lib/types/InputProblem.ts

@@ -4,6 +4,7 @@ import type { FacingDirection } from "lib/utils/dir"
 export type ChipId = string
 export type PinId = string
 export type NetId = string
+export type SectionId = string
 
 export interface InputPin {
   pinId: PinId
@@ -18,6 +19,7 @@ export interface InputChip {
   width: number
   height: number
   pins: Array<InputPin>
+  sectionId?: SectionId
 }
 export interface InputDirectConnection {
   pinIds: [PinId, PinId]

package/lib/utils/arePinsInDifferentSchematicSections.ts

@@ -0,0 +1,39 @@
+import type { InputProblem, InputPin } from "lib/types/InputProblem"
+
+const getSectionNameForPin = (
+  sectionByChipId: Map<string, string>,
+  sectionByPinId: Map<string, string>,
+  pin: InputPin & { chipId?: string },
+) => {
+  if (pin.chipId) {
+    const chipSection = sectionByChipId.get(pin.chipId)
+    if (chipSection) return chipSection
+  }
+
+  return sectionByPinId.get(pin.pinId)
+}
+
+export const arePinsInDifferentSchematicSections = (
+  inputProblem: InputProblem,
+  p1: InputPin & { chipId?: string },
+  p2: InputPin & { chipId?: string },
+) => {
+  const sectionByChipId = new Map<string, string>()
+  const sectionByPinId = new Map<string, string>()
+
+  for (const chip of inputProblem.chips) {
+    if (!chip.sectionId) continue
+
+    sectionByChipId.set(chip.chipId, chip.sectionId)
+    for (const pin of chip.pins) {
+      sectionByPinId.set(pin.pinId, chip.sectionId)
+    }
+  }
+
+  if (sectionByChipId.size === 0) return false
+
+  const s1 = getSectionNameForPin(sectionByChipId, sectionByPinId, p1)
+  const s2 = getSectionNameForPin(sectionByChipId, sectionByPinId, p2)
+
+  return !!s1 && !!s2 && s1 !== s2
+}

package/package.json

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

package/site/examples/example32.page.tsx

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

package/site/examples/example33.page.tsx

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

package/tests/assets/example32.json

@@ -0,0 +1,148 @@
+{
+  "chips": [
+    {
+      "chipId": "schematic_component_0",
+      "center": { "x": -4, "y": 3 },
+      "width": 0.95,
+      "height": 0.29,
+      "sectionId": "power",
+      "pins": [
+        { "pinId": "B1.1", "x": -4.45, "y": 2.9699999999999998 },
+        { "pinId": "B1.2", "x": -3.55, "y": 2.9699999999999998 }
+      ]
+    },
+    {
+      "chipId": "schematic_component_1",
+      "center": { "x": -2, "y": 3 },
+      "width": 0.76,
+      "height": 0.5,
+      "sectionId": "power",
+      "pins": [
+        { "pinId": "SW1.1", "x": -2.38, "y": 3 },
+        { "pinId": "SW1.2", "x": -1.62, "y": 3 }
+      ]
+    },
+    {
+      "chipId": "schematic_component_2",
+      "center": { "x": -3, "y": 1.5 },
+      "width": 1.1,
+      "height": 0.84,
+      "sectionId": "power",
+      "pins": [
+        { "pinId": "C3.1", "x": -3.55, "y": 1.5 },
+        { "pinId": "C3.2", "x": -2.45, "y": 1.5 }
+      ]
+    },
+    {
+      "chipId": "schematic_component_3",
+      "center": { "x": 1.5, "y": 2.5 },
+      "width": 1.6,
+      "height": 1,
+      "sectionId": "timer",
+      "pins": [
+        { "pinId": "U1.1", "x": 2.7, "y": 2.2 },
+        { "pinId": "U1.2", "x": 0.2999999999999998, "y": 2.2 },
+        { "pinId": "U1.3", "x": 2.7, "y": 2.6 },
+        { "pinId": "U1.4", "x": 0.2999999999999998, "y": 2.8 },
+        { "pinId": "U1.5", "x": 0.2999999999999998, "y": 2.6 },
+        { "pinId": "U1.6", "x": 0.2999999999999998, "y": 2.4 },
+        { "pinId": "U1.7", "x": 2.7, "y": 2.4 },
+        { "pinId": "U1.8", "x": 2.7, "y": 2.8 }
+      ]
+    },
+    {
+      "chipId": "schematic_component_4",
+      "center": { "x": 4, "y": 1.5 },
+      "width": 1.1,
+      "height": 0.84,
+      "sectionId": "timer",
+      "pins": [
+        { "pinId": "C2.1", "x": 3.45, "y": 1.5 },
+        { "pinId": "C2.2", "x": 4.55, "y": 1.5 }
+      ]
+    },
+    {
+      "chipId": "schematic_component_5",
+      "center": { "x": -4, "y": -1.5 },
+      "width": 1.1,
+      "height": 0.388910699999999,
+      "sectionId": "timing-network",
+      "pins": [
+        { "pinId": "R1.1", "x": -4.55, "y": -1.5 },
+        { "pinId": "R1.2", "x": -3.4499999999999997, "y": -1.5 }
+      ]
+    },
+    {
+      "chipId": "schematic_component_6",
+      "center": { "x": -2, "y": -1.5 },
+      "width": 1.1,
+      "height": 0.388910699999999,
+      "sectionId": "timing-network",
+      "pins": [
+        { "pinId": "R2.1", "x": -2.55, "y": -1.5 },
+        { "pinId": "R2.2", "x": -1.4500000000000002, "y": -1.5 }
+      ]
+    },
+    {
+      "chipId": "schematic_component_7",
+      "center": { "x": -3, "y": -3 },
+      "width": 1.1,
+      "height": 0.84,
+      "sectionId": "timing-network",
+      "pins": [
+        { "pinId": "C1.1", "x": -3.55, "y": -3 },
+        { "pinId": "C1.2", "x": -2.45, "y": -3 }
+      ]
+    },
+    {
+      "chipId": "schematic_component_8",
+      "center": { "x": 2.5, "y": -1.5 },
+      "width": 1.1,
+      "height": 0.388910699999999,
+      "sectionId": "output",
+      "pins": [
+        { "pinId": "R3.1", "x": 1.95, "y": -1.5 },
+        { "pinId": "R3.2", "x": 3.05, "y": -1.5 }
+      ]
+    },
+    {
+      "chipId": "schematic_component_9",
+      "center": { "x": 4.5, "y": -1.5 },
+      "width": 1.13,
+      "height": 0.65,
+      "sectionId": "output",
+      "pins": [
+        { "pinId": "D1.1", "x": 3.96, "y": -1.5 },
+        { "pinId": "D1.2", "x": 5.04, "y": -1.5 }
+      ]
+    }
+  ],
+  "directConnections": [
+    { "pinIds": ["B1.1", "SW1.1"], "netId": ".B1 > .pin1 to .SW1 > .pin1" },
+    { "pinIds": ["U1.5", "C2.1"], "netId": ".U1 > .CTRL to .C2 > .pin1" },
+    { "pinIds": ["U1.6", "U1.2"], "netId": ".U1 > .THRES to .U1 > .TRIG" },
+    { "pinIds": ["R1.2", "U1.7"], "netId": ".R1 > .pin2 to .U1 > .DISCH" },
+    { "pinIds": ["U1.7", "R2.1"], "netId": ".U1 > .DISCH to .R2 > .pin1" },
+    { "pinIds": ["R2.2", "U1.6"], "netId": ".R2 > .pin2 to .U1 > .THRES" },
+    { "pinIds": ["U1.6", "C1.1"], "netId": ".U1 > .THRES to .C1 > .pin1" },
+    { "pinIds": ["U1.3", "R3.1"], "netId": ".U1 > .OUT to .R3 > .pin1" },
+    { "pinIds": ["R3.2", "D1.1"], "netId": ".R3 > .pin2 to .D1 > .pin1" }
+  ],
+  "netConnections": [
+    {
+      "netId": "GND",
+      "pinIds": ["B1.2", "C3.2", "U1.1", "C2.2", "C1.2", "D1.2"],
+      "netLabelWidth": 0.3
+    },
+    {
+      "netId": "VCC",
+      "pinIds": ["SW1.2", "C3.1", "U1.4", "U1.8", "R1.1"],
+      "netLabelWidth": 0.3
+    }
+  ],
+  "availableNetLabelOrientations": {
+    "VCC": ["y+"],
+    "GND": ["y-"]
+  },
+  "maxMspPairDistance": 2.4
+}