@tscircuit/schematic-trace-solver 0.0.48 → 0.0.49

package/lib/solvers/Example28Solver/reroute.ts

@@ -0,0 +1,368 @@
+import type { Point } from "@tscircuit/math-utils"
+import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
+import { getRectBounds } from "lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/geometry"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import { simplifyPath } from "lib/solvers/TraceCleanupSolver/simplifyPath"
+import { detectTraceLabelOverlap } from "lib/solvers/TraceLabelOverlapAvoidanceSolver/detectTraceLabelOverlap"
+import { generateRerouteCandidates } from "lib/solvers/TraceLabelOverlapAvoidanceSolver/rerouteCollidingTrace"
+import type { InputProblem } from "lib/types/InputProblem"
+import { dir } from "lib/utils/dir"
+import {
+  countPathIntersections,
+  getPathKey,
+  getPathLength,
+  isPathCollidingWithChipInterior,
+} from "./geometry"
+import type {
+  ChipObstacle,
+  RerouteCandidateResult,
+  TracePathScore,
+} from "./types"
+
+const LABEL_SIDE_CLEARANCE = 0.1
+const LABEL_HUG_CLEARANCE = 0.001
+
+export const findBestReroutePath = ({
+  trace,
+  obstacleLabel,
+  inputProblem,
+  outputTraces,
+  outputNetLabelPlacements,
+  chipObstacles,
+}: {
+  trace: SolvedTracePath
+  obstacleLabel: NetLabelPlacement
+  inputProblem: InputProblem
+  outputTraces: SolvedTracePath[]
+  outputNetLabelPlacements: NetLabelPlacement[]
+  chipObstacles: ChipObstacle[]
+}) => {
+  const candidateResults = generateRerouteCandidateResults({
+    trace,
+    label: obstacleLabel,
+    inputProblem,
+    outputTraces,
+    outputNetLabelPlacements,
+    chipObstacles,
+  })
+  const bestPath = selectBestReroutePath({
+    trace,
+    obstacleLabel,
+    outputTraces,
+    outputNetLabelPlacements,
+    candidateResults,
+  })
+
+  markSelectedCandidate(candidateResults, bestPath)
+
+  return { bestPath, candidateResults }
+}
+
+export const generateRerouteCandidateResults = ({
+  trace,
+  label,
+  inputProblem,
+  outputTraces,
+  outputNetLabelPlacements,
+  chipObstacles,
+}: {
+  trace: SolvedTracePath
+  label: NetLabelPlacement
+  inputProblem: InputProblem
+  outputTraces: SolvedTracePath[]
+  outputNetLabelPlacements: NetLabelPlacement[]
+  chipObstacles: ChipObstacle[]
+}) => {
+  const rawCandidates = generateCandidatePaths(trace, label, inputProblem)
+  const seen = new Set<string>()
+  const candidateResults: RerouteCandidateResult[] = []
+
+  for (const rawCandidate of rawCandidates) {
+    candidateResults.push(
+      createCandidateResult({
+        trace,
+        obstacleLabel: label,
+        path: simplifyPath(rawCandidate),
+        seen,
+        outputTraces,
+        outputNetLabelPlacements,
+        chipObstacles,
+      }),
+    )
+  }
+
+  return candidateResults
+}
+
+const generateCandidatePaths = (
+  trace: SolvedTracePath,
+  label: NetLabelPlacement,
+  inputProblem: InputProblem,
+) => [
+  ...generateLabelHugCandidates(trace, label),
+  ...generateRerouteCandidates({
+    trace,
+    label,
+    problem: inputProblem,
+    paddingBuffer: LABEL_SIDE_CLEARANCE,
+    detourCount: 0,
+  }),
+  ...generateEndpointDetourCandidates(trace, label),
+]
+
+const createCandidateResult = ({
+  trace,
+  obstacleLabel,
+  path,
+  seen,
+  outputTraces,
+  outputNetLabelPlacements,
+  chipObstacles,
+}: {
+  trace: SolvedTracePath
+  obstacleLabel: NetLabelPlacement
+  path: Point[]
+  seen: Set<string>
+  outputTraces: SolvedTracePath[]
+  outputNetLabelPlacements: NetLabelPlacement[]
+  chipObstacles: ChipObstacle[]
+}): RerouteCandidateResult => {
+  const key = getPathKey(path)
+
+  if (seen.has(key)) {
+    return {
+      path,
+      status: "duplicate",
+      selected: false,
+    }
+  }
+
+  seen.add(key)
+
+  if (isPathCollidingWithChipInterior(path, chipObstacles)) {
+    return {
+      path,
+      status: "chip-collision",
+      selected: false,
+    }
+  }
+
+  return {
+    path,
+    score: scoreTracePath({
+      trace,
+      tracePath: path,
+      obstacleLabel,
+      outputTraces,
+      outputNetLabelPlacements,
+    }),
+    status: "valid",
+    selected: false,
+  }
+}
+
+const generateEndpointDetourCandidates = (
+  trace: SolvedTracePath,
+  label: NetLabelPlacement,
+): Point[][] => {
+  const start = trace.tracePath[0]
+  const end = trace.tracePath[trace.tracePath.length - 1]
+  if (!start || !end) return []
+
+  const bounds = getRectBounds(label.center, label.width, label.height)
+  const padding = LABEL_SIDE_CLEARANCE
+  const labelDirection = dir(label.orientation)
+  const labelSideX =
+    labelDirection.x < 0 ? bounds.minX - padding : bounds.maxX + padding
+  const oppositeSideX =
+    labelDirection.x < 0 ? bounds.maxX + padding : bounds.minX - padding
+  const topY = bounds.maxY + padding
+  const bottomY = bounds.minY - padding
+  const candidates: Point[][] = []
+
+  for (const sideX of [labelSideX, oppositeSideX]) {
+    candidates.push(
+      [
+        start,
+        { x: start.x, y: topY },
+        { x: sideX, y: topY },
+        { x: sideX, y: bottomY },
+        { x: end.x, y: bottomY },
+        end,
+      ],
+      [
+        start,
+        { x: start.x, y: bottomY },
+        { x: sideX, y: bottomY },
+        { x: sideX, y: topY },
+        { x: end.x, y: topY },
+        end,
+      ],
+    )
+  }
+
+  return candidates
+}
+
+const generateLabelHugCandidates = (
+  trace: SolvedTracePath,
+  label: NetLabelPlacement,
+): Point[][] => {
+  const start = trace.tracePath[0]
+  const end = trace.tracePath[trace.tracePath.length - 1]
+  if (!start || !end) return []
+
+  const labelDirection = dir(label.orientation)
+  if (labelDirection.x === 0) return []
+
+  const bounds = getRectBounds(label.center, label.width, label.height)
+  const sideX =
+    labelDirection.x < 0
+      ? bounds.minX - LABEL_SIDE_CLEARANCE
+      : bounds.maxX + LABEL_SIDE_CLEARANCE
+  const topY = bounds.maxY + LABEL_HUG_CLEARANCE
+  const bottomY = bounds.minY - LABEL_HUG_CLEARANCE
+  const startsAboveEnd = start.y >= end.y
+  const firstY = startsAboveEnd ? topY : bottomY
+  const secondY = startsAboveEnd ? bottomY : topY
+
+  return [
+    [
+      start,
+      { x: start.x, y: firstY },
+      { x: sideX, y: firstY },
+      { x: sideX, y: secondY },
+      { x: end.x, y: secondY },
+      end,
+    ],
+    [
+      start,
+      { x: start.x, y: secondY },
+      { x: sideX, y: secondY },
+      { x: sideX, y: firstY },
+      { x: end.x, y: firstY },
+      end,
+    ],
+  ]
+}
+
+const selectBestReroutePath = ({
+  trace,
+  obstacleLabel,
+  outputTraces,
+  outputNetLabelPlacements,
+  candidateResults,
+}: {
+  trace: SolvedTracePath
+  obstacleLabel: NetLabelPlacement
+  outputTraces: SolvedTracePath[]
+  outputNetLabelPlacements: NetLabelPlacement[]
+  candidateResults: RerouteCandidateResult[]
+}) => {
+  let bestPath: Point[] | null = null
+  let bestScore = scoreTracePath({
+    trace,
+    tracePath: trace.tracePath,
+    obstacleLabel,
+    outputTraces,
+    outputNetLabelPlacements,
+  })
+
+  for (const candidate of candidateResults) {
+    if (candidate.status !== "valid" || !candidate.score) continue
+    if (!isBetterScore(candidate.score, bestScore)) continue
+
+    bestScore = candidate.score
+    bestPath = candidate.path
+  }
+
+  return bestPath
+}
+
+const markSelectedCandidate = (
+  candidateResults: RerouteCandidateResult[],
+  bestPath: Point[] | null,
+) => {
+  if (!bestPath) return
+
+  for (const candidate of candidateResults) {
+    candidate.selected = candidate.path === bestPath
+  }
+}
+
+const scoreTracePath = ({
+  trace,
+  tracePath,
+  obstacleLabel,
+  outputTraces,
+  outputNetLabelPlacements,
+}: {
+  trace: SolvedTracePath
+  tracePath: Point[]
+  obstacleLabel: NetLabelPlacement
+  outputTraces: SolvedTracePath[]
+  outputNetLabelPlacements: NetLabelPlacement[]
+}): TracePathScore => {
+  const candidateTrace = { ...trace, tracePath }
+  return {
+    labelIntersections: detectTraceLabelOverlap({
+      traces: [candidateTrace],
+      netLabels: outputNetLabelPlacements,
+    }).length,
+    labelHugDistance: getLabelHugDistance(tracePath, obstacleLabel),
+    traceIntersections: countTraceIntersections(candidateTrace, outputTraces),
+    pathLength: getPathLength(tracePath),
+  }
+}
+
+const countTraceIntersections = (
+  trace: SolvedTracePath,
+  outputTraces: SolvedTracePath[],
+) => {
+  let count = 0
+  for (const otherTrace of outputTraces) {
+    if (otherTrace.mspPairId === trace.mspPairId) continue
+    count += countPathIntersections(trace.tracePath, otherTrace.tracePath)
+  }
+  return count
+}
+
+const isBetterScore = (score: TracePathScore, bestScore: TracePathScore) => {
+  if (score.labelIntersections !== bestScore.labelIntersections) {
+    return score.labelIntersections < bestScore.labelIntersections
+  }
+  if (score.labelHugDistance !== bestScore.labelHugDistance) {
+    return score.labelHugDistance < bestScore.labelHugDistance
+  }
+  if (score.traceIntersections !== bestScore.traceIntersections) {
+    return score.traceIntersections < bestScore.traceIntersections
+  }
+  return score.pathLength < bestScore.pathLength
+}
+
+const getLabelHugDistance = (
+  tracePath: Point[],
+  obstacleLabel: NetLabelPlacement,
+) => {
+  const bounds = getRectBounds(
+    obstacleLabel.center,
+    obstacleLabel.width,
+    obstacleLabel.height,
+  )
+  let distance = 0
+
+  for (const point of tracePath) {
+    distance += getPointDistanceFromRect(point, bounds)
+  }
+
+  return distance
+}
+
+const getPointDistanceFromRect = (
+  point: Point,
+  rect: { minX: number; minY: number; maxX: number; maxY: number },
+) => {
+  const dx = Math.max(rect.minX - point.x, 0, point.x - rect.maxX)
+  const dy = Math.max(rect.minY - point.y, 0, point.y - rect.maxY)
+  return dx + dy
+}

