@tscircuit/schematic-trace-solver 0.0.48 → 0.0.50

package/lib/solvers/AvailableNetOrientationSolver/geometry.ts

@@ -0,0 +1,192 @@
+import type { Point } from "@tscircuit/math-utils"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import type { InputProblem } from "lib/types/InputProblem"
+import type { FacingDirection } from "lib/utils/dir"
+import { EPS, TRACE_BOUNDARY_TOLERANCE } from "./constants"
+import type { Bounds, ChipSide } from "./types"
+
+export const isYOrientation = (
+  orientation: FacingDirection,
+): orientation is "y+" | "y-" => orientation === "y+" || orientation === "y-"
+
+export const isXOrientation = (
+  orientation: FacingDirection,
+): orientation is "x+" | "x-" => orientation === "x+" || orientation === "x-"
+
+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 rangesOverlap = (
+  minA: number,
+  maxA: number,
+  minB: number,
+  maxB: number,
+) => Math.min(maxA, maxB) - Math.max(minA, minB) > EPS
+
+export const traceCrossesBoundsInterior = (
+  bounds: Bounds,
+  traceMap: Record<string, SolvedTracePath>,
+) => {
+  for (const trace of Object.values(traceMap)) {
+    const points = trace.tracePath
+    for (let i = 0; i < points.length - 1; i++) {
+      if (segmentCrossesBoundsInterior(points[i]!, points[i + 1]!, bounds)) {
+        return true
+      }
+    }
+  }
+
+  return false
+}
+
+const segmentCrossesBoundsInterior = (p1: Point, p2: Point, bounds: Bounds) => {
+  const interiorBounds = {
+    minX: bounds.minX + TRACE_BOUNDARY_TOLERANCE,
+    minY: bounds.minY + TRACE_BOUNDARY_TOLERANCE,
+    maxX: bounds.maxX - TRACE_BOUNDARY_TOLERANCE,
+    maxY: bounds.maxY - TRACE_BOUNDARY_TOLERANCE,
+  }
+
+  if (
+    interiorBounds.minX >= interiorBounds.maxX ||
+    interiorBounds.minY >= interiorBounds.maxY
+  ) {
+    return false
+  }
+
+  if (sameX(p1, p2)) {
+    if (
+      p1.x <= interiorBounds.minX + EPS ||
+      p1.x >= interiorBounds.maxX - EPS
+    ) {
+      return false
+    }
+    return rangesOverlap(
+      Math.min(p1.y, p2.y),
+      Math.max(p1.y, p2.y),
+      interiorBounds.minY,
+      interiorBounds.maxY,
+    )
+  }
+
+  if (sameY(p1, p2)) {
+    if (
+      p1.y <= interiorBounds.minY + EPS ||
+      p1.y >= interiorBounds.maxY - EPS
+    ) {
+      return false
+    }
+    return rangesOverlap(
+      Math.min(p1.x, p2.x),
+      Math.max(p1.x, p2.x),
+      interiorBounds.minX,
+      interiorBounds.maxX,
+    )
+  }
+
+  return false
+}
+
+export const tracePathCrossesAnyTrace = (
+  tracePath: Point[],
+  traceMap: Record<string, SolvedTracePath>,
+) => {
+  for (const trace of Object.values(traceMap)) {
+    const points = trace.tracePath
+    for (let i = 0; i < tracePath.length - 1; i++) {
+      for (let j = 0; j < points.length - 1; j++) {
+        if (
+          segmentsStrictlyCross(
+            tracePath[i]!,
+            tracePath[i + 1]!,
+            points[j]!,
+            points[j + 1]!,
+          )
+        ) {
+          return true
+        }
+      }
+    }
+  }
+
+  return false
+}
+
+const segmentsStrictlyCross = (a1: Point, a2: Point, b1: Point, b2: Point) => {
+  if (sameX(a1, a2) && sameY(b1, b2)) {
+    return (
+      a1.x > Math.min(b1.x, b2.x) + EPS &&
+      a1.x < Math.max(b1.x, b2.x) - EPS &&
+      b1.y > Math.min(a1.y, a2.y) + EPS &&
+      b1.y < Math.max(a1.y, a2.y) - EPS
+    )
+  }
+
+  if (sameY(a1, a2) && sameX(b1, b2)) {
+    return (
+      b1.x > Math.min(a1.x, a2.x) + EPS &&
+      b1.x < Math.max(a1.x, a2.x) - EPS &&
+      a1.y > Math.min(b1.y, b2.y) + EPS &&
+      a1.y < Math.max(b1.y, b2.y) - EPS
+    )
+  }
+
+  return false
+}
+
+export const getSideDistances = (point: Point, bounds: Bounds) =>
+  [
+    ["left", Math.abs(point.x - bounds.minX)] as const,
+    ["right", Math.abs(point.x - bounds.maxX)] as const,
+    ["bottom", Math.abs(point.y - bounds.minY)] as const,
+    ["top", Math.abs(point.y - bounds.maxY)] as const,
+  ] satisfies Array<readonly [ChipSide, number]>
+
+export const getConnectorTracePath = (
+  source: Point,
+  target: Point,
+  orientation: FacingDirection,
+) =>
+  simplifyOrthogonalPath(
+    isYOrientation(orientation)
+      ? [source, { x: target.x, y: source.y }, target]
+      : [source, { x: source.x, y: target.y }, target],
+  )
+
+const simplifyOrthogonalPath = (path: Point[]) => {
+  const deduped = path.filter(
+    (point, index) => index === 0 || !pointsEqual(point, path[index - 1]!),
+  )
+  if (deduped.length < 3) return deduped
+
+  const simplified: Point[] = [deduped[0]!]
+  for (let i = 1; i < deduped.length - 1; i++) {
+    const prev = simplified[simplified.length - 1]!
+    const point = deduped[i]!
+    const next = deduped[i + 1]!
+    if (
+      (sameX(prev, point) && sameX(point, next)) ||
+      (sameY(prev, point) && sameY(point, next))
+    ) {
+      continue
+    }
+    simplified.push(point)
+  }
+  simplified.push(deduped[deduped.length - 1]!)
+  return simplified
+}
+
+const pointsEqual = (a: Point, b: Point) => sameX(a, b) && sameY(a, b)
+
+const sameX = (a: Point, b: Point) => Math.abs(a.x - b.x) <= EPS
+
+const sameY = (a: Point, b: Point) => Math.abs(a.y - b.y) <= EPS
+
+export const getMaxSearchDistance = (inputProblem: InputProblem) => {
+  const maxChipWidth = Math.max(
+    ...inputProblem.chips.map((chip) => chip.width),
+    1,
+  )
+  return maxChipWidth * 3
+}

