@tscircuit/schematic-trace-solver 0.0.48 → 0.0.50

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,8 @@ 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"
+import { AvailableNetOrientationSolver } from "../AvailableNetOrientationSolver/AvailableNetOrientationSolver"
 
 type PipelineStep<T extends new (...args: any[]) => BaseSolver> = {
   solverName: string
@@ -69,6 +71,8 @@ export class SchematicTracePipelineSolver extends BaseSolver {
   labelMergingSolver?: MergedNetLabelObstacleSolver
   traceLabelOverlapAvoidanceSolver?: TraceLabelOverlapAvoidanceSolver
   traceCleanupSolver?: TraceCleanupSolver
+  example28Solver?: Example28Solver
+  availableNetOrientationSolver?: AvailableNetOrientationSolver
 
   startTimeOfPhase: Record<string, number>
   endTimeOfPhase: Record<string, number>
@@ -224,6 +228,32 @@ 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,
+        },
+      ]
+    }),
+    definePipelineStep(
+      "availableNetOrientationSolver",
+      AvailableNetOrientationSolver,
+      (instance) => [
+        {
+          inputProblem: instance.inputProblem,
+          traces: instance.example28Solver!.outputTraces,
+          netLabelPlacements:
+            instance.example28Solver!.outputNetLabelPlacements,
+        },
+      ],
+    ),
   ]
 
   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.50",
   "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} />
+}

package/site/TraceLabelOverlapAvoidanceSolver/TraceLabelOverlapAvoidanceSolver.page.tsx

