@tscircuit/schematic-trace-solver 0.0.48 → 0.0.49

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,
+    })
+  }
+}

package/lib/solvers/Example28Solver/geometry.ts

@@ -0,0 +1,246 @@
+import type { Point } from "@tscircuit/math-utils"
+import { segmentIntersectsRect } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions"
+import type { ChipObstacle, PathSegment, SegmentOrientation } from "./types"
+import { EPS } from "./types"
+
+export const getPathKey = (path: Point[]) =>
+  path.map((point) => `${point.x},${point.y}`).join(";")
+
+export const getPathLength = (path: Point[]) => {
+  let length = 0
+  for (let i = 0; i < path.length - 1; i++) {
+    length +=
+      Math.abs(path[i + 1]!.x - path[i]!.x) +
+      Math.abs(path[i + 1]!.y - path[i]!.y)
+  }
+  return length
+}
+
+export const getDistance = (a: Point, b: Point) =>
+  Math.abs(a.x - b.x) + Math.abs(a.y - b.y)
+
+export const isAxisAlignedSegment = (start: Point, end: Point) =>
+  Math.abs(start.x - end.x) < EPS || Math.abs(start.y - end.y) < EPS
+
+export const getSegmentOrientation = (
+  start: Point,
+  end: Point,
+): SegmentOrientation =>
+  Math.abs(start.y - end.y) < EPS ? "horizontal" : "vertical"
+
+export const projectPointToSegment = (
+  point: Point,
+  start: Point,
+  end: Point,
+): Point => {
+  if (Math.abs(start.x - end.x) < EPS) {
+    return {
+      x: start.x,
+      y: Math.min(
+        Math.max(point.y, Math.min(start.y, end.y)),
+        Math.max(start.y, end.y),
+      ),
+    }
+  }
+
+  if (Math.abs(start.y - end.y) < EPS) {
+    return {
+      x: Math.min(
+        Math.max(point.x, Math.min(start.x, end.x)),
+        Math.max(start.x, end.x),
+      ),
+      y: start.y,
+    }
+  }
+
+  return start
+}
+
+export const getPointToSegmentDistance = (
+  point: Point,
+  start: Point,
+  end: Point,
+) => getDistance(point, projectPointToSegment(point, start, end))
+
+export const getSegments = (path: Point[]) => {
+  const segments: PathSegment[] = []
+
+  for (let i = 0; i < path.length - 1; i++) {
+    const start = path[i]!
+    const end = path[i + 1]!
+    if (!isAxisAlignedSegment(start, end)) continue
+    segments.push({
+      start,
+      end,
+      orientation: getSegmentOrientation(start, end),
+    })
+  }
+
+  return segments
+}
+
+export const findSegmentContainingPoint = (path: Point[], point: Point) => {
+  for (let i = 0; i < path.length - 1; i++) {
+    const start = path[i]!
+    const end = path[i + 1]!
+    if (!isAxisAlignedSegment(start, end)) continue
+    if (getPointToSegmentDistance(point, start, end) > 1e-6) continue
+
+    return {
+      index: i,
+      start,
+      end,
+      orientation: getSegmentOrientation(start, end),
+    }
+  }
+
+  return null
+}
+
+export const isPointWithinSegmentPrimaryRange = (
+  point: Point,
+  segment: PathSegment,
+) => {
+  if (segment.orientation === "horizontal") {
+    return (
+      point.x >= Math.min(segment.start.x, segment.end.x) - EPS &&
+      point.x <= Math.max(segment.start.x, segment.end.x) + EPS
+    )
+  }
+
+  return (
+    point.y >= Math.min(segment.start.y, segment.end.y) - EPS &&
+    point.y <= Math.max(segment.start.y, segment.end.y) + EPS
+  )
+}
+
+export const findPreferredReroutedSegment = (
+  path: Point[],
+  originalSegmentIndex: number,
+  originalSegmentCount: number,
+  orientation: SegmentOrientation,
+  anchorPoint: Point,
+) => {
+  const matchingSegments = getSegments(path).filter(
+    (segment) => segment.orientation === orientation,
+  )
+  if (matchingSegments.length === 0) return null
+
+  const containingSegments = matchingSegments.filter((segment) =>
+    isPointWithinSegmentPrimaryRange(anchorPoint, segment),
+  )
+  const candidateSegments =
+    containingSegments.length > 0 ? containingSegments : matchingSegments
+
+  const isNearStart = originalSegmentIndex < originalSegmentCount / 2
+  return isNearStart
+    ? candidateSegments[0]!
+    : candidateSegments[candidateSegments.length - 1]!
+}
+
+export const projectPointToPath = (point: Point, path: Point[]) => {
+  let bestPoint: Point | null = null
+  let bestDistance = Number.POSITIVE_INFINITY
+
+  for (let i = 0; i < path.length - 1; i++) {
+    const projectedPoint = projectPointToSegment(point, path[i]!, path[i + 1]!)
+    const distance = getDistance(point, projectedPoint)
+    if (distance < bestDistance) {
+      bestPoint = projectedPoint
+      bestDistance = distance
+    }
+  }
+
+  return bestPoint
+}
+
+export const segmentsIntersect = (
+  a1: Point,
+  a2: Point,
+  b1: Point,
+  b2: Point,
+) => {
+  const aVertical = Math.abs(a1.x - a2.x) < EPS
+  const bVertical = Math.abs(b1.x - b2.x) < EPS
+  const between = (value: number, p1: number, p2: number) =>
+    value >= Math.min(p1, p2) - EPS && value <= Math.max(p1, p2) + EPS
+
+  if (aVertical && bVertical) {
+    if (Math.abs(a1.x - b1.x) > EPS) return false
+    const overlap =
+      Math.min(Math.max(a1.y, a2.y), Math.max(b1.y, b2.y)) -
+      Math.max(Math.min(a1.y, a2.y), Math.min(b1.y, b2.y))
+    return overlap > EPS
+  }
+
+  if (!aVertical && !bVertical) {
+    if (Math.abs(a1.y - b1.y) > EPS) return false
+    const overlap =
+      Math.min(Math.max(a1.x, a2.x), Math.max(b1.x, b2.x)) -
+      Math.max(Math.min(a1.x, a2.x), Math.min(b1.x, b2.x))
+    return overlap > EPS
+  }
+
+  const verticalA = aVertical ? a1 : b1
+  const verticalB = aVertical ? a2 : b2
+  const horizontalA = aVertical ? b1 : a1
+  const horizontalB = aVertical ? b2 : a2
+
+  return (
+    between(verticalA.x, horizontalA.x, horizontalB.x) &&
+    between(horizontalA.y, verticalA.y, verticalB.y)
+  )
+}
+
+export const countPathIntersections = (pathA: Point[], pathB: Point[]) => {
+  let count = 0
+  for (let i = 0; i < pathA.length - 1; i++) {
+    for (let j = 0; j < pathB.length - 1; j++) {
+      if (
+        segmentsIntersect(pathA[i]!, pathA[i + 1]!, pathB[j]!, pathB[j + 1]!)
+      ) {
+        count++
+      }
+    }
+  }
+  return count
+}
+
+export const isPathCollidingWithChipInterior = (
+  path: Point[],
+  chipObstacles: ChipObstacle[],
+) => {
+  for (let i = 0; i < path.length - 1; i++) {
+    const start = path[i]!
+    const end = path[i + 1]!
+    for (const obstacle of chipObstacles) {
+      if (!segmentIntersectsRect(start, end, obstacle)) continue
+      if (segmentRunsAlongRectBoundary(start, end, obstacle)) continue
+      return true
+    }
+  }
+  return false
+}
+
+const segmentRunsAlongRectBoundary = (
+  start: Point,
+  end: Point,
+  rect: ChipObstacle,
+) => {
+  const isVertical = Math.abs(start.x - end.x) < EPS
+  const isHorizontal = Math.abs(start.y - end.y) < EPS
+
+  if (isVertical) {
+    return (
+      Math.abs(start.x - rect.minX) < EPS || Math.abs(start.x - rect.maxX) < EPS
+    )
+  }
+
+  if (isHorizontal) {
+    return (
+      Math.abs(start.y - rect.minY) < EPS || Math.abs(start.y - rect.maxY) < EPS
+    )
+  }
+
+  return false
+}