package/lib/solvers/AvailableNetOrientationSolver/traces.ts

@@ -0,0 +1,43 @@
+import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import type { InputPin, InputProblem } from "lib/types/InputProblem"
+import type { CandidateLabel } from "./types"
+
+export const getPinMap = (inputProblem: InputProblem) => {
+  const pinMap: Record<string, InputPin & { chipId: string }> = {}
+  for (const chip of inputProblem.chips) {
+    for (const pin of chip.pins) {
+      pinMap[pin.pinId] = { ...pin, chipId: chip.chipId }
+    }
+  }
+  return pinMap
+}
+
+export const getTracePins = (
+  label: NetLabelPlacement,
+  pinMap: Record<string, InputPin & { chipId: string }>,
+): SolvedTracePath["pins"] => {
+  const pins = label.pinIds.flatMap((pinId) => {
+    const pin = pinMap[pinId]
+    return pin ? [pin] : []
+  })
+
+  if (pins.length >= 2) return [pins[0]!, pins[1]!]
+  if (pins.length === 1) return [pins[0]!, pins[0]!]
+
+  const syntheticPin = {
+    pinId: `${label.globalConnNetId}-netlabel-anchor`,
+    x: label.anchorPoint.x,
+    y: label.anchorPoint.y,
+    chipId: "available-net-orientation",
+  }
+  return [syntheticPin, syntheticPin]
+}
+
+export const toNetLabelPlacementPatch = (candidate: CandidateLabel) => ({
+  orientation: candidate.orientation,
+  anchorPoint: candidate.anchorPoint,
+  center: candidate.center,
+  width: candidate.width,
+  height: candidate.height,
+})

package/lib/solvers/AvailableNetOrientationSolver/types.ts

@@ -0,0 +1,44 @@
+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"
+import type { FacingDirection } from "lib/utils/dir"
+
+export interface AvailableNetOrientationSolverParams {
+  inputProblem: InputProblem
+  traces: SolvedTracePath[]
+  netLabelPlacements: NetLabelPlacement[]
+}
+
+export type Bounds = {
+  minX: number
+  minY: number
+  maxX: number
+  maxY: number
+}
+
+export type ChipSide = "left" | "right" | "top" | "bottom"
+
+export type CandidateLabel = {
+  orientation: FacingDirection
+  anchorPoint: Point
+  center: Point
+  width: number
+  height: number
+}
+
+export type CandidateStatus =
+  | "valid"
+  | "chip-collision"
+  | "trace-collision"
+  | "netlabel-collision"
+
+export type CandidatePhase = "rotate" | "shift"
+
+export type EvaluatedCandidate = CandidateLabel & {
+  status: CandidateStatus
+  selected: boolean
+  phase: CandidatePhase
+  distance?: number
+  outwardDistance?: number
+}

