@tscircuit/schematic-trace-solver 0.0.1

package/lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver/SchematicTraceSingleLineSolver.ts

@@ -0,0 +1,191 @@
+import { getBounds, type GraphicsObject } from "graphics-debug"
+import { ChipObstacleSpatialIndex } from "lib/data-structures/ChipObstacleSpatialIndex"
+import { BaseSolver } from "lib/solvers/BaseSolver/BaseSolver"
+import type { Guideline } from "lib/solvers/GuidelinesSolver/GuidelinesSolver"
+import type { MspConnectionPair } from "lib/solvers/MspConnectionPairSolver/MspConnectionPairSolver"
+import { visualizeInputProblem } from "lib/solvers/SchematicTracePipelineSolver/visualizeInputProblem"
+import type { InputChip, InputProblem } from "lib/types/InputProblem"
+import { calculateElbow } from "calculate-elbow"
+import { getPinDirection } from "./getPinDirection"
+import {
+  generateElbowVariants,
+  type MovableSegment,
+} from "./generateElbowVariants"
+import type { Point } from "@tscircuit/math-utils"
+import { visualizeGuidelines } from "lib/solvers/GuidelinesSolver/visualizeGuidelines"
+import { getColorFromString } from "lib/utils/getColorFromString"
+
+export class SchematicTraceSingleLineSolver extends BaseSolver {
+  pins: MspConnectionPair["pins"]
+  inputProblem: InputProblem
+  guidelines: Guideline[]
+  chipMap: Record<string, InputChip>
+  movableSegments: Array<MovableSegment>
+  baseElbow: Point[]
+
+  queuedCandidatePaths: Array<Point[]>
+
+  chipObstacleSpatialIndex: ChipObstacleSpatialIndex
+
+  solvedTracePath: { x: number; y: number }[] | null = null
+
+  constructor(params: {
+    pins: MspConnectionPair["pins"]
+    guidelines: Guideline[]
+    inputProblem: InputProblem
+    chipMap: Record<string, InputChip>
+  }) {
+    super()
+    this.pins = params.pins
+    this.inputProblem = params.inputProblem
+    this.guidelines = params.guidelines
+    this.chipMap = params.chipMap
+    this.chipObstacleSpatialIndex =
+      this.inputProblem._chipObstacleSpatialIndex ||
+      new ChipObstacleSpatialIndex(this.inputProblem.chips)
+
+    if (!this.inputProblem._chipObstacleSpatialIndex) {
+      this.inputProblem._chipObstacleSpatialIndex =
+        this.chipObstacleSpatialIndex
+    }
+
+    for (const pin of this.pins) {
+      if (!pin._facingDirection) {
+        const chip = this.chipMap[pin.chipId]
+        pin._facingDirection = getPinDirection(pin, chip)
+      }
+    }
+
+    const [pin1, pin2] = this.pins
+    this.baseElbow = calculateElbow(
+      {
+        x: pin1.x,
+        y: pin1.y,
+        facingDirection: pin1._facingDirection,
+      },
+      {
+        x: pin2.x,
+        y: pin2.y,
+        facingDirection: pin2._facingDirection,
+      },
+      {
+        overshoot: 0.2,
+      },
+    )
+
+    const { elbowVariants, movableSegments } = generateElbowVariants({
+      baseElbow: this.baseElbow,
+      guidelines: this.guidelines,
+    })
+
+    this.movableSegments = movableSegments
+
+    this.queuedCandidatePaths = [this.baseElbow, ...elbowVariants]
+  }
+
+  override getConstructorParams(): ConstructorParameters<
+    typeof SchematicTraceSingleLineSolver
+  >[0] {
+    return {
+      chipMap: this.chipMap,
+      pins: this.pins,
+      guidelines: this.guidelines,
+      inputProblem: this.inputProblem,
+    }
+  }
+
+  override _step() {
+    if (this.queuedCandidatePaths.length === 0) {
+      this.failed = true
+      this.error = "No more candidate elbows, everything had collisions"
+      return
+    }
+
+    const nextCandidatePath = this.queuedCandidatePaths.shift()!
+
+    const obstacleOps = {
+      excludeChipIds: [this.pins[0].chipId, this.pins[1].chipId],
+    }
+    for (let i = 0; i < nextCandidatePath.length - 1; i++) {
+      const start = nextCandidatePath[i]
+      const end = nextCandidatePath[i + 1]
+      const intersects =
+        this.chipObstacleSpatialIndex.doesOrthogonalLineIntersectChip(
+          [start, end],
+          obstacleOps,
+        )
+      if (intersects) return
+    }
+
+    this.solvedTracePath = nextCandidatePath
+    this.solved = true
+  }
+
+  override visualize(): GraphicsObject {
+    const graphics = visualizeInputProblem(this.inputProblem, {
+      chipAlpha: 0.1,
+      connectionAlpha: 0.1,
+    })
+
+    const bounds = getBounds(graphics)
+    const boundsWidth = bounds.maxX - bounds.minX
+    const boundsHeight = bounds.maxY - bounds.minY
+    visualizeGuidelines({ guidelines: this.guidelines, graphics })
+
+    // Visualize movable segments
+    for (const { start, end, dir } of this.movableSegments) {
+      const mid = { x: (start.x + end.x) / 2, y: (start.y + end.y) / 2 }
+      const dist = Math.sqrt((start.x - end.x) ** 2 + (start.y - end.y) ** 2)
+      graphics.lines!.push({
+        points: [start, mid, end],
+        strokeColor: "rgba(0,0,255,0.5)",
+        strokeDash: "2 2",
+      })
+      graphics.lines!.push({
+        points: [
+          mid,
+          { x: mid.x + dir.x * dist * 0.1, y: mid.y + dir.y * dist * 0.1 },
+        ],
+        strokeColor: "rgba(0,0,255,0.5)",
+        strokeDash: "2 2",
+      })
+    }
+
+    // Draw the next candidate path in orange
+    if (!this.solvedTracePath) {
+      if (this.queuedCandidatePaths.length > 0) {
+        graphics.lines!.push({
+          points: this.queuedCandidatePaths[0],
+          strokeColor: "orange",
+          strokeWidth: boundsWidth * 0.005,
+        })
+      }
+
+      // Visualize all the other queued candidates in faded yellow
+      for (let i = 1; i < this.queuedCandidatePaths.length; i++) {
+        const candidatePath = this.queuedCandidatePaths[i]
+        const pi = i / this.queuedCandidatePaths.length
+        graphics.lines!.push({
+          points: candidatePath.map((p) => ({
+            x: p.x + pi * boundsWidth * 0.005,
+            y: p.y + pi * boundsHeight * 0.005,
+          })),
+          strokeColor: getColorFromString(
+            `${candidatePath.reduce((acc, p) => `${acc},${p.x},${p.y}`, "")}`,
+            0.5,
+          ),
+          strokeDash: "8 8",
+        })
+      }
+    }
+
+    if (this.solvedTracePath) {
+      graphics.lines!.push({
+        points: this.solvedTracePath,
+        strokeColor: "green",
+      })
+    }
+
+    return graphics
+  }
+}

