@tscircuit/schematic-trace-solver 0.0.50 → 0.0.52

package/lib/solvers/TraceAnchoredNetLabelOverlapSolver/visualize.ts

@@ -0,0 +1,125 @@
+import type { GraphicsObject } from "graphics-debug"
+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 { getColorFromString } from "lib/utils/getColorFromString"
+import type { LabelCandidate, LabelOverlap } from "./types"
+
+const CANDIDATE_SELECTED_COLOR = "blue"
+const CANDIDATE_REJECTED_COLOR = "red"
+
+export const visualizeTraceAnchoredNetLabelOverlapSolver = (state: {
+  inputProblem: InputProblem
+  traces: SolvedTracePath[]
+  outputNetLabelPlacements: NetLabelPlacement[]
+  currentOverlap: LabelOverlap | null
+  currentCandidateResults: LabelCandidate[]
+  solved: boolean
+}): GraphicsObject => {
+  const graphics = visualizeInputProblem(state.inputProblem)
+  ensureGraphicsArrays(graphics)
+
+  drawTraces(graphics, state.traces)
+  drawNetLabels(graphics, state.outputNetLabelPlacements)
+
+  if (!state.solved) {
+    drawCurrentOverlap(graphics, state)
+    drawCurrentCandidates(graphics, state.currentCandidateResults)
+  }
+
+  return graphics
+}
+
+const drawTraces = (graphics: GraphicsObject, traces: SolvedTracePath[]) => {
+  for (const trace of traces) {
+    graphics.lines!.push({
+      points: trace.tracePath,
+      strokeColor: "purple",
+    } as any)
+  }
+}
+
+const drawNetLabels = (
+  graphics: GraphicsObject,
+  labels: NetLabelPlacement[],
+) => {
+  for (const label of labels) {
+    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),
+      label: `anchorPoint\norientation: ${label.orientation}`,
+    } as any)
+  }
+}
+
+const drawCurrentOverlap = (
+  graphics: GraphicsObject,
+  state: {
+    outputNetLabelPlacements: NetLabelPlacement[]
+    currentOverlap: LabelOverlap | null
+  },
+) => {
+  if (!state.currentOverlap) return
+
+  for (const labelIndex of [
+    state.currentOverlap.firstLabelIndex,
+    state.currentOverlap.secondLabelIndex,
+  ]) {
+    const label = state.outputNetLabelPlacements[labelIndex]
+    if (!label) continue
+
+    graphics.rects!.push({
+      center: label.center,
+      width: label.width,
+      height: label.height,
+      fill: "rgba(255, 0, 0, 0.2)",
+      strokeColor: CANDIDATE_REJECTED_COLOR,
+      label: `netlabel overlap target\n${label.netId ?? label.globalConnNetId}`,
+    } as any)
+  }
+}
+
+const drawCurrentCandidates = (
+  graphics: GraphicsObject,
+  candidates: LabelCandidate[],
+) => {
+  for (const candidate of candidates) {
+    const color = candidate.selected
+      ? CANDIDATE_SELECTED_COLOR
+      : CANDIDATE_REJECTED_COLOR
+    graphics.rects!.push({
+      center: candidate.center,
+      width: candidate.width,
+      height: candidate.height,
+      fill: candidate.selected
+        ? "rgba(0, 0, 255, 0.2)"
+        : "rgba(255, 0, 0, 0.15)",
+      strokeColor: color,
+      strokeDash: candidate.selected ? undefined : "4 2",
+      label: `${candidate.selected ? "selected" : candidate.status} netlabel overlap candidate\ntrace: ${candidate.traceId}\ndistance: ${candidate.distanceFromOriginal.toFixed(3)}`,
+    } as any)
+    graphics.points!.push({
+      ...candidate.anchorPoint,
+      color,
+      label: `candidate anchor\n${candidate.status}`,
+    } as any)
+  }
+}
+
+const ensureGraphicsArrays = (graphics: GraphicsObject) => {
+  if (!graphics.lines) graphics.lines = []
+  if (!graphics.points) graphics.points = []
+  if (!graphics.rects) graphics.rects = []
+  if (!graphics.circles) graphics.circles = []
+  if (!graphics.texts) graphics.texts = []
+}

package/lib/solvers/VccNetLabelCornerPlacementSolver/VccNetLabelCornerPlacementSolver.ts