package/lib/solvers/Example28Solver/types.ts

@@ -0,0 +1,47 @@
+import type { Point } from "@tscircuit/math-utils"
+import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
+import type { getObstacleRects } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/rect"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import type { TraceLabelOverlap } from "lib/solvers/TraceLabelOverlapAvoidanceSolver/detectTraceLabelOverlap"
+import type { InputProblem } from "lib/types/InputProblem"
+
+export interface Example28SolverParams {
+  inputProblem: InputProblem
+  traces: SolvedTracePath[]
+  netLabelPlacements: NetLabelPlacement[]
+}
+
+export type TracePathScore = {
+  labelIntersections: number
+  labelHugDistance: number
+  traceIntersections: number
+  pathLength: number
+}
+
+export type SegmentOrientation = "horizontal" | "vertical"
+
+export type PathSegment = {
+  start: Point
+  end: Point
+  orientation: SegmentOrientation
+}
+
+export type ChipObstacle = ReturnType<typeof getObstacleRects>[number]
+
+export type RerouteCandidateResult = {
+  path: Point[]
+  score?: TracePathScore
+  status: "valid" | "duplicate" | "chip-collision"
+  selected: boolean
+}
+
+export type Example28VisualizationState = {
+  inputProblem: InputProblem
+  outputTraces: SolvedTracePath[]
+  outputNetLabelPlacements: NetLabelPlacement[]
+  solved: boolean
+  currentOverlap: TraceLabelOverlap | null
+  currentCandidateResults: RerouteCandidateResult[]
+}
+
+export const EPS = 1e-9

