@tscircuit/schematic-trace-solver 0.0.42 → 0.0.43

package/tests/examples/example29.test.ts

@@ -0,0 +1,13 @@
+import { test, expect } from "bun:test"
+import type { InputProblem } from "lib/index"
+import { SchematicTracePipelineSolver } from "lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver"
+import "tests/fixtures/matcher"
+import inputProblem from "../assets/example26.json"
+
+test("example29", () => {
+  const solver = new SchematicTracePipelineSolver(inputProblem as any)
+
+  solver.solve()
+
+  expect(solver).toMatchSolverSnapshot(import.meta.path)
+})

package/tests/solvers/{TraceLabelOverlapAvoidanceSolver/sub-solver → TraceCleanupSolver}/TraceCleanupSolver.test.ts

@@ -1,7 +1,7 @@
 import { expect } from "bun:test"
 import { test } from "bun:test"
-import { TraceCleanupSolver } from "lib/solvers/TraceLabelOverlapAvoidanceSolver/sub-solvers/TraceCleanupSolver/TraceCleanupSolver"
-import inputData from "../../../assets/TraceCleanupSolver.test.input.json"
+import inputData from "../../assets/TraceCleanupSolver.test.input.json"
+import { TraceCleanupSolver } from "lib/solvers/TraceCleanupSolver/TraceCleanupSolver"
 
 test("TraceCleanupSolver snapshot", () => {
   const solver = new TraceCleanupSolver({

package/tests/solvers/{TraceLabelOverlapAvoidanceSolver/sub-solver → TraceCleanupSolver}/__snapshots__/TraceCleanupSolver.snap.svg

@@ -51,7 +51,7 @@ x-" data-x="1.6" data-y="-2.295" cx="353.6" cy="465.31999999999994" r="3" fill="
     <polyline data-points="1.2000000000000002,0.30000000000000004 1.6,-1.895" data-type="line" data-label="" points="308.80000000000007,174.68 353.6,420.52" fill="none" stroke="hsl(190, 100%, 50%, 0.1)" stroke-width="1" stroke-dasharray="4 2" />
   </g>
   <g>
-    <polyline data-points="1.2000000000000002,-0.30000000000000004 1.4000000000000001,-0.30000000000000004 1.4000000000000001,-1.2975000000000003 1.049,-1.2975000000000003 1.049,-2.2950000000000004 1.6,-2.295" data-type="line" data-label="" points="308.80000000000007,241.88 331.20000000000005,241.88 331.20000000000005,353.6 291.88800000000003,353.6 291.88800000000003,465.32000000000005 353.6,465.31999999999994" fill="none" stroke="blue" stroke-width="1" />
+    <polyline data-points="1.2000000000000002,-0.30000000000000004 1.4000000000000001,-0.30000000000000004 1.4000000000000001,-1.2975000000000003 1.049,-1.2975000000000003 1.049,-2.2950000000000004 1.6,-2.295" data-type="line" data-label="" points="308.80000000000007,241.88 331.20000000000005,241.88 331.20000000000005,353.6 291.88800000000003,353.6 291.88800000000003,465.32000000000005 353.6,465.31999999999994" fill="none" stroke="red" stroke-width="1" />
   </g>
   <g>
     <rect data-type="rect" data-label="schematic_component_0" data-x="0" data-y="0" x="40" y="152.28" width="268.80000000000007" height="111.99999999999997" fill="hsl(24, 100%, 50%, 0.1)" stroke="black" stroke-width="0.008928571428571428" />

package/tests/solvers/TraceLabelOverlapAvoidanceSolver/renderComparisonView/__snapshots__/renderComparisonView03.snap.svg

@@ -107,7 +107,7 @@ x-" data-x="7.850000000000001" data-y="-2.295" cx="490.488888888889" cy="391.586
     <polyline data-points="7.450000000000001,0.30000000000000004 7.850000000000001,-1.895" data-type="line" data-label="" points="470.57777777777784,262.41333333333336 490.488888888889,371.6755555555556" fill="none" stroke="hsl(190, 100%, 50%, 0.1)" stroke-width="1" stroke-dasharray="4 2" />
   </g>
   <g>
-    <polyline data-points="7.450000000000001,-0.30000000000000004 7.650000000000001,-0.30000000000000004 7.650000000000001,-1.2975000000000003 7.299000000000001,-1.2975000000000003 7.299000000000001,-2.2950000000000004 7.850000000000001,-2.295" data-type="line" data-label="" points="470.57777777777784,292.28000000000003 480.5333333333334,292.28000000000003 480.5333333333334,341.9333333333334 463.06133333333344,341.9333333333334 463.06133333333344,391.5866666666667 490.488888888889,391.5866666666667" fill="none" stroke="blue" stroke-width="1" />
+    <polyline data-points="7.450000000000001,-0.30000000000000004 7.650000000000001,-0.30000000000000004 7.650000000000001,-1.2975000000000003 7.299000000000001,-1.2975000000000003 7.299000000000001,-2.2950000000000004 7.850000000000001,-2.295" data-type="line" data-label="" points="470.57777777777784,292.28000000000003 480.5333333333334,292.28000000000003 480.5333333333334,341.9333333333334 463.06133333333344,341.9333333333334 463.06133333333344,391.5866666666667 490.488888888889,391.5866666666667" fill="none" stroke="red" stroke-width="1" />
   </g>
   <g>
     <rect data-type="rect" data-label="schematic_component_0" data-x="0" data-y="0" x="40.00000000000001" y="252.4577777777778" width="119.4666666666667" height="49.7777777777778" fill="hsl(24, 100%, 50%, 0.1)" stroke="black" stroke-width="0.020089285714285712" />

package/tests/solvers/TraceLabelOverlapAvoidanceSolver/renderComparisonView/renderComparisonView03.test.ts

@@ -5,8 +5,8 @@ import {
   stackGraphicsHorizontally,
 } from "graphics-debug"
 import { SingleOverlapSolver } from "lib/solvers/TraceLabelOverlapAvoidanceSolver/sub-solvers/SingleOverlapSolver/SingleOverlapSolver"
-import { TraceCleanupSolver } from "lib/solvers/TraceLabelOverlapAvoidanceSolver/sub-solvers/TraceCleanupSolver/TraceCleanupSolver"
 import inputData from "../../../assets/3.input.json"
+import { TraceCleanupSolver } from "lib/solvers/TraceCleanupSolver/TraceCleanupSolver"
 
 test("SingleOverlapSolver-to-TraceCleanupSolver snapshot", () => {
   // Convert targetTraceIds to Set

package/lib/solvers/TraceLabelOverlapAvoidanceSolver/sub-solvers/TraceCleanupSolver/TraceCleanupSolver.ts

@@ -1,132 +0,0 @@
-import type { InputProblem } from "lib/types/InputProblem"
-import type { GraphicsObject, Line } from "graphics-debug"
-import type { NetLabelPlacement } from "../../../NetLabelPlacementSolver/NetLabelPlacementSolver"
-import { minimizeTurnsWithFilteredLabels } from "./minimizeTurnsWithFilteredLabels"
-import { balanceLShapes } from "./balanceLShapes"
-import { BaseSolver } from "lib/solvers/BaseSolver/BaseSolver"
-import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
-import { visualizeInputProblem } from "lib/solvers/SchematicTracePipelineSolver/visualizeInputProblem"
-
-interface TraceCleanupSolverInput {
-  inputProblem: InputProblem
-  allTraces: SolvedTracePath[]
-  targetTraceIds: Set<string>
-  allLabelPlacements: NetLabelPlacement[]
-  mergedLabelNetIdMap: Record<string, Set<string>>
-  paddingBuffer: number
-}
-
-/**
- * Cleans up traces by minimizing turns and balancing L-shapes to improve
- * the overall aesthetics and readability of the schematic.
- */
-export class TraceCleanupSolver extends BaseSolver {
-  private input: TraceCleanupSolverInput
-  private outputTraces: SolvedTracePath[]
-  private pipelineStepIndex = 0
-  private tracesToProcess: SolvedTracePath[]
-  private minimizedTraces: SolvedTracePath[] | null = null
-  private balancedTraces: SolvedTracePath[] | null = null
-
-  constructor(solverInput: TraceCleanupSolverInput) {
-    super()
-    this.input = solverInput
-    this.outputTraces = [...solverInput.allTraces]
-    this.tracesToProcess = this.outputTraces.filter((t) =>
-      this.input.targetTraceIds.has(t.mspPairId),
-    )
-  }
-
-  override _step() {
-    const {
-      targetTraceIds,
-      inputProblem,
-      allLabelPlacements,
-      mergedLabelNetIdMap,
-      paddingBuffer,
-    } = this.input
-
-    if (targetTraceIds.size === 0) {
-      this.solved = true
-      return
-    }
-
-    switch (this.pipelineStepIndex) {
-      case 0: {
-        // Step 0: Minimize turns
-        const minimizedTracesResult = minimizeTurnsWithFilteredLabels({
-          traces: this.tracesToProcess,
-          inputProblem,
-          allLabelPlacements,
-          mergedLabelNetIdMap,
-          paddingBuffer,
-        })
-
-        this.minimizedTraces = minimizedTracesResult ?? this.tracesToProcess
-
-        const tracesMap = new Map(
-          this.input.allTraces.map((t) => [t.mspPairId, t]),
-        )
-        for (const trace of this.minimizedTraces) {
-          tracesMap.set(trace.mspPairId, trace)
-        }
-        this.outputTraces = Array.from(tracesMap.values())
-        this.pipelineStepIndex++
-        break
-      }
-      case 1: {
-        // Step 1: Balance L-shapes
-        const balancedTracesResult = balanceLShapes({
-          traces: this.minimizedTraces!,
-          inputProblem,
-          allLabelPlacements,
-        })
-
-        this.balancedTraces = balancedTracesResult ?? this.minimizedTraces
-
-        const tracesMap = new Map(
-          this.input.allTraces.map((t) => [t.mspPairId, t]),
-        )
-        for (const trace of this.balancedTraces!) {
-          tracesMap.set(trace.mspPairId, trace)
-        }
-        this.outputTraces = Array.from(tracesMap.values())
-        this.pipelineStepIndex++
-        break
-      }
-      case 2: {
-        // Step 2: Done
-        this.solved = true
-        break
-      }
-    }
-  }
-
-  getOutput() {
-    return {
-      traces: this.outputTraces,
-    }
-  }
-
-  override visualize(): GraphicsObject {
-    const graphics = visualizeInputProblem(this.input.inputProblem, {
-      chipAlpha: 0.1,
-      connectionAlpha: 0.1,
-    })
-
-    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 = []
-
-    for (const trace of this.outputTraces) {
-      const line: Line = {
-        points: trace.tracePath.map((p) => ({ x: p.x, y: p.y })),
-        strokeColor: "blue",
-      }
-      graphics.lines!.push(line)
-    }
-    return graphics
-  }
-}

package/lib/solvers/TraceLabelOverlapAvoidanceSolver/sub-solvers/TraceCleanupSolver/balanceLShapes.ts

@@ -1,209 +0,0 @@
-import type { Point } from "graphics-debug"
-import type { InputProblem } from "lib/types/InputProblem"
-import type { NetLabelPlacement } from "../../../NetLabelPlacementSolver/NetLabelPlacementSolver"
-import { simplifyPath } from "./simplifyPath"
-import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
-import { segmentIntersectsRect } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions"
-import { getObstacleRects } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/rect"
-
-export const balanceLShapes = ({
-  traces,
-  inputProblem,
-  allLabelPlacements,
-}: {
-  traces: SolvedTracePath[]
-  inputProblem: InputProblem
-  allLabelPlacements: NetLabelPlacement[]
-}): SolvedTracePath[] | null => {
-  const TOLERANCE = 1e-5
-  let changesMade = false
-
-  for (const trace of traces) {
-    if (trace.tracePath.length === 4) {
-      const [p0, p1, p2, p3] = trace.tracePath
-      const isHVHShape = p0.y === p1.y && p1.x === p2.x && p2.y === p3.y
-      const isVHVShape = p0.x === p1.x && p1.y === p2.y && p2.x === p3.x
-
-      const isCollinearHorizontal =
-        p0.y === p1.y && p1.y === p2.y && p2.y === p3.y
-      const isCollinearVertical =
-        p0.x === p1.x && p1.x === p2.x && p2.x === p3.x
-      const isCollinear = isCollinearHorizontal || isCollinearVertical
-
-      let isSameDirection = false
-      if (isHVHShape) {
-        isSameDirection = Math.sign(p1.x - p0.x) === Math.sign(p3.x - p2.x)
-      } else if (isVHVShape) {
-        isSameDirection = Math.sign(p1.y - p0.y) === Math.sign(p3.y - p2.y)
-      }
-
-      const isValidZShape =
-        (isHVHShape || isVHVShape) && !isCollinear && isSameDirection
-
-      if (!isValidZShape) {
-        return null
-      }
-    }
-  }
-
-  const obstacles = getObstacleRects(inputProblem).map((obs) => ({
-    ...obs,
-    minX: obs.minX + TOLERANCE,
-    maxX: obs.maxX - TOLERANCE,
-    minY: obs.minY + TOLERANCE,
-    maxY: obs.maxY - TOLERANCE,
-  }))
-
-  const segmentIntersectsAnyRect = (
-    p1: Point,
-    p2: Point,
-    rects: any[],
-  ): boolean => {
-    for (const rect of rects) {
-      if (segmentIntersectsRect(p1, p2, rect)) {
-        return true
-      }
-    }
-    return false
-  }
-
-  const getLabelBounds = (labels: NetLabelPlacement[], traceNetId: string) => {
-    const filteredLabels = labels.filter(
-      (label) => label.globalConnNetId !== traceNetId,
-    )
-
-    return filteredLabels.map((nl) => ({
-      minX: nl.center.x - nl.width / 2 + TOLERANCE,
-      maxX: nl.center.x + nl.width / 2 - TOLERANCE,
-      minY: nl.center.y - nl.height / 2 + TOLERANCE,
-      maxY: nl.center.y + nl.height / 2 - TOLERANCE,
-    }))
-  }
-
-  const newTraces = traces.map((trace) => {
-    const newPath = [...trace.tracePath]
-
-    if (newPath.length < 4) {
-      return { ...trace }
-    }
-
-    const labelBounds = getLabelBounds(
-      allLabelPlacements,
-      trace.globalConnNetId,
-    )
-
-    if (newPath.length === 4) {
-      const [p0, p1, p2, p3] = newPath
-      let p1New: Point
-      let p2New: Point
-
-      const isHVHShape = p0.y === p1.y && p1.x === p2.x && p2.y === p3.y
-
-      if (isHVHShape) {
-        const idealX = (p0.x + p3.x) / 2
-        p1New = { x: idealX, y: p1.y }
-        p2New = { x: idealX, y: p2.y }
-      } else {
-        const idealY = (p0.y + p3.y) / 2
-        p1New = { x: p1.x, y: idealY }
-        p2New = { x: p2.x, y: idealY }
-      }
-
-      const collides =
-        segmentIntersectsAnyRect(p0, p1New, obstacles) ||
-        segmentIntersectsAnyRect(p1New, p2New, obstacles) ||
-        segmentIntersectsAnyRect(p2New, p3, obstacles) ||
-        segmentIntersectsAnyRect(p0, p1New, labelBounds) ||
-        segmentIntersectsAnyRect(p1New, p2New, labelBounds) ||
-        segmentIntersectsAnyRect(p2New, p3, labelBounds)
-
-      if (!collides) {
-        newPath[1] = p1New
-        newPath[2] = p2New
-        changesMade = true
-      }
-
-      return { ...trace, tracePath: simplifyPath(newPath) }
-    }
-
-    for (let i = 1; i < newPath.length - 4; i++) {
-      const p1 = newPath[i]
-      const p2 = newPath[i + 1]
-      const p3 = newPath[i + 2]
-      const p4 = newPath[i + 3]
-
-      const isHVHZShape = p1.y === p2.y && p2.x === p3.x && p3.y === p4.y
-      const isVHVZShape = p1.x === p2.x && p2.y === p3.y && p3.x === p4.x
-
-      const isCollinearHorizontal =
-        p1.y === p2.y && p2.y === p3.y && p3.y === p4.y
-      const isCollinearVertical =
-        p1.x === p2.x && p2.x === p3.x && p3.x === p4.x
-      const isCollinear = isCollinearHorizontal || isCollinearVertical
-
-      let isSameDirection = false
-      if (isHVHZShape) {
-        isSameDirection = Math.sign(p2.x - p1.x) === Math.sign(p4.x - p3.x)
-      } else if (isVHVZShape) {
-        isSameDirection = Math.sign(p2.y - p1.y) === Math.sign(p4.y - p3.y)
-      }
-
-      const isValidZShape =
-        (isHVHZShape || isVHVZShape) && !isCollinear && isSameDirection
-
-      if (!isValidZShape) {
-        continue
-      }
-
-      let p2New: Point
-      let p3New: Point
-      const len1Original = isHVHZShape
-        ? Math.abs(p1.x - p2.x)
-        : Math.abs(p1.y - p2.y)
-      const len2Original = isHVHZShape
-        ? Math.abs(p3.x - p4.x)
-        : Math.abs(p3.y - p4.y)
-
-      if (Math.abs(len1Original - len2Original) < 0.001) {
-        continue
-      }
-
-      if (isHVHZShape) {
-        const idealX = (p1.x + p4.x) / 2
-        p2New = { x: idealX, y: p2.y }
-        p3New = { x: idealX, y: p3.y }
-      } else {
-        const idealY = (p1.y + p4.y) / 2
-        p2New = { x: p2.x, y: idealY }
-        p3New = { x: p3.x, y: idealY }
-      }
-
-      const collides =
-        segmentIntersectsAnyRect(p1, p2New, obstacles) ||
-        segmentIntersectsAnyRect(p2New, p3New, obstacles) ||
-        segmentIntersectsAnyRect(p3New, p4, obstacles) ||
-        segmentIntersectsAnyRect(p1, p2New, labelBounds) ||
-        segmentIntersectsAnyRect(p2New, p3New, labelBounds) ||
-        segmentIntersectsAnyRect(p3New, p4, labelBounds)
-
-      if (!collides) {
-        newPath[i + 1] = p2New
-        newPath[i + 2] = p3New
-        changesMade = true
-        i = 0
-      }
-    }
-
-    const finalSimplifiedPath = simplifyPath(newPath)
-    return {
-      ...trace,
-      tracePath: finalSimplifiedPath,
-    }
-  })
-
-  if (changesMade) {
-    return newTraces
-  } else {
-    return null
-  }
-}

package/lib/solvers/TraceLabelOverlapAvoidanceSolver/sub-solvers/TraceCleanupSolver/minimizeTurnsWithFilteredLabels.ts

@@ -1,66 +0,0 @@
-import type { InputProblem } from "lib/types/InputProblem"
-import type { NetLabelPlacement } from "../../../NetLabelPlacementSolver/NetLabelPlacementSolver"
-import { minimizeTurns } from "./turnMinimization"
-import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
-import { getObstacleRects } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/rect"
-
-export const minimizeTurnsWithFilteredLabels = ({
-  traces,
-  inputProblem,
-  allLabelPlacements,
-  mergedLabelNetIdMap,
-  paddingBuffer,
-}: {
-  traces: SolvedTracePath[]
-  inputProblem: InputProblem
-  allLabelPlacements: NetLabelPlacement[]
-  mergedLabelNetIdMap: Record<string, Set<string>>
-  paddingBuffer: number
-}): SolvedTracePath[] | null => {
-  let changesMade = false
-  const obstacles = getObstacleRects(inputProblem)
-
-  const newTraces = traces.map((trace) => {
-    const originalPath = trace.tracePath
-    const filteredLabels = allLabelPlacements.filter((label) => {
-      const originalNetIds = mergedLabelNetIdMap[label.globalConnNetId]
-      if (originalNetIds) {
-        return !originalNetIds.has(trace.globalConnNetId)
-      }
-      return label.globalConnNetId !== trace.globalConnNetId
-    })
-
-    const labelBounds = filteredLabels.map((nl) => ({
-      minX: nl.center.x - nl.width / 2 - paddingBuffer,
-      maxX: nl.center.x + nl.width / 2 + paddingBuffer,
-      minY: nl.center.y - nl.height / 2 - paddingBuffer,
-      maxY: nl.center.y + nl.height / 2 + paddingBuffer,
-    }))
-
-    const newPath = minimizeTurns({
-      path: originalPath,
-      obstacles,
-      labelBounds,
-    })
-
-    if (
-      newPath.length !== originalPath.length ||
-      newPath.some(
-        (p, i) => p.x !== originalPath[i].x || p.y !== originalPath[i].y,
-      )
-    ) {
-      changesMade = true
-    }
-
-    return {
-      ...trace,
-      tracePath: newPath,
-    }
-  })
-
-  if (changesMade) {
-    return newTraces
-  } else {
-    return null
-  }
-}