@@ -0,0 +1,268 @@
+import type { GraphicsObject } from "graphics-debug"
+import { traceCrossesBoundsInterior } from "lib/solvers/AvailableNetOrientationSolver/geometry"
+import { BaseSolver } from "lib/solvers/BaseSolver/BaseSolver"
+import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
+import {
+  getCenterFromAnchor,
+  getRectBounds,
+} from "lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/geometry"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import type { InputProblem } from "lib/types/InputProblem"
+import {
+  getDistance,
+  getTraceCorners,
+  isTraceLine,
+  rectsOverlap,
+  tracePathContainsPoint,
+} from "./geometry"
+import type {
+  Bounds,
+  CornerCandidateStatus,
+  EvaluatedCornerCandidate,
+  TraceCornerCandidate,
+  VccNetLabelCornerPlacementSolverParams,
+} from "./types"
+import { visualizeVccNetLabelCornerPlacementSolver } from "./visualize"
+
+export class VccNetLabelCornerPlacementSolver extends BaseSolver {
+  inputProblem: InputProblem
+  traces: SolvedTracePath[]
+  netLabelPlacements: NetLabelPlacement[]
+
+  outputNetLabelPlacements: NetLabelPlacement[]
+  queuedLabelIndices: number[] = []
+  currentLabelIndex: number | null = null
+  currentLabel: NetLabelPlacement | null = null
+  currentCandidateResults: EvaluatedCornerCandidate[] = []
+
+  private queuedCornerCandidates: TraceCornerCandidate[] = []
+  private shouldAdvanceToNextLabel = false
+  private traceMap: Record<string, SolvedTracePath>
+
+  constructor(params: VccNetLabelCornerPlacementSolverParams) {
+    super()
+    this.inputProblem = params.inputProblem
+    this.traces = params.traces
+    this.netLabelPlacements = params.netLabelPlacements
+    this.outputNetLabelPlacements = [...params.netLabelPlacements]
+    this.traceMap = Object.fromEntries(
+      params.traces.map((trace) => [trace.mspPairId, trace]),
+    )
+    this.queuedLabelIndices = this.getProcessableLabelIndices()
+    this.prepareNextLabel()
+  }
+
+  override getConstructorParams(): ConstructorParameters<
+    typeof VccNetLabelCornerPlacementSolver
+  >[0] {
+    return {
+      inputProblem: this.inputProblem,
+      traces: this.traces,
+      netLabelPlacements: this.netLabelPlacements,
+    }
+  }
+
+  override _step() {
+    if (this.shouldAdvanceToNextLabel) {
+      this.advanceToNextLabel()
+      return
+    }
+
+    const label = this.currentLabel
+    const labelIndex = this.currentLabelIndex
+    if (label === null || labelIndex === null) {
+      this.finish()
+      return
+    }
+
+    const candidate = this.queuedCornerCandidates.shift()
+    if (!candidate) {
+      this.shouldAdvanceToNextLabel = true
+      return
+    }
+
+    const result = this.evaluateCornerCandidate(label, labelIndex, candidate)
+    this.currentCandidateResults.push(result)
+
+    if (result.status !== "valid") return
+
+    result.selected = true
+    this.applyCandidate(labelIndex, label, result)
+    this.shouldAdvanceToNextLabel = true
+  }
+
+  getOutput() {
+    return {
+      netLabelPlacements: this.outputNetLabelPlacements,
+    }
+  }
+
+  private getProcessableLabelIndices() {
+    const labelIndices: number[] = []
+
+    for (let i = 0; i < this.outputNetLabelPlacements.length; i++) {
+      const label = this.outputNetLabelPlacements[i]!
+      if (!this.shouldProcessLabel(label)) continue
+
+      labelIndices.push(i)
+    }
+
+    return labelIndices
+  }
+
+  private prepareNextLabel() {
+    const labelIndex = this.queuedLabelIndices.shift()
+    if (labelIndex === undefined) {
+      this.clearCurrentLabel()
+      return false
+    }
+
+    const label = this.outputNetLabelPlacements[labelIndex]!
+    this.currentLabelIndex = labelIndex
+    this.currentLabel = label
+    this.currentCandidateResults = []
+    this.queuedCornerCandidates = this.getCornerCandidatesForLabel(label)
+
+    return true
+  }
+
+  private advanceToNextLabel() {
+    this.shouldAdvanceToNextLabel = false
+    if (!this.prepareNextLabel()) this.finish()
+  }
+
+  private clearCurrentLabel() {
+    this.currentLabelIndex = null
+    this.currentLabel = null
+    this.currentCandidateResults = []
+    this.queuedCornerCandidates = []
+  }
+
+  private finish() {
+    this.clearCurrentLabel()
+    this.solved = true
+  }
+
+  private evaluateCornerCandidate(
+    label: NetLabelPlacement,
+    labelIndex: number,
+    candidate: TraceCornerCandidate,
+  ): EvaluatedCornerCandidate {
+    const center = getCenterFromAnchor(
+      candidate.anchorPoint,
+      label.orientation,
+      label.width,
+      label.height,
+    )
+    const bounds = getRectBounds(center, label.width, label.height)
+
+    return {
+      ...candidate,
+      center,
+      width: label.width,
+      height: label.height,
+      status: this.getCandidateStatus(bounds, labelIndex),
+      selected: false,
+    }
+  }
+
+  private getCandidateStatus(
+    bounds: Bounds,
+    labelIndex: number,
+  ): CornerCandidateStatus {
+    if (this.intersectsAnyChip(bounds)) return "chip-collision"
+    if (traceCrossesBoundsInterior(bounds, this.traceMap)) {
+      return "trace-collision"
+    }
+    if (this.intersectsAnyOtherNetLabel(bounds, labelIndex)) {
+      return "netlabel-collision"
+    }
+
+    return "valid"
+  }
+
+  private applyCandidate(
+    labelIndex: number,
+    label: NetLabelPlacement,
+    candidate: EvaluatedCornerCandidate,
+  ) {
+    this.outputNetLabelPlacements[labelIndex] = {
+      ...label,
+      anchorPoint: candidate.anchorPoint,
+      center: candidate.center,
+    }
+  }
+
+  private shouldProcessLabel(label: NetLabelPlacement) {
+    return (
+      label.netId === "VCC" &&
+      this.getCornerCandidatesForLabel(label).length > 0
+    )
+  }
+
+  private intersectsAnyChip(bounds: Bounds) {
+    return this.inputProblem.chips.some((chip) =>
+      rectsOverlap(bounds, getRectBounds(chip.center, chip.width, chip.height)),
+    )
+  }
+
+  private intersectsAnyOtherNetLabel(bounds: Bounds, labelIndex: number) {
+    return this.outputNetLabelPlacements.some((label, index) => {
+      if (index === labelIndex) return false
+      return rectsOverlap(
+        bounds,
+        getRectBounds(label.center, label.width, label.height),
+      )
+    })
+  }
+
+  private getCornerCandidatesForLabel(label: NetLabelPlacement) {
+    const candidates: TraceCornerCandidate[] = []
+    const seenCornerKeys = new Set<string>()
+
+    for (const trace of this.getTraceLinesForLabel(label)) {
+      for (const anchorPoint of getTraceCorners(trace.tracePath)) {
+        const key = `${anchorPoint.x}:${anchorPoint.y}`
+        if (seenCornerKeys.has(key)) continue
+        seenCornerKeys.add(key)
+        candidates.push({
+          anchorPoint,
+          traceId: trace.mspPairId,
+          distance: getDistance(anchorPoint, label.anchorPoint),
+        })
+      }
+    }
+
+    return candidates.sort((a, b) => a.distance - b.distance)
+  }
+
+  private getTraceLinesForLabel(label: NetLabelPlacement) {
+    return this.traces.filter(
+      (trace) => isTraceLine(trace) && this.isTraceForLabel(trace, label),
+    )
+  }
+
+  private isTraceForLabel(trace: SolvedTracePath, label: NetLabelPlacement) {
+    if (!tracePathContainsPoint(trace.tracePath, label.anchorPoint)) {
+      return false
+    }
+
+    const traceIds = new Set(label.mspConnectionPairIds)
+    if (traceIds.size > 0) {
+      return traceIds.has(trace.mspPairId)
+    }
+
+    return trace.globalConnNetId === label.globalConnNetId
+  }
+
+  override visualize(): GraphicsObject {
+    return visualizeVccNetLabelCornerPlacementSolver({
+      inputProblem: this.inputProblem,
+      traces: this.traces,
+      outputNetLabelPlacements: this.outputNetLabelPlacements,
+      currentLabel: this.currentLabel,
+      currentCandidateResults: this.currentCandidateResults,
+      solved: this.solved,
+    })
+  }
+}