package/lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver/generateElbowVariants.ts

@@ -0,0 +1,132 @@
+import type { Point } from "@tscircuit/math-utils"
+import type { Guideline } from "lib/solvers/GuidelinesSolver/GuidelinesSolver"
+import { dir, type FacingDirection } from "lib/utils/dir"
+
+export interface MovableSegment {
+  start: Point
+  end: Point
+  freedom: "x+" | "x-" | "y+" | "y-"
+  dir: { x: number; y: number }
+}
+
+export const generateElbowVariants = ({
+  baseElbow,
+  guidelines,
+}: {
+  baseElbow: Point[]
+  guidelines: Guideline[]
+}): {
+  elbowVariants: Array<Point[]>
+  movableSegments: Array<MovableSegment>
+} => {
+  // First we find the movable segments, movable segments are the any segments
+  // of the baseElbow that are not the first or last segment
+  const movableSegments: Array<MovableSegment> = []
+  for (let i = 1; i < baseElbow.length - 2; i++) {
+    const prev = baseElbow[i - 1]
+    const start = baseElbow[i]
+    const end = baseElbow[i + 1]
+
+    const isHorz = Math.abs(start.y - end.y) < 1e-6
+
+    let freedom: FacingDirection
+    if (isHorz) {
+      freedom = prev.y <= start.y ? "y+" : "y-"
+    } else {
+      freedom = prev.x <= start.x ? "x+" : "x-"
+    }
+
+    movableSegments.push({ start, end, freedom, dir: dir(freedom) })
+  }
+
+  // Find relevant guidelines for each movable segment
+  const segmentGuidelineOptions: Array<Array<number>> = []
+
+  for (const segment of movableSegments) {
+    const relevantPositions: number[] = []
+
+    if (segment.freedom === "x+" || segment.freedom === "x-") {
+      // Segment can move horizontally, find vertical guidelines
+      for (const guideline of guidelines) {
+        if (guideline.orientation === "vertical" && guideline.x !== undefined) {
+          relevantPositions.push(guideline.x)
+        }
+      }
+      // Add current position as an option (no movement)
+      relevantPositions.push(segment.start.x)
+    } else {
+      // Segment can move vertically, find horizontal guidelines
+      for (const guideline of guidelines) {
+        if (
+          guideline.orientation === "horizontal" &&
+          guideline.y !== undefined
+        ) {
+          relevantPositions.push(guideline.y)
+        }
+      }
+      // Add current position as an option (no movement)
+      relevantPositions.push(segment.start.y)
+    }
+
+    segmentGuidelineOptions.push(
+      [...new Set(relevantPositions)].sort((a, b) => a - b),
+    )
+  }
+
+  // Generate all combinations of segment positions
+  const generateCombinations = (
+    options: Array<Array<number>>,
+  ): Array<Array<number>> => {
+    if (options.length === 0) return [[]]
+    if (options.length === 1) return options[0].map((pos) => [pos])
+
+    const combinations: Array<Array<number>> = []
+    const firstOptions = options[0]
+    const restCombinations = generateCombinations(options.slice(1))
+
+    for (const firstOption of firstOptions) {
+      for (const restCombination of restCombinations) {
+        combinations.push([firstOption, ...restCombination])
+      }
+    }
+
+    return combinations
+  }
+
+  const positionCombinations = generateCombinations(segmentGuidelineOptions)
+
+  // Create elbow variants by applying each combination
+  const elbowVariants: Array<Point[]> = []
+
+  for (const combination of positionCombinations) {
+    const variant = [...baseElbow]
+
+    // Apply each segment movement
+    for (
+      let segmentIndex = 0;
+      segmentIndex < movableSegments.length;
+      segmentIndex++
+    ) {
+      const segment = movableSegments[segmentIndex]
+      const newPosition = combination[segmentIndex]
+      const elbowIndex = segmentIndex + 1 // movable segments start at index 1
+
+      if (segment.freedom === "x+" || segment.freedom === "x-") {
+        // Move horizontally
+        variant[elbowIndex] = { ...variant[elbowIndex], x: newPosition }
+        variant[elbowIndex + 1] = { ...variant[elbowIndex + 1], x: newPosition }
+      } else {
+        // Move vertically
+        variant[elbowIndex] = { ...variant[elbowIndex], y: newPosition }
+        variant[elbowIndex + 1] = { ...variant[elbowIndex + 1], y: newPosition }
+      }
+    }
+
+    elbowVariants.push(variant)
+  }
+
+  return {
+    elbowVariants,
+    movableSegments,
+  }
+}

