@tscircuit/schematic-trace-solver 0.0.120 → 0.0.121

package/tests/repros/repro-bq25895-cross-net-trace-overlap.test.ts

@@ -0,0 +1,75 @@
+import { expect, test } from "bun:test"
+import { SchematicTracePipelineSolver } from "lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import { SCHEMATIC_TRACE_MIN_VISUAL_CENTERLINE_CLEARANCE } from "lib/utils/doesPathCoincideWithTraces"
+import "tests/fixtures/matcher"
+import inputProblem from "./assets/repro-bq25895-cross-net-trace-overlap.input.json"
+
+const EPSILON = 1e-6
+
+const tracesHaveInsufficientParallelClearance = (
+  firstTrace: SolvedTracePath,
+  secondTrace: SolvedTracePath,
+) => {
+  for (
+    let firstPointIndex = 0;
+    firstPointIndex < firstTrace.tracePath.length - 1;
+    firstPointIndex++
+  ) {
+    const firstStart = firstTrace.tracePath[firstPointIndex]!
+    const firstEnd = firstTrace.tracePath[firstPointIndex + 1]!
+    const firstIsVertical = Math.abs(firstStart.x - firstEnd.x) < EPSILON
+    if (!firstIsVertical) continue
+
+    for (
+      let secondPointIndex = 0;
+      secondPointIndex < secondTrace.tracePath.length - 1;
+      secondPointIndex++
+    ) {
+      const secondStart = secondTrace.tracePath[secondPointIndex]!
+      const secondEnd = secondTrace.tracePath[secondPointIndex + 1]!
+      const secondIsVertical = Math.abs(secondStart.x - secondEnd.x) < EPSILON
+      if (!secondIsVertical) continue
+
+      const xSeparation = Math.abs(firstStart.x - secondStart.x)
+      const verticalOverlap =
+        Math.min(
+          Math.max(firstStart.y, firstEnd.y),
+          Math.max(secondStart.y, secondEnd.y),
+        ) -
+        Math.max(
+          Math.min(firstStart.y, firstEnd.y),
+          Math.min(secondStart.y, secondEnd.y),
+        )
+
+      if (
+        xSeparation + EPSILON <
+          SCHEMATIC_TRACE_MIN_VISUAL_CENTERLINE_CLEARANCE &&
+        verticalOverlap > EPSILON
+      ) {
+        return true
+      }
+    }
+  }
+
+  return false
+}
+
+test("BQ25895 CE and GND traces keep visible parallel clearance", () => {
+  const solver = new SchematicTracePipelineSolver(inputProblem as any)
+  solver.solve()
+
+  const traces = solver.netLabelTraceCollisionSolver!.getOutput().traces
+  const ceTraces = traces.filter(
+    (trace) => trace.userNetId === "J3.pin6 to U1.CE",
+  )
+  const groundTraces = traces.filter((trace) => trace.userNetId === "GND")
+  const hasInsufficientCeAndGroundClearance = ceTraces.some((ceTrace) =>
+    groundTraces.some((groundTrace) =>
+      tracesHaveInsufficientParallelClearance(ceTrace, groundTrace),
+    ),
+  )
+
+  expect(hasInsufficientCeAndGroundClearance).toBe(false)
+  expect(solver).toMatchSolverSnapshot(import.meta.path)
+})

package/tests/solvers/TraceCleanupSolver/alignSameNetRails-trace-clearance.test.ts

@@ -0,0 +1,68 @@
+import { expect, test } from "bun:test"
+import {
+  SCHEMATIC_TRACE_MIN_VISUAL_CENTERLINE_CLEARANCE,
+  SCHEMATIC_TRACE_STROKE_WIDTH,
+} from "lib/utils/doesPathCoincideWithTraces"
+import {
+  align,
+  createTrace,
+  getVerticalRailTraces,
+} from "./fixtures/alignSameNetRails"
+
+test("aligns same-net rails at a safe coordinate beside different-net traces", () => {
+  const rails = getVerticalRailTraces()
+  const foreignLowerTrace = createTrace(
+    "foreign-lower",
+    [
+      { x: -2.02, y: -2 },
+      { x: -2.02, y: -0.2 },
+    ],
+    [
+      { pinId: "X1.1", chipId: "X1", x: -2.02, y: -2 },
+      { pinId: "X2.1", chipId: "X2", x: -2.02, y: -0.2 },
+    ],
+    "foreign-lower-net",
+  )
+  const foreignUpperTrace = createTrace(
+    "foreign-upper",
+    [
+      { x: -3.02, y: 0.2 },
+      { x: -3.02, y: 2 },
+    ],
+    [
+      { pinId: "X3.1", chipId: "X3", x: -3.02, y: 0.2 },
+      { pinId: "X4.1", chipId: "X4", x: -3.02, y: 2 },
+    ],
+    "foreign-upper-net",
+  )
+  const traces = [...rails, foreignLowerTrace, foreignUpperTrace]
+
+  const result = align(traces, {
+    eligibleTraceIds: new Set(rails.map((trace) => trace.mspPairId)),
+  })
+
+  expect(result.alignedRailGroupCount).toBe(1)
+
+  const alignedUpper = result.traces.find(
+    (trace) => trace.mspPairId === "upper",
+  )!
+  const alignedLower = result.traces.find(
+    (trace) => trace.mspPairId === "lower",
+  )!
+  const upperRailX = alignedUpper.tracePath[1]!.x
+  const lowerRailX = alignedLower.tracePath[1]!.x
+
+  expect(upperRailX).toBe(lowerRailX)
+  expect(
+    Math.abs(upperRailX - foreignLowerTrace.tracePath[0]!.x),
+  ).toBeGreaterThan(SCHEMATIC_TRACE_STROKE_WIDTH)
+  expect(
+    Math.abs(upperRailX - foreignUpperTrace.tracePath[0]!.x),
+  ).toBeGreaterThan(SCHEMATIC_TRACE_STROKE_WIDTH)
+  expect(
+    Math.min(
+      Math.abs(upperRailX - foreignLowerTrace.tracePath[0]!.x),
+      Math.abs(upperRailX - foreignUpperTrace.tracePath[0]!.x),
+    ),
+  ).toBeCloseTo(SCHEMATIC_TRACE_MIN_VISUAL_CENTERLINE_CLEARANCE, 6)
+})