package/lib/solvers/Example28Solver/visualize.ts

@@ -0,0 +1,96 @@
+import type { GraphicsObject } from "graphics-debug"
+import { visualizeInputProblem } from "lib/solvers/SchematicTracePipelineSolver/visualizeInputProblem"
+import { getColorFromString } from "lib/utils/getColorFromString"
+import type {
+  Example28VisualizationState,
+  RerouteCandidateResult,
+} from "./types"
+
+const CANDIDATE_SELECTED_COLOR = "blue"
+const CANDIDATE_REJECTED_COLOR = "red"
+
+export const visualizeExample28Solver = (
+  state: Example28VisualizationState,
+): GraphicsObject => {
+  const graphics = visualizeInputProblem(state.inputProblem)
+
+  drawTraces(graphics, state)
+  drawNetLabels(graphics, state)
+
+  if (!state.solved) {
+    drawCurrentCandidates(graphics, state.currentCandidateResults)
+    drawCurrentOverlap(graphics, state)
+  }
+
+  return graphics
+}
+
+const drawTraces = (
+  graphics: GraphicsObject,
+  state: Example28VisualizationState,
+) => {
+  for (const trace of state.outputTraces) {
+    graphics.lines!.push({
+      points: trace.tracePath,
+      strokeColor: "purple",
+    } as any)
+  }
+}
+
+const drawNetLabels = (
+  graphics: GraphicsObject,
+  state: Example28VisualizationState,
+) => {
+  for (const label of state.outputNetLabelPlacements) {
+    const color = getColorFromString(label.globalConnNetId, 0.35)
+    graphics.rects!.push({
+      center: label.center,
+      width: label.width,
+      height: label.height,
+      fill: color,
+      strokeColor: getColorFromString(label.globalConnNetId, 0.9),
+      label: `netId: ${label.netId}\nglobalConnNetId: ${label.globalConnNetId}`,
+    } as any)
+    graphics.points!.push({
+      ...label.anchorPoint,
+      color: getColorFromString(label.globalConnNetId, 0.9),
+      label: `anchorPoint\norientation: ${label.orientation}`,
+    } as any)
+  }
+}
+
+const drawCurrentCandidates = (
+  graphics: GraphicsObject,
+  candidateResults: RerouteCandidateResult[],
+) => {
+  for (const candidate of candidateResults) {
+    const scoreLabel = candidate.score
+      ? `\nlabel intersections: ${candidate.score.labelIntersections}\ntrace intersections: ${candidate.score.traceIntersections}`
+      : ""
+    graphics.lines!.push({
+      points: candidate.path,
+      strokeColor: candidate.selected
+        ? CANDIDATE_SELECTED_COLOR
+        : CANDIDATE_REJECTED_COLOR,
+      strokeDash: candidate.selected ? undefined : "4 2",
+      label: `${candidate.selected ? "selected" : candidate.status} reroute${scoreLabel}`,
+    } as any)
+  }
+}
+
+const drawCurrentOverlap = (
+  graphics: GraphicsObject,
+  state: Example28VisualizationState,
+) => {
+  if (!state.currentOverlap) return
+
+  const label = state.currentOverlap.label
+  graphics.rects!.push({
+    center: label.center,
+    width: label.width,
+    height: label.height,
+    fill: "rgba(255, 0, 0, 0.2)",
+    strokeColor: CANDIDATE_REJECTED_COLOR,
+    label: `overlap target\n${label.netId ?? label.globalConnNetId}`,
+  } as any)
+}