package/lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver/getPinDirection.ts

@@ -0,0 +1,42 @@
+import type { InputChip, InputPin } from "lib/types/InputProblem"
+
+export const getPinDirection = (
+  pin: InputPin,
+  chip: InputChip,
+): "x+" | "x-" | "y+" | "y-" => {
+  // Determine what edge the pin lies on
+  const { x, y } = pin
+  const { center, width, height } = chip
+
+  const yPlusEdge = center.y + height / 2
+  const yMinusEdge = center.y - height / 2
+  const xPlusEdge = center.x + width / 2
+  const xMinusEdge = center.x - width / 2
+
+  // Which edge is the pin closest to?
+  const yPlusDistance = Math.abs(y - yPlusEdge)
+  const yMinusDistance = Math.abs(y - yMinusEdge)
+  const xPlusDistance = Math.abs(x - xPlusEdge)
+  const xMinusDistance = Math.abs(x - xMinusEdge)
+
+  const minDistance = Math.min(
+    yPlusDistance,
+    yMinusDistance,
+    xPlusDistance,
+    xMinusDistance,
+  )
+
+  if (minDistance === yPlusDistance) {
+    return "y+"
+  }
+
+  if (minDistance === yMinusDistance) {
+    return "y-"
+  }
+
+  if (minDistance === xPlusDistance) {
+    return "x+"
+  }
+
+  return "x-"
+}