@@ -0,0 +1,146 @@
+import { useMemo } from "react"
+import { GenericSolverDebugger } from "site/components/GenericSolverDebugger"
+import { TraceLabelOverlapAvoidanceSolver } from "lib/solvers/TraceLabelOverlapAvoidanceSolver/TraceLabelOverlapAvoidanceSolver"
+import type { InputProblem } from "lib/types/InputProblem"
+import testInput from "../../tests/assets/TraceLabelOverlapAvoidanceSolver.test.input.json"
+
+const inputProblem: InputProblem = {
+  chips: [
+    {
+      chipId: "schematic_component_0",
+      center: { x: -5, y: 2 },
+      width: 0.6394553499999995,
+      height: 1.08,
+      pins: [
+        { pinId: "V1.1", x: -5.005, y: 2.54 },
+        { pinId: "V1.2", x: -4.995, y: 1.46 },
+      ],
+    },
+    {
+      chipId: "schematic_component_1",
+      center: { x: 0, y: 3 },
+      width: 1.16,
+      height: 0.46,
+      pins: [
+        { pinId: "L1.1", x: -0.55, y: 2.98 },
+        { pinId: "L1.2", x: 0.55, y: 2.97 },
+      ],
+    },
+    {
+      chipId: "schematic_component_2",
+      center: { x: 3, y: 3 },
+      width: 1.04,
+      height: 0.54,
+      pins: [
+        { pinId: "D1.1", x: 2.48, y: 3 },
+        { pinId: "D1.2", x: 3.52, y: 3 },
+      ],
+    },
+    {
+      chipId: "schematic_component_3",
+      center: { x: 3, y: 0 },
+      width: 0.5700000000000001,
+      height: 0.99,
+      pins: [
+        { pinId: "C1.2", x: 3, y: -0.49500000000000005 },
+        { pinId: "C1.1", x: 3, y: 0.495 },
+      ],
+    },
+    {
+      chipId: "schematic_component_4",
+      center: { x: 6, y: 0 },
+      width: 0.3194553499999995,
+      height: 1.1,
+      pins: [
+        { pinId: "R1.1", x: 6, y: 0.5499999999999999 },
+        { pinId: "R1.2", x: 6, y: -0.55 },
+      ],
+    },
+    {
+      chipId: "schematic_component_5",
+      center: { x: -3, y: 0 },
+      width: 0.39624869999999945,
+      height: 0.8916016,
+      pins: [
+        { pinId: "V2.1", x: -2.9999378, y: 0.4458008 },
+        { pinId: "V2.2", x: -3.0000622, y: -0.4458008 },
+      ],
+    },
+    {
+      chipId: "schematic_component_6",
+      center: { x: 0, y: 0 },
+      width: 0.89,
+      height: 1.16,
+      pins: [
+        { pinId: "M1.1", x: 0.3, y: 0.55 },
+        { pinId: "M1.2", x: 0.31, y: -0.55 },
+        { pinId: "M1.3", x: -0.42, y: -0.1 },
+      ],
+    },
+  ],
+  directConnections: [
+    {
+      pinIds: ["V1.1", "L1.1"],
+      netId: ".V1 > .pin1 to .L1 > .pin1",
+    },
+    {
+      pinIds: ["L1.2", "D1.1"],
+      netId: ".L1 > .pin2 to .D1 > .anode",
+    },
+    {
+      pinIds: ["D1.2", "C1.1"],
+      netId: ".D1 > .cathode to .C1 > .pin1",
+    },
+    {
+      pinIds: ["D1.2", "R1.1"],
+      netId: ".D1 > .cathode to .R1 > .pin1",
+    },
+    {
+      pinIds: ["C1.2", "R1.2"],
+      netId: ".C1 > .pin2 to .R1 > .pin2",
+    },
+    {
+      pinIds: ["R1.2", "V1.2"],
+      netId: ".R1 > .pin2 to .V1 > .pin2",
+    },
+    {
+      pinIds: ["L1.2", "M1.1"],
+      netId: ".L1 > .pin2 to .M1 > .drain",
+    },
+    {
+      pinIds: ["M1.2", "V1.2"],
+      netId: ".M1 > .source to .V1 > .pin2",
+    },
+    {
+      pinIds: ["M1.3", "V2.1"],
+      netId: ".M1 > .gate to .V2 > .pin1",
+    },
+    {
+      pinIds: ["V2.2", "V1.2"],
+      netId: ".V2 > .pin2 to .V1 > .pin2",
+    },
+  ],
+  netConnections: [
+    {
+      netId: "GND",
+      pinIds: ["V1.2", "C1.2", "R1.2", "V2.2", "M1.2"],
+      netLabelWidth: 0.3,
+    },
+  ],
+  availableNetLabelOrientations: { GND: ["y-"] },
+  maxMspPairDistance: 2.4,
+}
+
+export default () => {
+  const solver = useMemo(
+    () =>
+      new TraceLabelOverlapAvoidanceSolver({
+        inputProblem: inputProblem as any,
+        netLabelPlacements: testInput.netLabelPlacements as any,
+        traces: testInput.traces as any,
+      }),
+    [],
+  )
+
+  return <GenericSolverDebugger solver={solver} />
+}

package/site/TraceLabelOverlapAvoidanceSolver/renderComparisonView01.page.tsx

@@ -0,0 +1,32 @@
+import { useMemo } from "react"
+import { InteractiveGraphics } from "graphics-debug/react"
+import { stackGraphicsHorizontally } from "graphics-debug"
+import { NetLabelPlacementSolver } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
+import { MergedNetLabelObstacleSolver } from "lib/solvers/TraceLabelOverlapAvoidanceSolver/sub-solvers/LabelMergingSolver/LabelMergingSolver"
+import inputData from "../../tests/assets/1.input.json"
+
+export default () => {
+  const graphics = useMemo(() => {
+    const mergedNetLabelObstacleSolver = new MergedNetLabelObstacleSolver(
+      inputData.mergedNetLabelObstacleSolver as any,
+    )
+    const netLabelPlacementSolver = new NetLabelPlacementSolver(
+      inputData.netLabelPlacementSolver as any,
+    )
+
+    mergedNetLabelObstacleSolver.solve()
+    netLabelPlacementSolver.solve()
+
+    return stackGraphicsHorizontally(
+      [
+        netLabelPlacementSolver.visualize(),
+        mergedNetLabelObstacleSolver.visualize(),
+      ],
+      {
+        titles: ["NetLabelPlacementSolver", "MergedNetLabelObstacles"],
+      },
+    )
+  }, [])
+
+  return <InteractiveGraphics graphics={graphics} />
+}

