@tscircuit/schematic-trace-solver 0.0.150 → 0.0.151

package/lib/solvers/InlineNetLabelSolver/InlineNetLabelSolver.ts

@@ -1,5 +1,5 @@
 import type { Bounds, Point } from "@tscircuit/math-utils"
-import type { GraphicsObject, Rect } from "graphics-debug"
+import type { GraphicsObject, Rect, Text } 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"
@@ -92,6 +92,13 @@ interface InlineNetLabelSolverInput {
   netLabelPlacements: NetLabelPlacement[]
 }
 
+export interface InlineNetLabelOutput {
+  inputProblem: InputProblem
+  traces: SolvedTracePath[]
+  netLabelPlacements: NetLabelPlacement[]
+  inlineNetLabelPlacements: InlineNetLabelPlacement[]
+}
+
 type InlineEligibleConnection = InputDirectConnection | InputNetConnection
 
 const getPinPairKey = (pinIds: readonly string[]) =>
@@ -646,95 +653,117 @@ export class InlineNetLabelSolver extends BaseSolver {
     // Mirrors the previous pipeline stage's visualization so that a problem
     // with no inline labels renders identically, then layers the inline labels
     // on top.
-    const graphics = visualizeInputProblem(this.inputProblem)
-    graphics.lines ??= []
-    graphics.rects ??= []
-    graphics.points ??= []
-    graphics.texts ??= []
-
-    const output = this.getOutput()
-    for (const trace of output.traces) {
+    return visualizeInlineNetLabelOutput({
+      inputProblem: this.inputProblem,
+      ...this.getOutput(),
+    })
+  }
+}
+
+export const visualizeInlineNetLabelOutput = ({
+  inputProblem,
+  traces,
+  netLabelPlacements,
+  inlineNetLabelPlacements,
+}: InlineNetLabelOutput): GraphicsObject => {
+  const graphics = visualizeInputProblem(inputProblem)
+  graphics.lines ??= []
+  graphics.rects ??= []
+  graphics.points ??= []
+  graphics.texts ??= []
+
+  for (const trace of traces) {
+    graphics.lines.push({
+      points: trace.tracePath,
+      strokeColor: "purple",
+    })
+  }
+
+  for (const label of netLabelPlacements) {
+    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 Rect & { strokeColor: string })
+    graphics.points.push({
+      x: label.anchorPoint.x,
+      y: label.anchorPoint.y,
+      color: getColorFromString(label.globalConnNetId, 0.9),
+      label: `anchorPoint\norientation: ${label.orientation}`,
+    })
+  }
+
+  for (const inlineLabel of inlineNetLabelPlacements) {
+    if (inlineLabel.stubTracePath) {
       graphics.lines.push({
-        points: trace.tracePath,
+        points: inlineLabel.stubTracePath,
         strokeColor: "purple",
       })
     }
-
-    const { netLabelPlacements } = this.getOutput()
-    for (const label of netLabelPlacements) {
-      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 Rect & { strokeColor: string })
-      graphics.points.push({
-        x: label.anchorPoint.x,
-        y: label.anchorPoint.y,
-        color: getColorFromString(label.globalConnNetId, 0.9),
-        label: `anchorPoint\norientation: ${label.orientation}`,
-      })
+    const isHorizontal = inlineLabel.axis === "x"
+    let renderedWidth = inlineLabel.width
+    let renderedHeight = inlineLabel.height
+    if (!isHorizontal) {
+      renderedWidth = inlineLabel.height
+      renderedHeight = inlineLabel.width
     }
-
-    for (const inlineLabel of this.inlineNetLabelPlacements) {
-      if (inlineLabel.stubTracePath) {
-        graphics.lines.push({
-          points: inlineLabel.stubTracePath,
-          strokeColor: "purple",
-        })
+    graphics.rects.push({
+      center: inlineLabel.center,
+      width: renderedWidth,
+      height: renderedHeight,
+      fill: getColorFromString(inlineLabel.globalConnNetId, 0.35),
+      strokeColor: "green",
+      label: [
+        `INLINE netId: ${inlineLabel.netId}`,
+        `axis: ${inlineLabel.axis}`,
+        `side: ${inlineLabel.side}`,
+      ].join("\n"),
+    } as Rect & { strokeColor: string })
+
+    let textX = inlineLabel.center.x
+    let textY = inlineLabel.center.y
+    let anchorSide: Text["anchorSide"] = "center"
+    let rotation: Text["rotation"]
+    if (inlineLabel.stubTracePath) {
+      const stubStart = inlineLabel.stubTracePath[0]
+      const stubEnd = inlineLabel.stubTracePath[1]
+      let labelOffset = inlineLabel.width / 2
+      if (stubEnd[inlineLabel.axis] > stubStart[inlineLabel.axis]) {
+        labelOffset = -inlineLabel.width / 2
+        anchorSide = "center_left"
+      } else {
+        anchorSide = "center_right"
+      }
+      if (inlineLabel.axis === "x") {
+        textX += labelOffset
+      } else {
+        textY += labelOffset
       }
-      const isHorizontal = inlineLabel.axis === "x"
-      graphics.rects.push({
-        center: inlineLabel.center,
-        width: isHorizontal ? inlineLabel.width : inlineLabel.height,
-        height: isHorizontal ? inlineLabel.height : inlineLabel.width,
-        fill: getColorFromString(inlineLabel.globalConnNetId, 0.35),
-        strokeColor: "green",
-        label: [
-          `INLINE netId: ${inlineLabel.netId}`,
-          `axis: ${inlineLabel.axis}`,
-          `side: ${inlineLabel.side}`,
-        ].join("\n"),
-      } as Rect & { strokeColor: string })
-      graphics.texts.push({
-        x:
-          inlineLabel.stubTracePath && inlineLabel.axis === "x"
-            ? inlineLabel.center.x +
-              (inlineLabel.stubTracePath[1].x > inlineLabel.stubTracePath[0].x
-                ? -inlineLabel.width / 2
-                : inlineLabel.width / 2)
-            : inlineLabel.center.x,
-        y:
-          inlineLabel.stubTracePath && inlineLabel.axis === "y"
-            ? inlineLabel.center.y +
-              (inlineLabel.stubTracePath[1].y > inlineLabel.stubTracePath[0].y
-                ? -inlineLabel.width / 2
-                : inlineLabel.width / 2)
-            : inlineLabel.center.y,
-        text: inlineLabel.netLabelText ?? inlineLabel.netId ?? "",
-        color: "green",
-        fontSize: inlineLabel.height,
-        anchorSide: inlineLabel.stubTracePath
-          ? inlineLabel.stubTracePath[1][inlineLabel.axis] >
-            inlineLabel.stubTracePath[0][inlineLabel.axis]
-            ? "center_left"
-            : "center_right"
-          : "center",
-        // Vertical labels read bottom-to-top, alongside the wire they name.
-        rotation: inlineLabel.axis === "y" ? 90 : undefined,
-      })
-      graphics.points.push({
-        x: inlineLabel.anchorPoint.x,
-        y: inlineLabel.anchorPoint.y,
-        color: "green",
-        label: `inline anchor\n${inlineLabel.netLabelText ?? inlineLabel.netId}`,
-      })
     }
-
-    return graphics
+    if (inlineLabel.axis === "y") rotation = 90
+
+    graphics.texts.push({
+      x: textX,
+      y: textY,
+      text: inlineLabel.netLabelText ?? inlineLabel.netId ?? "",
+      color: "green",
+      fontSize: inlineLabel.height,
+      anchorSide,
+      // Vertical labels read bottom-to-top, alongside the wire they name.
+      rotation,
+    })
+    graphics.points.push({
+      x: inlineLabel.anchorPoint.x,
+      y: inlineLabel.anchorPoint.y,
+      color: "green",
+      label: `inline anchor\n${inlineLabel.netLabelText ?? inlineLabel.netId}`,
+    })
   }
+
+  return graphics
 }
 
 /**

package/lib/solvers/NetLabelToTraceSolver/NetLabelToTraceSolver.ts

@@ -0,0 +1,338 @@
+import {
+  doesSegmentIntersectRect,
+  getBoundFromCenteredRect,
+  type Point,
+} from "@tscircuit/math-utils"
+import type { GraphicsObject } from "graphics-debug"
+import { BaseSolver } from "lib/solvers/BaseSolver/BaseSolver"
+import { getConnectivityMapsFromInputProblem } from "lib/solvers/MspConnectionPairSolver/getConnectivityMapFromInputProblem"
+import { doesPairCrossRestrictedCenterLines } from "lib/solvers/MspConnectionPairSolver/doesPairCrossRestrictedCenterLines"
+import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
+import {
+  getTraceRecoveryConnectivityMaps,
+  type TraceRecoveryPin,
+} from "lib/solvers/NetLabelTraceRecovery/getTraceRecoveryConnectivityMaps"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import { SchematicTraceSingleLineSolver2 } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/SchematicTraceSingleLineSolver2"
+import type {
+  ChipId,
+  InputChip,
+  InputProblem,
+  PinId,
+} from "lib/types/InputProblem"
+import { arePinsInDifferentSchematicSections } from "lib/utils/arePinsInDifferentSchematicSections"
+import { doesTraceOverlapWithExistingTraces } from "lib/utils/does-trace-overlap-with-existing-traces"
+import {
+  type InlineNetLabelPlacement,
+  type InlineNetLabelOutput,
+  visualizeInlineNetLabelOutput,
+} from "../InlineNetLabelSolver/InlineNetLabelSolver"
+
+type GlobalConnNetId = NetLabelPlacement["globalConnNetId"]
+
+interface CandidatePair {
+  firstLabel: NetLabelPlacement
+  secondLabel: NetLabelPlacement
+  pins: [TraceRecoveryPin, TraceRecoveryPin]
+  perpendicularOffset: number
+  routeDistance: number
+  key: string
+}
+
+const AVAILABLE_NET_ORIENTATION_PREFIX = "available-net-orientation-"
+const RECOVERED_TRACE_PREFIX = "net-label-to-trace-"
+
+const getCanonicalPairKey = (firstPinId: PinId, secondPinId: PinId) =>
+  [firstPinId, secondPinId].sort().join("--")
+
+export const pathIntersectsRenderedLabel = (
+  path: Point[],
+  label: NetLabelPlacement | InlineNetLabelPlacement,
+) => {
+  let width = label.width
+  let height = label.height
+  if ("axis" in label && label.axis === "y") {
+    width = label.height
+    height = label.width
+  }
+  const bounds = getBoundFromCenteredRect({
+    center: label.center,
+    width,
+    height,
+  })
+  for (let pathIndex = 0; pathIndex < path.length - 1; pathIndex++) {
+    if (
+      doesSegmentIntersectRect(path[pathIndex]!, path[pathIndex + 1]!, bounds)
+    ) {
+      return true
+    }
+  }
+  return false
+}
+
+const getPerpendicularOffset = (
+  firstPin: TraceRecoveryPin,
+  secondPin: TraceRecoveryPin,
+) => {
+  const xDistance = Math.abs(firstPin.x - secondPin.x)
+  const yDistance = Math.abs(firstPin.y - secondPin.y)
+  if (xDistance >= yDistance) return yDistance
+  return xDistance
+}
+
+export class NetLabelToTraceSolver extends BaseSolver {
+  inputProblem: InputProblem
+
+  outputTraces: SolvedTracePath[]
+  outputNetLabelPlacements: NetLabelPlacement[]
+
+  private chipMap: Record<ChipId, InputChip>
+  private pinMap: Map<PinId, TraceRecoveryPin>
+  private queuedCandidates: CandidatePair[]
+  private currentCandidate: CandidatePair | null = null
+  declare activeSubSolver: SchematicTraceSingleLineSolver2 | null
+
+  constructor(private input: InlineNetLabelOutput) {
+    super()
+    this.inputProblem = input.inputProblem
+    this.outputTraces = [...input.traces]
+    this.outputNetLabelPlacements = [...input.netLabelPlacements]
+
+    const { chipMap, pinMap } = getTraceRecoveryConnectivityMaps(
+      this.inputProblem,
+    )
+    this.chipMap = chipMap
+    this.pinMap = pinMap
+
+    this.queuedCandidates = this.buildCandidatePairs()
+    this.stats.candidateCount = this.queuedCandidates.length
+    this.stats.recoveredTraceCount = 0
+  }
+
+  override getConstructorParams(): [InlineNetLabelOutput] {
+    return [this.input]
+  }
+
+  private isEligiblePortOnlyDirectConnectionLabel(
+    label: NetLabelPlacement,
+    groundGlobalConnNetId?: GlobalConnNetId,
+  ) {
+    if (
+      label.pinIds.length !== 1 ||
+      label.mspConnectionPairIds.length !== 0 ||
+      !label.netId ||
+      label.netId === "GND" ||
+      label.globalConnNetId === groundGlobalConnNetId
+    ) {
+      return false
+    }
+
+    const pinId = label.pinIds[0]!
+    return this.inputProblem.directConnections.some(
+      (connection) =>
+        connection.netId === label.netId && connection.pinIds.includes(pinId),
+    )
+  }
+
+  private buildCandidatePairs() {
+    const { netConnMap } = getConnectivityMapsFromInputProblem(
+      this.inputProblem,
+    )
+    const groundGlobalConnNetId =
+      netConnMap.getNetConnectedToId("GND") ?? undefined
+    const labelsByGlobalNet = new Map<GlobalConnNetId, NetLabelPlacement[]>()
+
+    for (const label of this.input.netLabelPlacements) {
+      if (
+        !this.isEligiblePortOnlyDirectConnectionLabel(
+          label,
+          groundGlobalConnNetId,
+        )
+      ) {
+        continue
+      }
+      const labels = labelsByGlobalNet.get(label.globalConnNetId) ?? []
+      labels.push(label)
+      labelsByGlobalNet.set(label.globalConnNetId, labels)
+    }
+
+    const candidates: CandidatePair[] = []
+    for (const labels of labelsByGlobalNet.values()) {
+      for (let firstIndex = 0; firstIndex < labels.length; firstIndex++) {
+        for (
+          let secondIndex = firstIndex + 1;
+          secondIndex < labels.length;
+          secondIndex++
+        ) {
+          const firstLabel = labels[firstIndex]!
+          const secondLabel = labels[secondIndex]!
+          const firstPin = this.pinMap.get(firstLabel.pinIds[0]!)
+          const secondPin = this.pinMap.get(secondLabel.pinIds[0]!)
+          if (!firstPin || !secondPin) continue
+          if (
+            arePinsInDifferentSchematicSections(
+              this.inputProblem,
+              firstPin,
+              secondPin,
+            )
+          ) {
+            continue
+          }
+          if (
+            doesPairCrossRestrictedCenterLines({
+              inputProblem: this.inputProblem,
+              chipMap: this.chipMap,
+              pinIdMap: this.pinMap,
+              p1: firstPin,
+              p2: secondPin,
+            })
+          ) {
+            continue
+          }
+
+          candidates.push({
+            firstLabel,
+            secondLabel,
+            pins: [firstPin, secondPin],
+            perpendicularOffset: getPerpendicularOffset(firstPin, secondPin),
+            routeDistance:
+              Math.abs(firstPin.x - secondPin.x) +
+              Math.abs(firstPin.y - secondPin.y),
+            key: getCanonicalPairKey(firstPin.pinId, secondPin.pinId),
+          })
+        }
+      }
+    }
+
+    candidates.sort(
+      (first, second) =>
+        first.perpendicularOffset - second.perpendicularOffset ||
+        first.routeDistance - second.routeDistance ||
+        first.key.localeCompare(second.key),
+    )
+    return candidates
+  }
+
+  private isSupersededConnectorTrace(
+    trace: SolvedTracePath,
+    candidate: CandidatePair,
+  ) {
+    if (!trace.mspPairId.startsWith(AVAILABLE_NET_ORIENTATION_PREFIX)) {
+      return false
+    }
+    if (trace.pinIds.length !== 1) return false
+    return candidate.pins.some((pin) => pin.pinId === trace.pinIds[0])
+  }
+
+  private routeIntersectsRemainingLabels(
+    tracePath: Point[],
+    candidate: CandidatePair,
+  ) {
+    for (const label of this.outputNetLabelPlacements) {
+      if (label === candidate.firstLabel || label === candidate.secondLabel) {
+        continue
+      }
+      if (pathIntersectsRenderedLabel(tracePath, label)) return true
+    }
+    return this.input.inlineNetLabelPlacements.some((label) =>
+      pathIntersectsRenderedLabel(tracePath, label),
+    )
+  }
+
+  private tryAcceptCurrentRoute() {
+    const candidate = this.currentCandidate
+    const tracePath = this.activeSubSolver?.solvedTracePath
+    if (!candidate || !tracePath) return
+
+    const retainedTraces = this.outputTraces.filter(
+      (trace) => !this.isSupersededConnectorTrace(trace, candidate),
+    )
+    if (
+      doesTraceOverlapWithExistingTraces(tracePath, retainedTraces) ||
+      this.routeIntersectsRemainingLabels(tracePath, candidate)
+    ) {
+      return
+    }
+
+    const [firstPin, secondPin] = candidate.pins
+    const mspPairId = `${RECOVERED_TRACE_PREFIX}${candidate.key}`
+    const recoveredTrace: SolvedTracePath = {
+      mspPairId,
+      dcConnNetId: candidate.firstLabel.globalConnNetId,
+      globalConnNetId: candidate.firstLabel.globalConnNetId,
+      pins: [firstPin, secondPin],
+      tracePath,
+      mspConnectionPairIds: [mspPairId],
+      pinIds: [firstPin.pinId, secondPin.pinId],
+    }
+
+    this.outputTraces = [...retainedTraces, recoveredTrace]
+    this.outputNetLabelPlacements = this.outputNetLabelPlacements.filter(
+      (label) =>
+        label !== candidate.firstLabel && label !== candidate.secondLabel,
+    )
+    this.stats.recoveredTraceCount++
+  }
+
+  override _step() {
+    if (this.activeSubSolver) {
+      this.activeSubSolver.step()
+      if (this.activeSubSolver.solved) {
+        this.tryAcceptCurrentRoute()
+        this.activeSubSolver = null
+        this.currentCandidate = null
+      } else if (this.activeSubSolver.failed) {
+        this.activeSubSolver = null
+        this.currentCandidate = null
+      }
+      return
+    }
+
+    let candidate = this.queuedCandidates.shift()
+    while (
+      candidate &&
+      (!this.outputNetLabelPlacements.includes(candidate.firstLabel) ||
+        !this.outputNetLabelPlacements.includes(candidate.secondLabel))
+    ) {
+      candidate = this.queuedCandidates.shift()
+    }
+
+    if (!candidate) {
+      this.solved = true
+      return
+    }
+
+    this.currentCandidate = candidate
+    this.activeSubSolver = new SchematicTraceSingleLineSolver2({
+      inputProblem: this.inputProblem,
+      pins: candidate.pins,
+      chipMap: this.chipMap,
+    })
+  }
+
+  getOutput() {
+    return {
+      traces: this.outputTraces,
+      netLabelPlacements: this.outputNetLabelPlacements,
+      inlineNetLabelPlacements: this.input.inlineNetLabelPlacements,
+    }
+  }
+
+  override visualize(): GraphicsObject {
+    if (this.activeSubSolver) return this.activeSubSolver.visualize()
+
+    const graphics = visualizeInlineNetLabelOutput({
+      inputProblem: this.inputProblem,
+      ...this.getOutput(),
+    })
+    for (const trace of this.outputTraces) {
+      if (!trace.mspPairId.startsWith(RECOVERED_TRACE_PREFIX)) continue
+      graphics.lines!.push({
+        points: trace.tracePath,
+        strokeColor: "green",
+        label: `recovered from net labels: ${trace.pinIds.join(" -> ")}`,
+      })
+    }
+    return graphics
+  }
+}

package/lib/solvers/NetLabelTraceRecovery/getTraceRecoveryConnectivityMaps.ts

@@ -0,0 +1,33 @@
+import { getPinDirection } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver/getPinDirection"
+import type { MspConnectionPair } from "lib/solvers/MspConnectionPairSolver/MspConnectionPairSolver"
+import type {
+  ChipId,
+  InputChip,
+  InputProblem,
+  PinId,
+} from "lib/types/InputProblem"
+import type { FacingDirection } from "lib/utils/dir"
+
+export type TraceRecoveryPin = MspConnectionPair["pins"][number] & {
+  _facingDirection: FacingDirection
+}
+
+export const getTraceRecoveryConnectivityMaps = (
+  inputProblem: InputProblem,
+) => {
+  const chipMap: Record<ChipId, InputChip> = {}
+  const pinMap = new Map<PinId, TraceRecoveryPin>()
+
+  for (const chip of inputProblem.chips) {
+    chipMap[chip.chipId] = chip
+    for (const pin of chip.pins) {
+      pinMap.set(pin.pinId, {
+        ...pin,
+        chipId: chip.chipId,
+        _facingDirection: pin._facingDirection ?? getPinDirection(pin, chip),
+      })
+    }
+  }
+
+  return { chipMap, pinMap }
+}

package/lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver.ts

@@ -35,6 +35,7 @@ import { UnroutedTraceRecoverySolver } from "../UnroutedTraceRecoverySolver/Unro
 import { SameNetJunctionAlignmentSolver } from "../SameNetJunctionAlignmentSolver/SameNetJunctionAlignmentSolver"
 import { TraceElbowTransitionSimplificationSolver } from "../TraceElbowTransitionSimplificationSolver/TraceElbowTransitionSimplificationSolver"
 import { InlineNetLabelSolver } from "../InlineNetLabelSolver/InlineNetLabelSolver"
+import { NetLabelToTraceSolver } from "../NetLabelToTraceSolver/NetLabelToTraceSolver"
 import { findPerpendicularPathCrossings } from "../TraceCleanupSolver/sub-solver/findIntersectionsWithObstacles"
 
 type PipelineStep<T extends new (...args: any[]) => BaseSolver> = {
@@ -103,6 +104,7 @@ export class SchematicTracePipelineSolver extends BaseSolver {
   finalTraceElbowTransitionSimplificationSolver?: TraceElbowTransitionSimplificationSolver
   sameNetJunctionAlignmentSolver?: SameNetJunctionAlignmentSolver
   inlineNetLabelSolver?: InlineNetLabelSolver
+  netLabelToTraceSolver?: NetLabelToTraceSolver
 
   startTimeOfPhase: Record<string, number>
   endTimeOfPhase: Record<string, number>
@@ -588,6 +590,19 @@ export class SchematicTracePipelineSolver extends BaseSolver {
         ]
       },
     ),
+    definePipelineStep(
+      "netLabelToTraceSolver",
+      NetLabelToTraceSolver,
+      (instance) => {
+        const inlineOutput = instance.inlineNetLabelSolver!.getOutput()
+        return [
+          {
+            inputProblem: instance.inputProblem,
+            ...inlineOutput,
+          },
+        ]
+      },
+    ),
   ]
 
   constructor(inputProblem: InputProblem, opts?: Options) {

package/package.json

@@ -5,7 +5,7 @@
     "url": "https://github.com/tscircuit/schematic-trace-solver.git"
   },
   "main": "dist/index.js",
-  "version": "0.0.150",
+  "version": "0.0.151",
   "type": "module",
   "scripts": {
     "start": "cosmos",