package/lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver.ts

@@ -0,0 +1,244 @@
+/**
+ * Pipeline solver that runs a series of solvers to find the best schematic layout.
+ * Coordinates the entire layout process from chip partitioning through final packing.
+ */
+
+import type { GraphicsObject } from "graphics-debug"
+import { BaseSolver } from "lib/solvers/BaseSolver/BaseSolver"
+import type { InputProblem } from "lib/types/InputProblem"
+import { MspConnectionPairSolver } from "../MspConnectionPairSolver/MspConnectionPairSolver"
+import { SchematicTraceLinesSolver } from "../SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import { TraceOverlapShiftSolver } from "../TraceOverlapShiftSolver/TraceOverlapShiftSolver"
+import { NetLabelPlacementSolver } from "../NetLabelPlacementSolver/NetLabelPlacementSolver"
+import { visualizeInputProblem } from "./visualizeInputProblem"
+import { GuidelinesSolver } from "../GuidelinesSolver/GuidelinesSolver"
+
+type PipelineStep<T extends new (...args: any[]) => BaseSolver> = {
+  solverName: string
+  solverClass: T
+  getConstructorParams: (
+    instance: SchematicTracePipelineSolver,
+  ) => ConstructorParameters<T>
+  onSolved?: (instance: SchematicTracePipelineSolver) => void
+}
+
+function definePipelineStep<
+  T extends new (
+    ...args: any[]
+  ) => BaseSolver,
+  const P extends ConstructorParameters<T>,
+>(
+  solverName: keyof SchematicTracePipelineSolver,
+  solverClass: T,
+  getConstructorParams: (instance: SchematicTracePipelineSolver) => P,
+  opts: {
+    onSolved?: (instance: SchematicTracePipelineSolver) => void
+  } = {},
+): PipelineStep<T> {
+  return {
+    solverName,
+    solverClass,
+    getConstructorParams,
+    onSolved: opts.onSolved,
+  }
+}
+
+export class SchematicTracePipelineSolver extends BaseSolver {
+  mspConnectionPairSolver?: MspConnectionPairSolver
+  guidelinesSolver?: GuidelinesSolver
+  schematicTraceLinesSolver?: SchematicTraceLinesSolver
+  traceOverlapShiftSolver?: TraceOverlapShiftSolver
+  netLabelPlacementSolver?: NetLabelPlacementSolver
+
+  startTimeOfPhase: Record<string, number>
+  endTimeOfPhase: Record<string, number>
+  timeSpentOnPhase: Record<string, number>
+  firstIterationOfPhase: Record<string, number>
+
+  inputProblem: InputProblem
+
+  pipelineDef = [
+    definePipelineStep(
+      "mspConnectionPairSolver",
+      MspConnectionPairSolver,
+      () => [{ inputProblem: this.inputProblem }],
+      {
+        onSolved: (mspSolver) => {},
+      },
+    ),
+    definePipelineStep(
+      "guidelinesSolver",
+      GuidelinesSolver,
+      () => [
+        {
+          inputProblem: this.inputProblem,
+        },
+      ],
+      {
+        onSolved: (guidelinesSolver) => {},
+      },
+    ),
+    definePipelineStep(
+      "schematicTraceLinesSolver",
+      SchematicTraceLinesSolver,
+      () => [
+        {
+          mspConnectionPairs: this.mspConnectionPairSolver!.mspConnectionPairs,
+          dcConnMap: this.mspConnectionPairSolver!.dcConnMap,
+          globalConnMap: this.mspConnectionPairSolver!.globalConnMap,
+          inputProblem: this.inputProblem,
+          guidelines: this.guidelinesSolver!.guidelines,
+          chipMap: this.mspConnectionPairSolver!.chipMap,
+        },
+      ],
+      {
+        onSolved: (schematicTraceLinesSolver) => {},
+      },
+    ),
+    definePipelineStep(
+      "traceOverlapShiftSolver",
+      TraceOverlapShiftSolver,
+      () => [
+        {
+          inputProblem: this.inputProblem,
+          inputTracePaths: this.schematicTraceLinesSolver!.solvedTracePaths,
+          globalConnMap: this.mspConnectionPairSolver!.globalConnMap,
+        },
+      ],
+      {
+        onSolved: (_solver) => {},
+      },
+    ),
+    definePipelineStep(
+      "netLabelPlacementSolver",
+      NetLabelPlacementSolver,
+      () => [
+        {
+          inputProblem: this.inputProblem,
+          inputTraceMap:
+            this.traceOverlapShiftSolver?.correctedTraceMap ??
+            Object.fromEntries(
+              this.schematicTraceLinesSolver!.solvedTracePaths.map((p) => [
+                p.mspPairId,
+                p,
+              ]),
+            ),
+        },
+      ],
+      {
+        onSolved: (_solver) => {
+          // TODO
+        },
+      },
+    ),
+  ]
+
+  constructor(inputProblem: InputProblem) {
+    super()
+    this.inputProblem = inputProblem
+    this.MAX_ITERATIONS = 1e6
+    this.startTimeOfPhase = {}
+    this.endTimeOfPhase = {}
+    this.timeSpentOnPhase = {}
+    this.firstIterationOfPhase = {}
+  }
+
+  currentPipelineStepIndex = 0
+
+  override _step() {
+    const pipelineStepDef = this.pipelineDef[this.currentPipelineStepIndex]
+    if (!pipelineStepDef) {
+      this.solved = true
+      return
+    }
+
+    if (this.activeSubSolver) {
+      this.activeSubSolver.step()
+      if (this.activeSubSolver.solved) {
+        this.endTimeOfPhase[pipelineStepDef.solverName] = performance.now()
+        this.timeSpentOnPhase[pipelineStepDef.solverName] =
+          this.endTimeOfPhase[pipelineStepDef.solverName]! -
+          this.startTimeOfPhase[pipelineStepDef.solverName]!
+        pipelineStepDef.onSolved?.(this)
+        this.activeSubSolver = null
+        this.currentPipelineStepIndex++
+      } else if (this.activeSubSolver.failed) {
+        this.error = this.activeSubSolver?.error
+        this.failed = true
+        this.activeSubSolver = null
+      }
+      return
+    }
+
+    const constructorParams = pipelineStepDef.getConstructorParams(this)
+    // @ts-ignore
+    this.activeSubSolver = new pipelineStepDef.solverClass(...constructorParams)
+    ;(this as any)[pipelineStepDef.solverName] = this.activeSubSolver
+    this.timeSpentOnPhase[pipelineStepDef.solverName] = 0
+    this.startTimeOfPhase[pipelineStepDef.solverName] = performance.now()
+    this.firstIterationOfPhase[pipelineStepDef.solverName] = this.iterations
+  }
+
+  solveUntilPhase(phase: string) {
+    while (this.getCurrentPhase().toLowerCase() !== phase.toLowerCase()) {
+      this.step()
+    }
+  }
+
+  getCurrentPhase(): string {
+    return this.pipelineDef[this.currentPipelineStepIndex]?.solverName ?? "none"
+  }
+
+  override visualize(): GraphicsObject {
+    if (!this.solved && this.activeSubSolver)
+      return this.activeSubSolver.visualize()
+
+    const visualizations = [
+      visualizeInputProblem(this.inputProblem),
+      ...(this.pipelineDef
+        .map((p) => (this as any)[p.solverName]?.visualize())
+        .filter(Boolean)
+        .map((viz, stepIndex) => {
+          for (const rect of viz!.rects ?? []) {
+            rect.step = stepIndex
+          }
+          for (const point of viz!.points ?? []) {
+            point.step = stepIndex
+          }
+          for (const circle of viz!.circles ?? []) {
+            circle.step = stepIndex
+          }
+          for (const text of viz!.texts ?? []) {
+            text.step = stepIndex
+          }
+          for (const line of viz!.lines ?? []) {
+            line.step = stepIndex
+          }
+          return viz
+        }) as GraphicsObject[]),
+    ]
+
+    if (visualizations.length === 1) return visualizations[0]!
+
+    // Simple combination of visualizations
+    return {
+      points: visualizations.flatMap((v) => v.points || []),
+      rects: visualizations.flatMap((v) => v.rects || []),
+      lines: visualizations.flatMap((v) => v.lines || []),
+      circles: visualizations.flatMap((v) => v.circles || []),
+      texts: visualizations.flatMap((v) => v.texts || []),
+    }
+  }
+
+  /**
+   * A lightweight version of the visualize method that can be used to stream
+   * progress
+   */
+  override preview(): GraphicsObject {
+    if (this.activeSubSolver) {
+      return this.activeSubSolver.preview()
+    }
+
+    return super.preview()
+  }
+}