package/site/TraceLabelOverlapAvoidanceSolver/renderComparisonView02.page.tsx

@@ -0,0 +1,32 @@
+import { useMemo } from "react"
+import { InteractiveGraphics } from "graphics-debug/react"
+import { stackGraphicsHorizontally } from "graphics-debug"
+import { MergedNetLabelObstacleSolver } from "lib/solvers/TraceLabelOverlapAvoidanceSolver/sub-solvers/LabelMergingSolver/LabelMergingSolver"
+import { SingleOverlapSolver } from "lib/solvers/TraceLabelOverlapAvoidanceSolver/sub-solvers/SingleOverlapSolver/SingleOverlapSolver"
+import inputData from "../../tests/assets/2.input.json"
+
+export default () => {
+  const graphics = useMemo(() => {
+    const mergedNetLabelObstacleSolver = new MergedNetLabelObstacleSolver(
+      inputData.mergedNetLabelObstacleSolver as any,
+    )
+    const singleOverlapSolver = new SingleOverlapSolver(
+      inputData.singleOverlapSolver as any,
+    )
+
+    mergedNetLabelObstacleSolver.solve()
+    singleOverlapSolver.solve()
+
+    return stackGraphicsHorizontally(
+      [
+        mergedNetLabelObstacleSolver.visualize(),
+        singleOverlapSolver.visualize(),
+      ],
+      {
+        titles: ["MergedNetLabelObstaclesSolver", "SingleOverlapSolver"],
+      },
+    )
+  }, [])
+
+  return <InteractiveGraphics graphics={graphics} />
+}

package/site/TraceLabelOverlapAvoidanceSolver/renderComparisonView03.page.tsx

@@ -0,0 +1,35 @@
+import { useMemo } from "react"
+import { InteractiveGraphics } from "graphics-debug/react"
+import { stackGraphicsHorizontally } from "graphics-debug"
+import { TraceCleanupSolver } from "lib/solvers/TraceCleanupSolver/TraceCleanupSolver"
+import { SingleOverlapSolver } from "lib/solvers/TraceLabelOverlapAvoidanceSolver/sub-solvers/SingleOverlapSolver/SingleOverlapSolver"
+import inputData from "../../tests/assets/3.input.json"
+
+export default () => {
+  const graphics = useMemo(() => {
+    const traceCleanupSolver = new TraceCleanupSolver({
+      ...inputData.traceCleanupSolver,
+      targetTraceIds: new Set(inputData.traceCleanupSolver.targetTraceIds),
+      mergedLabelNetIdMap: Object.fromEntries(
+        Object.entries(inputData.traceCleanupSolver.mergedLabelNetIdMap).map(
+          ([key, value]) => [key, new Set(value as any)],
+        ),
+      ),
+    } as any)
+    const singleOverlapSolver = new SingleOverlapSolver(
+      inputData.singleOverlapSolver as any,
+    )
+
+    traceCleanupSolver.solve()
+    singleOverlapSolver.solve()
+
+    return stackGraphicsHorizontally(
+      [singleOverlapSolver.visualize(), traceCleanupSolver.visualize()],
+      {
+        titles: ["SingleOverlapSolver", "TraceCleanupSolver"],
+      },
+    )
+  }, [])
+
+  return <InteractiveGraphics graphics={graphics} />
+}

package/site/examples/example01.page.tsx

@@ -0,0 +1,6 @@
+import { PipelineDebugger } from "site/components/PipelineDebugger"
+import inputProblem from "../../tests/assets/example01.json"
+
+export { inputProblem }
+
+export default () => <PipelineDebugger inputProblem={inputProblem as any} />