@tscircuit/schematic-trace-solver 0.0.1

package/lib/solvers/MspConnectionPairSolver/getMspConnectionPairsFromPins.ts

@@ -0,0 +1,96 @@
+import type { InputPin, PinId } from "lib/types/InputProblem"
+
+/**
+ * Compute the Orthogonal (Manhattan/L1) Minimum Spanning Tree (MST)
+ * for a set of points and return it as pairs of connected PinIds.
+ *
+ * The MST minimizes total |Δx| + |Δy| distance and fully connects all points.
+ * Uses Prim's algorithm with O(n^2) time and O(n) extra space.
+ *
+ * Edge cases:
+ * - []           -> []
+ * - [one point]  -> []
+ * - duplicate coordinates are allowed (0-length edges possible)
+ *
+ * Deterministic tie-breaking:
+ * - When multiple candidates have the same distance, we pick the one
+ *   whose pinId is lexicographically smallest (for stable output).
+ */
+export function getOrthogonalMinimumSpanningTree(
+  pins: InputPin[],
+): Array<[PinId, PinId]> {
+  const n = pins.length
+  if (n <= 1) return []
+
+  // Quick validation (optional; remove if hot path)
+  // Ensure pinIds are unique to avoid ambiguous output edges.
+  {
+    const seen = new Set<string>()
+    for (const p of pins) {
+      if (seen.has(p.pinId)) {
+        throw new Error(`Duplicate pinId detected: "${p.pinId}"`)
+      }
+      seen.add(p.pinId)
+    }
+  }
+
+  // Helper: Manhattan distance
+  const manhattan = (a: InputPin, b: InputPin) =>
+    Math.abs(a.x - b.x) + Math.abs(a.y - b.y)
+
+  // Prim's data structures
+  const inTree = new Array<boolean>(n).fill(false)
+  const bestDist = new Array<number>(n).fill(Number.POSITIVE_INFINITY)
+  const parent = new Array<number>(n).fill(-1)
+
+  // Start from the point with lexicographically smallest pinId (stable)
+  let startIndex = 0
+  for (let i = 1; i < n; i++) {
+    if (pins[i].pinId < pins[startIndex].pinId) startIndex = i
+  }
+  bestDist[startIndex] = 0
+
+  const edges: Array<[PinId, PinId]> = []
+  for (let iter = 0; iter < n; iter++) {
+    // Pick the next vertex u with minimal bestDist[u] not yet in the tree
+    let u = -1
+    let best = Number.POSITIVE_INFINITY
+    let bestId = "" // for tie-breaking
+    for (let i = 0; i < n; i++) {
+      if (!inTree[i]) {
+        const d = bestDist[i]
+        if (
+          d < best ||
+          (d === best && (bestId === "" || pins[i].pinId < bestId))
+        ) {
+          best = d
+          bestId = pins[i].pinId
+          u = i
+        }
+      }
+    }
+
+    // Add u to the tree
+    inTree[u] = true
+    if (parent[u] !== -1) {
+      edges.push([pins[u].pinId, pins[parent[u]].pinId])
+    }
+
+    // Relax edges from u to all v not yet in the tree
+    for (let v = 0; v < n; v++) {
+      if (!inTree[v]) {
+        const d = manhattan(pins[u], pins[v])
+        if (
+          d < bestDist[v] ||
+          (d === bestDist[v] && pins[u].pinId < pins[parent[v]]?.pinId)
+        ) {
+          bestDist[v] = d
+          parent[v] = u
+        }
+      }
+    }
+  }
+
+  // edges.length === n-1 when n>0
+  return edges
+}

package/lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver.ts