package/lib/solvers/Example28Solver/labelMovement.ts

@@ -0,0 +1,82 @@
+import type { Point } from "@tscircuit/math-utils"
+import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import {
+  findPreferredReroutedSegment,
+  findSegmentContainingPoint,
+  projectPointToPath,
+  projectPointToSegment,
+} from "./geometry"
+
+export const moveAttachedLabelsToReroutedTrace = ({
+  trace,
+  originalTracePath,
+  reroutedTracePath,
+  netLabelPlacements,
+}: {
+  trace: SolvedTracePath
+  originalTracePath: Point[]
+  reroutedTracePath: Point[]
+  netLabelPlacements: NetLabelPlacement[]
+}) =>
+  netLabelPlacements.map((label) => {
+    if (!isLabelAttachedToTrace(label, trace)) return label
+
+    const movedAnchorPoint = getMovedAnchorPointForReroute(
+      label.anchorPoint,
+      originalTracePath,
+      reroutedTracePath,
+    )
+    if (!movedAnchorPoint) return label
+
+    const delta = {
+      x: movedAnchorPoint.x - label.anchorPoint.x,
+      y: movedAnchorPoint.y - label.anchorPoint.y,
+    }
+
+    return {
+      ...label,
+      anchorPoint: movedAnchorPoint,
+      center: {
+        x: label.center.x + delta.x,
+        y: label.center.y + delta.y,
+      },
+    }
+  })
+
+const isLabelAttachedToTrace = (
+  label: NetLabelPlacement,
+  trace: SolvedTracePath,
+) =>
+  label.globalConnNetId === trace.globalConnNetId ||
+  label.mspConnectionPairIds.includes(trace.mspPairId)
+
+const getMovedAnchorPointForReroute = (
+  anchorPoint: Point,
+  originalTracePath: Point[],
+  reroutedTracePath: Point[],
+) => {
+  const originalSegment = findSegmentContainingPoint(
+    originalTracePath,
+    anchorPoint,
+  )
+  if (!originalSegment) return null
+
+  const preferredSegment = findPreferredReroutedSegment(
+    reroutedTracePath,
+    originalSegment.index,
+    originalTracePath.length - 1,
+    originalSegment.orientation,
+    anchorPoint,
+  )
+
+  if (!preferredSegment) {
+    return projectPointToPath(anchorPoint, reroutedTracePath)
+  }
+
+  return projectPointToSegment(
+    anchorPoint,
+    preferredSegment.start,
+    preferredSegment.end,
+  )
+}