package/lib/solvers/VccNetLabelCornerPlacementSolver/geometry.ts

@@ -0,0 +1,59 @@
+import type { Point } from "@tscircuit/math-utils"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import type { Bounds } from "./types"
+
+export const EPS = 1e-6
+
+export const isTraceLine = (trace: SolvedTracePath) =>
+  getUniquePinCount(trace.pinIds) >= 2
+
+export const rectsOverlap = (a: Bounds, b: Bounds) =>
+  Math.min(a.maxX, b.maxX) - Math.max(a.minX, b.minX) > EPS &&
+  Math.min(a.maxY, b.maxY) - Math.max(a.minY, b.minY) > EPS
+
+export const getTraceCorners = (path: Point[]) => {
+  const corners: Point[] = []
+  for (let i = 1; i < path.length - 1; i++) {
+    const previousPoint = path[i - 1]!
+    const cornerPoint = path[i]!
+    const nextPoint = path[i + 1]!
+    if (isTraceCorner(previousPoint, cornerPoint, nextPoint)) {
+      corners.push(cornerPoint)
+    }
+  }
+  return corners
+}
+
+export const tracePathContainsPoint = (path: Point[], point: Point) => {
+  for (let i = 0; i < path.length - 1; i++) {
+    if (isPointOnSegment(point, path[i]!, path[i + 1]!)) return true
+  }
+  return false
+}
+
+export const getDistance = (a: Point, b: Point) =>
+  Math.abs(a.x - b.x) + Math.abs(a.y - b.y)
+
+const getUniquePinCount = (pinIds: string[]) => new Set(pinIds).size
+
+const isTraceCorner = (a: Point, b: Point, c: Point) =>
+  getSegmentOrientation(a, b) !== getSegmentOrientation(b, c)
+
+const isPointOnSegment = (point: Point, start: Point, end: Point) => {
+  if (getSegmentOrientation(start, end) === "horizontal") {
+    return (
+      Math.abs(point.y - start.y) <= EPS &&
+      point.x >= Math.min(start.x, end.x) - EPS &&
+      point.x <= Math.max(start.x, end.x) + EPS
+    )
+  }
+
+  return (
+    Math.abs(point.x - start.x) <= EPS &&
+    point.y >= Math.min(start.y, end.y) - EPS &&
+    point.y <= Math.max(start.y, end.y) + EPS
+  )
+}
+
+const getSegmentOrientation = (a: Point, b: Point) =>
+  Math.abs(a.y - b.y) <= EPS ? "horizontal" : "vertical"