package/lib/solvers/AvailableNetOrientationSolver/visualize.ts

@@ -0,0 +1,123 @@
+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 { CANDIDATE_REJECTED_COLOR, CANDIDATE_SELECTED_COLOR } from "./constants"
+import type { EvaluatedCandidate } from "./types"
+
+export const visualizeAvailableNetOrientationSolver = (params: {
+  inputProblem: InputProblem
+  traces: SolvedTracePath[]
+  outputNetLabelPlacements: NetLabelPlacement[]
+  currentLabel: NetLabelPlacement | null
+  currentCandidateResults: EvaluatedCandidate[]
+  solved: boolean
+}): GraphicsObject => {
+  const graphics = visualizeInputProblem(params.inputProblem)
+  ensureGraphicsArrays(graphics)
+
+  drawTraces(graphics, params.traces)
+  drawNetLabels(graphics, params.outputNetLabelPlacements)
+  drawCurrentLabel(graphics, params.currentLabel, params.solved)
+  drawCurrentCandidates(graphics, params.currentCandidateResults, params.solved)
+
+  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,
+  solved: boolean,
+) => {
+  if (!currentLabel || solved) 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: `available orientation target\n${currentLabel.netId ?? currentLabel.globalConnNetId}`,
+  } as any)
+}
+
+const drawCurrentCandidates = (
+  graphics: GraphicsObject,
+  candidates: EvaluatedCandidate[],
+  solved: boolean,
+) => {
+  if (solved) return
+
+  for (const candidate of candidates) {
+    const color = candidate.selected
+      ? CANDIDATE_SELECTED_COLOR
+      : CANDIDATE_REJECTED_COLOR
+    const distanceLabel =
+      candidate.distance === undefined
+        ? ""
+        : `\ndistance: ${candidate.distance.toFixed(3)}`
+    const outwardDistanceLabel =
+      candidate.outwardDistance === undefined || candidate.outwardDistance === 0
+        ? ""
+        : `\noutward distance: ${candidate.outwardDistance.toFixed(3)}`
+
+    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} available orientation\nphase: ${candidate.phase}\norientation: ${candidate.orientation}${distanceLabel}${outwardDistanceLabel}`,
+    } as any)
+    graphics.points!.push({
+      x: candidate.anchorPoint.x,
+      y: candidate.anchorPoint.y,
+      color,
+      label: `candidate anchor\n${candidate.phase}\n${candidate.orientation}`,
+    } 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/Example28Solver/Example28Solver.ts

@@ -0,0 +1,182 @@
+import type { GraphicsObject } from "graphics-debug"
+import { BaseSolver } from "lib/solvers/BaseSolver/BaseSolver"
+import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
+import { getObstacleRects } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/rect"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import {
+  detectTraceLabelOverlap,
+  type TraceLabelOverlap,
+} from "lib/solvers/TraceLabelOverlapAvoidanceSolver/detectTraceLabelOverlap"
+import type { InputProblem } from "lib/types/InputProblem"
+import { moveAttachedLabelsToReroutedTrace } from "./labelMovement"
+import { findBestReroutePath } from "./reroute"
+import type { Example28SolverParams, RerouteCandidateResult } from "./types"
+import { visualizeExample28Solver } from "./visualize"
+
+export class Example28Solver extends BaseSolver {
+  inputProblem: InputProblem
+  traces: SolvedTracePath[]
+  netLabelPlacements: NetLabelPlacement[]
+
+  outputTraces: SolvedTracePath[]
+  outputNetLabelPlacements: NetLabelPlacement[]
+  queuedOverlaps: TraceLabelOverlap[] = []
+  currentOverlap: TraceLabelOverlap | null = null
+  currentCandidateResults: RerouteCandidateResult[] = []
+
+  private chipObstacles: ReturnType<typeof getObstacleRects>
+
+  constructor(params: Example28SolverParams) {
+    super()
+    this.inputProblem = params.inputProblem
+    this.traces = params.traces
+    this.netLabelPlacements = params.netLabelPlacements
+    this.outputTraces = [...params.traces]
+    this.outputNetLabelPlacements = [...params.netLabelPlacements]
+    this.chipObstacles = getObstacleRects(params.inputProblem)
+    this.initializeQueuedOverlaps()
+    this.currentOverlap = this.queuedOverlaps[0] ?? null
+  }
+
+  override getConstructorParams(): ConstructorParameters<
+    typeof Example28Solver
+  >[0] {
+    return {
+      inputProblem: this.inputProblem,
+      traces: this.traces,
+      netLabelPlacements: this.netLabelPlacements,
+    }
+  }
+
+  override _step() {
+    const overlap = this.queuedOverlaps.shift()
+    if (!overlap) {
+      this.finish()
+      return
+    }
+
+    if (!this.isOverlapStillPresent(overlap)) {
+      this.currentOverlap = overlap
+      this.currentCandidateResults = []
+      return
+    }
+
+    this.rerouteOverlappingTrace(overlap)
+  }
+
+  private finish() {
+    this.currentOverlap = null
+    this.currentCandidateResults = []
+    this.solved = true
+  }
+
+  private initializeQueuedOverlaps() {
+    const queuedOverlaps: TraceLabelOverlap[] = []
+    const seenPairs = new Set<string>()
+
+    for (const overlap of this.getTraceLabelOverlaps()) {
+      if (!this.shouldRerouteOverlap(overlap)) continue
+
+      const key = this.getOverlapKey(overlap)
+      if (seenPairs.has(key)) continue
+
+      seenPairs.add(key)
+      queuedOverlaps.push(overlap)
+    }
+
+    this.queuedOverlaps = queuedOverlaps
+  }
+
+  private getTraceLabelOverlaps() {
+    return detectTraceLabelOverlap({
+      traces: this.outputTraces,
+      netLabels: this.outputNetLabelPlacements,
+    })
+  }
+
+  private shouldRerouteOverlap(overlap: TraceLabelOverlap) {
+    return (
+      this.isXFacingLabel(overlap.label) &&
+      !this.hasExplicitOrientationConstraint(overlap.label)
+    )
+  }
+
+  private isXFacingLabel(label: NetLabelPlacement) {
+    return label.orientation === "x+" || label.orientation === "x-"
+  }
+
+  private hasExplicitOrientationConstraint(label: NetLabelPlacement) {
+    const effectiveNetId = label.netId ?? label.globalConnNetId
+    return Object.hasOwn(
+      this.inputProblem.availableNetLabelOrientations,
+      effectiveNetId,
+    )
+  }
+
+  private getOverlapKey(overlap: TraceLabelOverlap) {
+    const labelNetId = overlap.label.netId ?? overlap.label.globalConnNetId
+    return `${overlap.trace.mspPairId}:${labelNetId}:${overlap.label.anchorPoint.x}:${overlap.label.anchorPoint.y}`
+  }
+
+  private isOverlapStillPresent(overlap: TraceLabelOverlap) {
+    const currentTrace = this.getCurrentTrace(overlap.trace)
+    if (!currentTrace) return false
+
+    return (
+      detectTraceLabelOverlap({
+        traces: [currentTrace],
+        netLabels: [overlap.label],
+      }).length > 0
+    )
+  }
+
+  private getCurrentTrace(trace: SolvedTracePath) {
+    return this.outputTraces.find((t) => t.mspPairId === trace.mspPairId)
+  }
+
+  private rerouteOverlappingTrace(overlap: TraceLabelOverlap) {
+    this.currentOverlap = overlap
+    this.currentCandidateResults = []
+
+    const traceIndex = this.outputTraces.findIndex(
+      (trace) => trace.mspPairId === overlap.trace.mspPairId,
+    )
+    if (traceIndex === -1) return
+
+    const currentTrace = this.outputTraces[traceIndex]!
+    const rerouteResult = findBestReroutePath({
+      trace: currentTrace,
+      obstacleLabel: overlap.label,
+      inputProblem: this.inputProblem,
+      outputTraces: this.outputTraces,
+      outputNetLabelPlacements: this.outputNetLabelPlacements,
+      chipObstacles: this.chipObstacles,
+    })
+    this.currentCandidateResults = rerouteResult.candidateResults
+
+    if (!rerouteResult.bestPath) return
+
+    const originalTracePath = currentTrace.tracePath
+    this.outputTraces[traceIndex] = {
+      ...currentTrace,
+      tracePath: rerouteResult.bestPath,
+    }
+    this.outputNetLabelPlacements = moveAttachedLabelsToReroutedTrace({
+      trace: currentTrace,
+      originalTracePath,
+      reroutedTracePath: rerouteResult.bestPath,
+      netLabelPlacements: this.outputNetLabelPlacements,
+    })
+  }
+
+  override visualize(): GraphicsObject {
+    return visualizeExample28Solver({
+      inputProblem: this.inputProblem,
+      outputTraces: this.outputTraces,
+      outputNetLabelPlacements: this.outputNetLabelPlacements,
+      solved: this.solved,
+      currentOverlap: this.currentOverlap,
+      currentCandidateResults: this.currentCandidateResults,
+    })
+  }
+}