package/lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver.ts

@@ -20,6 +20,7 @@ import { expandChipsToFitPins } from "./expandChipsToFitPins"
 import { LongDistancePairSolver } from "../LongDistancePairSolver/LongDistancePairSolver"
 import { MergedNetLabelObstacleSolver } from "../TraceLabelOverlapAvoidanceSolver/sub-solvers/LabelMergingSolver/LabelMergingSolver"
 import { TraceCleanupSolver } from "../TraceCleanupSolver/TraceCleanupSolver"
+import { Example28Solver } from "../Example28Solver/Example28Solver"
 
 type PipelineStep<T extends new (...args: any[]) => BaseSolver> = {
   solverName: string
@@ -69,6 +70,7 @@ export class SchematicTracePipelineSolver extends BaseSolver {
   labelMergingSolver?: MergedNetLabelObstacleSolver
   traceLabelOverlapAvoidanceSolver?: TraceLabelOverlapAvoidanceSolver
   traceCleanupSolver?: TraceCleanupSolver
+  example28Solver?: Example28Solver
 
   startTimeOfPhase: Record<string, number>
   endTimeOfPhase: Record<string, number>
@@ -224,6 +226,20 @@ export class SchematicTracePipelineSolver extends BaseSolver {
         ]
       },
     ),