package/lib/solvers/SchematicTracePipelineSolver/visualizeInputProblem.ts

@@ -0,0 +1,89 @@
+import type { GraphicsObject } from "graphics-debug"
+import type { PinId, InputPin, InputProblem } from "lib/types/InputProblem"
+import { getColorFromString } from "lib/utils/getColorFromString"
+
+export const visualizeInputProblem = (
+  inputProblem: InputProblem,
+  opts: {
+    chipAlpha?: number
+    connectionAlpha?: number
+  } = {},
+): GraphicsObject => {
+  const { connectionAlpha = 0.8, chipAlpha = 0.8 } = opts
+  const graphics: Pick<
+    Required<GraphicsObject>,
+    "lines" | "points" | "rects"
+  > = {
+    lines: [],
+    points: [],
+    rects: [],
+  }
+
+  const pinIdMap = new Map<PinId, InputPin>()
+  for (const chip of inputProblem.chips) {
+    for (const pin of chip.pins) {
+      pinIdMap.set(pin.pinId, pin)
+    }
+  }
+
+  for (const chip of inputProblem.chips) {
+    graphics.rects.push({
+      label: chip.chipId,
+      center: chip.center,
+      width: chip.width,
+      height: chip.height,
+      fill: getColorFromString(chip.chipId, chipAlpha),
+    })
+
+    for (const pin of chip.pins) {
+      graphics.points.push({
+        label: pin.pinId,
+        x: pin.x,
+        y: pin.y,
+        color: getColorFromString(pin.pinId, 0.8),
+      })
+    }
+  }
+
+  for (const directConn of inputProblem.directConnections) {
+    const [pinId1, pinId2] = directConn.pinIds
+    const pin1 = pinIdMap.get(pinId1)!
+    const pin2 = pinIdMap.get(pinId2)!
+    graphics.lines.push({
+      points: [
+        {
+          x: pin1.x,
+          y: pin1.y,
+        },
+        {
+          x: pin2.x,
+          y: pin2.y,
+        },
+      ],
+      strokeColor: getColorFromString(
+        directConn.netId ?? `${pinId1}-${pinId2}`,
+        connectionAlpha,
+      ),
+    })
+  }
+
+  for (const netConn of inputProblem.netConnections) {
+    const pins = netConn.pinIds.map((pinId) => pinIdMap.get(pinId)!)
+    for (let i = 0; i < pins.length - 1; i++) {
+      for (let j = i + 1; j < pins.length; j++) {
+        const pin1 = pins[i]!
+        const pin2 = pins[j]!
+        graphics.lines.push({
+          points: [
+            { x: pin1.x, y: pin1.y },
+            { x: pin2.x, y: pin2.y },
+          ],
+          strokeColor: getColorFromString(netConn.netId, connectionAlpha),
+          strokeDash: "4 2",
+        })
+      }
+    }
+  }
+
+  return graphics
+}