@@ -0,0 +1,192 @@
+import { BaseSolver } from "lib/solvers/BaseSolver/BaseSolver"
+import type { InputProblem } from "lib/types/InputProblem"
+import type { SolvedTracePath } from "../SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import type { MspConnectionPairId } from "../MspConnectionPairSolver/MspConnectionPairSolver"
+import { SingleNetLabelPlacementSolver } from "./SingleNetLabelPlacementSolver/SingleNetLabelPlacementSolver"
+import type { FacingDirection } from "lib/utils/dir"
+import type { Point } from "@tscircuit/math-utils"
+import type { GraphicsObject } from "graphics-debug"
+import { visualizeInputProblem } from "../SchematicTracePipelineSolver/visualizeInputProblem"
+import { getColorFromString } from "lib/utils/getColorFromString"
+
+/**
+ * A group of traces that have at least one overlapping segment and
+ * are part of the same global connectivity net
+ */
+export type OverlappingSameNetTraceGroup = {
+  globalConnNetId: string
+  netId?: string
+  overlappingTraces: SolvedTracePath
+}
+
+export interface NetLabelPlacement {
+  globalConnNetId: string
+  dcConnNetId?: string
+  orientation: FacingDirection
+
+  /**
+   * The anchor point is the point on the trace where the net label connects
+   */
+  anchorPoint: Point
+
+  width: number
+  height: number
+
+  /**
+   * The center point is computed from the anchor point, the width and height
+   * and the orientation.
+   */
+  center: Point
+}
+
+/**
+ * Places net labels in an available orientation along a trace in each group.
+ *
+ * Trace groups each receive either one net label or no net label if there
+ * isn't a netId.
+ *
+ * The specific placement of the net label is solved for using the
+ */
+export class NetLabelPlacementSolver extends BaseSolver {
+  inputProblem: InputProblem
+  inputTraceMap: Record<MspConnectionPairId, SolvedTracePath>
+
+  overlappingSameNetTraceGroups: Array<OverlappingSameNetTraceGroup>
+
+  queuedOverlappingSameNetTraceGroups: Array<OverlappingSameNetTraceGroup>
+
+  declare activeSubSolver: SingleNetLabelPlacementSolver | null
+
+  netLabelPlacements: Array<NetLabelPlacement> = []
+
+  constructor(params: {
+    inputProblem: InputProblem
+    inputTraceMap: Record<MspConnectionPairId, SolvedTracePath>
+  }) {
+    super()
+    this.inputProblem = params.inputProblem
+    this.inputTraceMap = params.inputTraceMap
+
+    this.overlappingSameNetTraceGroups =
+      this.computeOverlappingSameNetTraceGroups()
+
+    this.queuedOverlappingSameNetTraceGroups = [
+      ...this.overlappingSameNetTraceGroups,
+    ]
+  }
+
+  computeOverlappingSameNetTraceGroups(): Array<OverlappingSameNetTraceGroup> {
+    // Group traces by their global connectivity net id.
+    const byGlobal: Record<string, Array<SolvedTracePath>> = {}
+    for (const trace of Object.values(this.inputTraceMap)) {
+      const key = trace.globalConnNetId
+      if (!byGlobal[key]) byGlobal[key] = []
+      byGlobal[key].push(trace)
+    }
+
+    // For each group, pick a representative path (longest by L1 length).
+    const groups: Array<OverlappingSameNetTraceGroup> = []
+    for (const [globalConnNetId, traces] of Object.entries(byGlobal)) {
+      if (traces.length === 0) continue
+      const lengthOf = (path: SolvedTracePath) => {
+        let sum = 0
+        const pts = path.tracePath
+        for (let i = 0; i < pts.length - 1; i++) {
+          sum +=
+            Math.abs(pts[i + 1]!.x - pts[i]!.x) +
+            Math.abs(pts[i + 1]!.y - pts[i]!.y)
+        }
+        return sum
+      }
+      let rep = traces[0]!
+      let repLen = lengthOf(rep)
+      for (let i = 1; i < traces.length; i++) {
+        const len = lengthOf(traces[i]!)
+        if (len > repLen) {
+          rep = traces[i]!
+          repLen = len
+        }
+      }
+      const userNetId = traces.find((t) => t.userNetId != null)?.userNetId
+      groups.push({
+        globalConnNetId,
+        netId: userNetId,
+        overlappingTraces: rep,
+      })
+    }
+
+    return groups
+  }
+
+  override _step() {
+    if (this.activeSubSolver?.solved) {
+      this.netLabelPlacements.push(this.activeSubSolver.netLabelPlacement!)
+      this.activeSubSolver = null
+      return
+    }
+
+    if (this.activeSubSolver?.failed) {
+      this.failed = true
+      this.error = this.activeSubSolver.error
+      return
+    }
+
+    if (this.activeSubSolver) {
+      this.activeSubSolver.step()
+      return
+    }
+
+    const nextOverlappingSameNetTraceGroup =
+      this.queuedOverlappingSameNetTraceGroups.shift()
+
+    if (!nextOverlappingSameNetTraceGroup) {
+      this.solved = true
+      return
+    }
+
+    const netId =
+      nextOverlappingSameNetTraceGroup.netId ??
+      nextOverlappingSameNetTraceGroup.globalConnNetId
+
+    this.activeSubSolver = new SingleNetLabelPlacementSolver({
+      inputProblem: this.inputProblem,
+      inputTraceMap: this.inputTraceMap,
+      overlappingSameNetTraceGroup: nextOverlappingSameNetTraceGroup,
+      availableOrientations: this.inputProblem.availableNetLabelOrientations[
+        netId
+      ] ?? ["x+", "x-", "y+", "y-"],
+    })
+  }
+
+  override visualize(): GraphicsObject {
+    if (this.activeSubSolver) {
+      return this.activeSubSolver.visualize()
+    }
+    const graphics = visualizeInputProblem(this.inputProblem)
+
+    for (const trace of Object.values(this.inputTraceMap)) {
+      graphics.lines!.push({
+        points: trace.tracePath,
+        strokeColor: "purple",
+        strokeWidth: 0.005,
+      })
+    }
+
+    for (const p of this.netLabelPlacements) {
+      graphics.rects!.push({
+        center: p.center,
+        width: p.width,
+        height: p.height,
+        fill: getColorFromString(p.globalConnNetId, 0.35),
+        strokeColor: getColorFromString(p.globalConnNetId, 0.9),
+      } as any)
+      graphics.points!.push({
+        x: p.anchorPoint.x,
+        y: p.anchorPoint.y,
+        color: getColorFromString(p.globalConnNetId, 0.9),
+      } as any)
+    }
+
+    return graphics
+  }
+}