+    definePipelineStep("example28Solver", Example28Solver, (instance) => {
+      const traces =
+        instance.traceCleanupSolver?.getOutput().traces ??
+        instance.traceLabelOverlapAvoidanceSolver!.getOutput().traces
+
+      return [
+        {
+          inputProblem: instance.inputProblem,
+          traces,
+          netLabelPlacements:
+            instance.netLabelPlacementSolver!.netLabelPlacements,
+        },
+      ]
+    }),
   ]
 
   constructor(inputProblem: InputProblem) {

package/package.json

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

package/site/SchematicTraceSingleLineSolver2/SchematicTraceSingleLineSolver2_01-example17-d1_1-u1_1.page.tsx

@@ -0,0 +1,2 @@
+export { inputProblem } from "./SchematicTraceSingleLineSolver2_01-example17.page"
+export { default } from "./SchematicTraceSingleLineSolver2_01-example17.page"

package/site/TraceCleanupSolver/TraceCleanupSolver.page.tsx

@@ -0,0 +1,23 @@
+import { useMemo } from "react"
+import { GenericSolverDebugger } from "site/components/GenericSolverDebugger"
+import { TraceCleanupSolver } from "lib/solvers/TraceCleanupSolver/TraceCleanupSolver"
+import inputData from "../../tests/assets/TraceCleanupSolver.test.input.json"
+
+export default () => {
+  const solver = useMemo(
+    () =>
+      new TraceCleanupSolver({
+        ...inputData,
+        targetTraceIds: new Set(inputData.targetTraceIds),
+        mergedLabelNetIdMap: Object.fromEntries(
+          Object.entries(inputData.mergedLabelNetIdMap).map(([k, v]) => [
+            k,
+            new Set(v as any),
+          ]),
+        ),
+      } as any),
+    [],
+  )
+
+  return <GenericSolverDebugger solver={solver} />
+}

package/site/TraceLabelOverlapAvoidanceSolver/MergedNetLabelObstacles.page.tsx

@@ -0,0 +1,18 @@
+import { useMemo } from "react"
+import { GenericSolverDebugger } from "site/components/GenericSolverDebugger"
+import { MergedNetLabelObstacleSolver } from "lib/solvers/TraceLabelOverlapAvoidanceSolver/sub-solvers/LabelMergingSolver/LabelMergingSolver"
+import inputData from "../../tests/assets/MergedNetLabelObstacles.test.input.json"
+
+export default () => {
+  const solver = useMemo(
+    () =>
+      new MergedNetLabelObstacleSolver({
+        netLabelPlacements: inputData.netLabelPlacements as any,
+        inputProblem: inputData.inputProblem as any,
+        traces: inputData.traces as any,
+      }),
+    [],
+  )
+
+  return <GenericSolverDebugger solver={solver} />
+}

package/site/TraceLabelOverlapAvoidanceSolver/OverlapAvoidanceStepSolver.page.tsx

@@ -0,0 +1,24 @@
+import { useMemo } from "react"
+import { GenericSolverDebugger } from "site/components/GenericSolverDebugger"
+import { OverlapAvoidanceStepSolver } from "lib/solvers/TraceLabelOverlapAvoidanceSolver/sub-solvers/OverlapAvoidanceStepSolver/OverlapAvoidanceStepSolver"
+import inputData from "../../tests/assets/OverlapAvoidanceStepSolver.test.input.json"
+
+export default () => {
+  const solver = useMemo(
+    () =>
+      new OverlapAvoidanceStepSolver({
+        inputProblem: inputData.problem as any,
+        traces: inputData.traces as any,
+        netLabelPlacements: inputData.netLabelPlacements as any,
+        mergedLabelNetIdMap: Object.fromEntries(
+          Object.entries(inputData.mergedLabelNetIdMap).map(([k, v]) => [
+            k,
+            new Set(v as any),
+          ]),
+        ),
+      } as any),
+    [],
+  )
+
+  return <GenericSolverDebugger solver={solver} />
+}

package/site/TraceLabelOverlapAvoidanceSolver/SingleOverlapSolver.page.tsx

@@ -0,0 +1,10 @@
+import { useMemo } from "react"
+import { GenericSolverDebugger } from "site/components/GenericSolverDebugger"
+import { SingleOverlapSolver } from "lib/solvers/TraceLabelOverlapAvoidanceSolver/sub-solvers/SingleOverlapSolver/SingleOverlapSolver"
+import inputData from "../../tests/assets/SingleOverlapSolver.test.input.json"
+
+export default () => {
+  const solver = useMemo(() => new SingleOverlapSolver(inputData as any), [])
+
+  return <GenericSolverDebugger solver={solver} />
+}