@tscircuit/schematic-trace-solver 0.0.49 → 0.0.51

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/SchematicTracePipelineSolver/SchematicTracePipelineSolver.ts

@@ -21,6 +21,8 @@ import { LongDistancePairSolver } from "../LongDistancePairSolver/LongDistancePa
 import { MergedNetLabelObstacleSolver } from "../TraceLabelOverlapAvoidanceSolver/sub-solvers/LabelMergingSolver/LabelMergingSolver"
 import { TraceCleanupSolver } from "../TraceCleanupSolver/TraceCleanupSolver"
 import { Example28Solver } from "../Example28Solver/Example28Solver"
+import { AvailableNetOrientationSolver } from "../AvailableNetOrientationSolver/AvailableNetOrientationSolver"
+import { VccNetLabelCornerPlacementSolver } from "../VccNetLabelCornerPlacementSolver/VccNetLabelCornerPlacementSolver"
 
 type PipelineStep<T extends new (...args: any[]) => BaseSolver> = {
   solverName: string
@@ -71,6 +73,8 @@ export class SchematicTracePipelineSolver extends BaseSolver {
   traceLabelOverlapAvoidanceSolver?: TraceLabelOverlapAvoidanceSolver
   traceCleanupSolver?: TraceCleanupSolver
   example28Solver?: Example28Solver
+  availableNetOrientationSolver?: AvailableNetOrientationSolver
+  vccNetLabelCornerPlacementSolver?: VccNetLabelCornerPlacementSolver
 
   startTimeOfPhase: Record<string, number>
   endTimeOfPhase: Record<string, number>
@@ -240,6 +244,32 @@ export class SchematicTracePipelineSolver extends BaseSolver {
         },
       ]
     }),
+    definePipelineStep(
+      "availableNetOrientationSolver",
+      AvailableNetOrientationSolver,
+      (instance) => [
+        {
+          inputProblem: instance.inputProblem,
+          traces: instance.example28Solver!.outputTraces,
+          netLabelPlacements:
+            instance.example28Solver!.outputNetLabelPlacements,
+        },
+      ],
+    ),
+    definePipelineStep(
+      "vccNetLabelCornerPlacementSolver",
+      VccNetLabelCornerPlacementSolver,
+      (instance) => {
+        return [
+          {
+            inputProblem: instance.inputProblem,
+            traces: instance.availableNetOrientationSolver!.traces,
+            netLabelPlacements:
+              instance.availableNetOrientationSolver!.outputNetLabelPlacements,
+          },
+        ]
+      },
+    ),
   ]
 
   constructor(inputProblem: InputProblem) {