package/lib/solvers/VccNetLabelCornerPlacementSolver/types.ts

@@ -0,0 +1,37 @@
+import type { Point } from "@tscircuit/math-utils"
+import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import type { InputProblem } from "lib/types/InputProblem"
+
+export interface VccNetLabelCornerPlacementSolverParams {
+  inputProblem: InputProblem
+  traces: SolvedTracePath[]
+  netLabelPlacements: NetLabelPlacement[]
+}
+
+export type Bounds = {
+  minX: number
+  minY: number
+  maxX: number
+  maxY: number
+}
+
+export type TraceCornerCandidate = {
+  anchorPoint: Point
+  traceId: string
+  distance: number
+}
+
+export type CornerCandidateStatus =
+  | "valid"
+  | "chip-collision"
+  | "trace-collision"
+  | "netlabel-collision"
+
+export type EvaluatedCornerCandidate = TraceCornerCandidate & {
+  center: Point
+  width: number
+  height: number
+  status: CornerCandidateStatus
+  selected: boolean
+}

package/lib/solvers/VccNetLabelCornerPlacementSolver/visualize.ts

@@ -0,0 +1,114 @@
+import type { GraphicsObject } from "graphics-debug"
+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 { getColorFromString } from "lib/utils/getColorFromString"
+import type { EvaluatedCornerCandidate } from "./types"
+
+const CANDIDATE_SELECTED_COLOR = "blue"
+const CANDIDATE_REJECTED_COLOR = "red"
+
+export const visualizeVccNetLabelCornerPlacementSolver = (state: {
+  inputProblem: InputProblem
+  traces: SolvedTracePath[]
+  outputNetLabelPlacements: NetLabelPlacement[]
+  currentLabel: NetLabelPlacement | null
+  currentCandidateResults: EvaluatedCornerCandidate[]
+  solved: boolean
+}): GraphicsObject => {
+  const graphics = visualizeInputProblem(state.inputProblem)
+  ensureGraphicsArrays(graphics)
+
+  drawTraces(graphics, state.traces)
+  drawNetLabels(graphics, state.outputNetLabelPlacements)
+
+  if (!state.solved) {
+    drawCurrentLabel(graphics, state.currentLabel)
+    drawCurrentCandidates(graphics, state.currentCandidateResults)
+  }
+
+  return graphics
+}
+
+const drawTraces = (graphics: GraphicsObject, traces: SolvedTracePath[]) => {
+  for (const trace of traces) {
+    graphics.lines!.push({
+      points: trace.tracePath,
+      strokeColor: "purple",
+    } as any)
+  }
+}
+
+const drawNetLabels = (
+  graphics: GraphicsObject,
+  labels: NetLabelPlacement[],
+) => {
+  for (const label of labels) {
+    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),
+      label: `anchorPoint\norientation: ${label.orientation}`,
+    } as any)
+  }
+}
+
+const drawCurrentLabel = (
+  graphics: GraphicsObject,
+  currentLabel: NetLabelPlacement | null,
+) => {
+  if (!currentLabel) return
+
+  graphics.rects!.push({
+    center: currentLabel.center,
+    width: currentLabel.width,
+    height: currentLabel.height,
+    fill: "rgba(255, 0, 0, 0.2)",
+    strokeColor: CANDIDATE_REJECTED_COLOR,
+    label: `trace-line VCC target\n${currentLabel.netId ?? currentLabel.globalConnNetId}`,
+  } as any)
+}
+
+const drawCurrentCandidates = (
+  graphics: GraphicsObject,
+  candidates: EvaluatedCornerCandidate[],
+) => {
+  for (const candidate of candidates) {
+    const color = candidate.selected
+      ? CANDIDATE_SELECTED_COLOR
+      : CANDIDATE_REJECTED_COLOR
+    graphics.rects!.push({
+      center: candidate.center,
+      width: candidate.width,
+      height: candidate.height,
+      fill: candidate.selected
+        ? "rgba(0, 0, 255, 0.2)"
+        : "rgba(255, 0, 0, 0.15)",
+      strokeColor: color,
+      strokeDash: candidate.selected ? undefined : "4 2",
+      label: `${candidate.selected ? "selected" : candidate.status} trace corner\ntrace: ${candidate.traceId}\ndistance: ${candidate.distance.toFixed(3)}`,
+    } as any)
+    graphics.points!.push({
+      ...candidate.anchorPoint,
+      color,
+      label: `candidate anchor\n${candidate.status}`,
+    } as any)
+  }
+}
+
+const ensureGraphicsArrays = (graphics: GraphicsObject) => {
+  if (!graphics.lines) graphics.lines = []
+  if (!graphics.points) graphics.points = []
+  if (!graphics.rects) graphics.rects = []
+  if (!graphics.circles) graphics.circles = []
+  if (!graphics.texts) graphics.texts = []
+}

package/package.json

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

package/tests/examples/__snapshots__/example12.snap.svg

@@ -30,7 +30,7 @@ x+" data-x="3.41" data-y="0.01999999999999985" cx="576.1069836552749" cy="222.85
   </g>
   <g>
     <circle data-type="point" data-label="anchorPoint
-orientation: y+" data-x="1.4024999999999999" data-y="0.2" cx="337.4739970282318" cy="201.4588202080238" r="3" fill="hsl(40, 100%, 50%, 0.9)" />
+orientation: y+" data-x="1.7049999999999998" data-y="0.2" cx="373.4323922734027" cy="201.4588202080238" r="3" fill="hsl(40, 100%, 50%, 0.9)" />
   </g>
   <g>
     <circle data-type="point" data-label="anchorPoint
@@ -82,7 +82,7 @@ orientation: y-" data-x="3.511" data-y="-0.4310000000000001" cx="588.11292719167
   </g>
   <g>
     <rect data-type="rect" data-label="netId: VCC
-globalConnNetId: connectivity_net0" data-x="1.4024999999999999" data-y="0.42500000000000004" x="325.5869242199108" y="147.96699257057952" width="23.77414561664193" height="53.49182763744429" fill="hsl(40, 100%, 50%, 0.35)" stroke="black" stroke-width="0.008412500000000002" />
+globalConnNetId: connectivity_net0" data-x="1.7049999999999998" data-y="0.42500000000000004" x="361.54531946508166" y="147.96699257057952" width="23.77414561664193" height="53.49182763744429" fill="hsl(40, 100%, 50%, 0.35)" stroke="black" stroke-width="0.008412500000000002" />
   </g>
   <g>
     <rect data-type="rect" data-label="netId: OUT