@tscircuit/schematic-trace-solver 0.0.41 → 0.0.43

package/lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver.ts

@@ -7,16 +7,19 @@ import type { GraphicsObject } from "graphics-debug"
 import { BaseSolver } from "lib/solvers/BaseSolver/BaseSolver"
 import type { InputProblem } from "lib/types/InputProblem"
 import { MspConnectionPairSolver } from "../MspConnectionPairSolver/MspConnectionPairSolver"
-import { SchematicTraceLinesSolver } from "../SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import {
+  SchematicTraceLinesSolver,
+  type SolvedTracePath,
+} from "../SchematicTraceLinesSolver/SchematicTraceLinesSolver"
 import { TraceOverlapShiftSolver } from "../TraceOverlapShiftSolver/TraceOverlapShiftSolver"
 import { NetLabelPlacementSolver } from "../NetLabelPlacementSolver/NetLabelPlacementSolver"
 import { visualizeInputProblem } from "./visualizeInputProblem"
-import { GuidelinesSolver } from "../GuidelinesSolver/GuidelinesSolver"
 import { TraceLabelOverlapAvoidanceSolver } from "../TraceLabelOverlapAvoidanceSolver/TraceLabelOverlapAvoidanceSolver"
-import { getInputChipBounds } from "../GuidelinesSolver/getInputChipBounds"
 import { correctPinsInsideChips } from "./correctPinsInsideChip"
 import { expandChipsToFitPins } from "./expandChipsToFitPins"
 import { LongDistancePairSolver } from "../LongDistancePairSolver/LongDistancePairSolver"
+import { MergedNetLabelObstacleSolver } from "../TraceLabelOverlapAvoidanceSolver/sub-solvers/LabelMergingSolver/LabelMergingSolver"
+import { TraceCleanupSolver } from "../TraceCleanupSolver/TraceCleanupSolver"
 
 type PipelineStep<T extends new (...args: any[]) => BaseSolver> = {
   solverName: string
@@ -63,7 +66,9 @@ export class SchematicTracePipelineSolver extends BaseSolver {
   longDistancePairSolver?: LongDistancePairSolver
   traceOverlapShiftSolver?: TraceOverlapShiftSolver
   netLabelPlacementSolver?: NetLabelPlacementSolver
+  labelMergingSolver?: MergedNetLabelObstacleSolver
   traceLabelOverlapAvoidanceSolver?: TraceLabelOverlapAvoidanceSolver
+  traceCleanupSolver?: TraceCleanupSolver
 
   startTimeOfPhase: Record<string, number>
   endTimeOfPhase: Record<string, number>
@@ -182,18 +187,42 @@ export class SchematicTracePipelineSolver extends BaseSolver {
           },
         ]
       },
-      {
-        onSolved: (instance) => {
-          if (
-            instance.traceLabelOverlapAvoidanceSolver &&
-            instance.netLabelPlacementSolver
-          ) {
-            const { netLabelPlacements } =
-              instance.traceLabelOverlapAvoidanceSolver.getOutput()
-            instance.netLabelPlacementSolver.netLabelPlacements =
-              netLabelPlacements
-          }
+    ),
+    definePipelineStep("traceCleanupSolver", TraceCleanupSolver, (instance) => {
+      const prevSolverOutput =
+        instance.traceLabelOverlapAvoidanceSolver!.getOutput()
+      const traces = prevSolverOutput.traces
+
+      const labelMergingOutput =
+        instance.traceLabelOverlapAvoidanceSolver!.labelMergingSolver!.getOutput()
+
+      return [
+        {
+          inputProblem: instance.inputProblem,
+          allTraces: traces,
+          targetTraceIds: new Set(traces.map((t) => t.mspPairId)),
+          allLabelPlacements: labelMergingOutput.netLabelPlacements,
+          mergedLabelNetIdMap: labelMergingOutput.mergedLabelNetIdMap,
+          paddingBuffer: 0.1,
         },
+      ]
+    }),
+    definePipelineStep(
+      "netLabelPlacementSolver",
+      NetLabelPlacementSolver,
+      (instance) => {
+        const traces =
+          instance.traceCleanupSolver?.getOutput().traces ??
+          instance.traceLabelOverlapAvoidanceSolver!.getOutput().traces
+
+        return [
+          {
+            inputProblem: instance.inputProblem,
+            inputTraceMap: Object.fromEntries(
+              traces.map((trace: SolvedTracePath) => [trace.mspPairId, trace]),
+            ),
+          },
+        ]
       },
     ),
   ]
@@ -303,16 +332,19 @@ export class SchematicTracePipelineSolver extends BaseSolver {
         }) as GraphicsObject[]),
     ]
 
-    if (visualizations.length === 1) return visualizations[0]!
+    if (visualizations.length === 1) {
+      return visualizations[0]!
+    }
 
     // Simple combination of visualizations
-    return {
+    const finalGraphics = {
       points: visualizations.flatMap((v) => v.points || []),
       rects: visualizations.flatMap((v) => v.rects || []),
       lines: visualizations.flatMap((v) => v.lines || []),
       circles: visualizations.flatMap((v) => v.circles || []),
       texts: visualizations.flatMap((v) => v.texts || []),
     }
+    return finalGraphics
   }
 
   /**

package/lib/solvers/TraceCleanupSolver/TraceCleanupSolver.ts

@@ -0,0 +1,133 @@
+import type { InputProblem } from "lib/types/InputProblem"
+import type { GraphicsObject, Line } from "graphics-debug"
+import { minimizeTurnsWithFilteredLabels } from "./minimizeTurnsWithFilteredLabels"
+import { balanceZShapes } from "./balanceZShapes"
+import { BaseSolver } from "lib/solvers/BaseSolver/BaseSolver"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import { visualizeInputProblem } from "lib/solvers/SchematicTracePipelineSolver/visualizeInputProblem"
+import type { NetLabelPlacement } from "../NetLabelPlacementSolver/NetLabelPlacementSolver"
+
+interface TraceCleanupSolverInput {
+  inputProblem: InputProblem
+  allTraces: SolvedTracePath[]
+  targetTraceIds: Set<string>
+  allLabelPlacements: NetLabelPlacement[]
+  mergedLabelNetIdMap: Record<string, Set<string>>
+  paddingBuffer: number
+}
+
+type PipelineStep = "minimizing_turns" | "balancing_l_shapes"
+
+/**
+ * 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 traceIdQueue: string[]
+  private tracesMap: Map<string, SolvedTracePath>
+  private pipelineStep: PipelineStep = "minimizing_turns"
+  private activeTraceId: string | null = null // New property
+
+  constructor(solverInput: TraceCleanupSolverInput) {
+    super()
+    this.input = solverInput
+    this.outputTraces = [...solverInput.allTraces]
+    this.tracesMap = new Map(this.outputTraces.map((t) => [t.mspPairId, t]))
+    this.traceIdQueue = Array.from(solverInput.targetTraceIds)
+  }
+
+  override _step() {
+    if (
+      this.pipelineStep === "minimizing_turns" &&
+      this.traceIdQueue.length === 0
+    ) {
+      this.pipelineStep = "balancing_l_shapes"
+      this.traceIdQueue = Array.from(this.input.targetTraceIds)
+    }
+
+    if (
+      this.pipelineStep === "balancing_l_shapes" &&
+      this.traceIdQueue.length === 0
+    ) {
+      this.solved = true
+      return
+    }
+
+    const targetMspConnectionPairId = this.traceIdQueue.shift()!
+    this.activeTraceId = targetMspConnectionPairId // Set active trace ID
+    const originalTrace = this.tracesMap.get(targetMspConnectionPairId)!
+
+    const { tracePath } = originalTrace
+
+    // Skip if the trace is a perfect rectangle
+    const is4PointRectangle = (path: typeof tracePath): boolean => {
+      if (path.length !== 4) return false
+      const [p0, p1, p2, p3] = path
+      // H-V-H "C" shape
+      const isHVHC =
+        p0.y === p1.y && p1.x === p2.x && p2.y === p3.y && p0.x === p3.x
+      // V-H-V "C" shape
+      const isVHVC =
+        p0.x === p1.x && p1.y === p2.y && p2.x === p3.x && p0.y === p3.y
+      return isHVHC || isVHVC
+    }
+
+    if (is4PointRectangle(tracePath)) {
+      return
+    }
+
+    const allTraces = Array.from(this.tracesMap.values())
+
+    let updatedTrace: SolvedTracePath
+
+    if (this.pipelineStep === "minimizing_turns") {
+      updatedTrace = minimizeTurnsWithFilteredLabels({
+        ...this.input,
+        targetMspConnectionPairId,
+        traces: allTraces,
+      })
+    } else {
+      updatedTrace = balanceZShapes({
+        ...this.input,
+        targetMspConnectionPairId,
+        traces: allTraces,
+      })
+    }
+
+    // Update the state in the central map
+    this.tracesMap.set(targetMspConnectionPairId, updatedTrace)
+
+    // Update the output for visualization
+    this.outputTraces = Array.from(this.tracesMap.values())
+  }
+
+  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: trace.mspPairId === this.activeTraceId ? "red" : "blue", // Highlight active trace
+      }
+      graphics.lines!.push(line)
+    }
+    return graphics
+  }
+}

package/lib/solvers/TraceCleanupSolver/balanceZShapes.ts

@@ -0,0 +1,200 @@
+import type { Point } from "graphics-debug"
+import type { InputProblem } from "lib/types/InputProblem"
+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"
+import type { NetLabelPlacement } from "../NetLabelPlacementSolver/NetLabelPlacementSolver"
+
+export const balanceZShapes = ({
+  targetMspConnectionPairId,
+  traces,
+  inputProblem,
+  allLabelPlacements,
+  mergedLabelNetIdMap,
+  paddingBuffer,
+}: {
+  targetMspConnectionPairId: string
+  traces: SolvedTracePath[]
+  inputProblem: InputProblem
+  allLabelPlacements: NetLabelPlacement[]
+  mergedLabelNetIdMap: Record<string, Set<string>>
+  paddingBuffer: number
+}): SolvedTracePath => {
+  const targetTrace = traces.find(
+    (t) => t.mspPairId === targetMspConnectionPairId,
+  )
+
+  if (!targetTrace) {
+    throw new Error(`Target trace ${targetMspConnectionPairId} not found`)
+  }
+
+  const TOLERANCE = 1e-5
+
+  const obstacleTraces = traces.filter(
+    (t) => t.mspPairId !== targetMspConnectionPairId,
+  )
+
+  const TRACE_WIDTH = 0.01
+  const traceObstacles = obstacleTraces.flatMap((trace, i) =>
+    trace.tracePath.slice(0, -1).map((p1, pi) => {
+      const p2 = trace.tracePath[pi + 1]!
+      return {
+        chipId: `trace-obstacle-${i}-${pi}`,
+        minX: Math.min(p1.x, p2.x) - TRACE_WIDTH / 2,
+        minY: Math.min(p1.y, p2.y) - TRACE_WIDTH / 2,
+        maxX: Math.max(p1.x, p2.x) + TRACE_WIDTH / 2,
+        maxY: Math.max(p1.y, p2.y) + TRACE_WIDTH / 2,
+      }
+    }),
+  )
+
+  const staticObstacles = getObstacleRects(inputProblem).map((obs) => ({
+    ...obs,
+    minX: obs.minX + TOLERANCE,
+    maxX: obs.maxX - TOLERANCE,
+    minY: obs.minY + TOLERANCE,
+    maxY: obs.maxY - TOLERANCE,
+  }))
+
+  const combinedObstacles = [...staticObstacles, ...traceObstacles]
+
+  const segmentIntersectsAnyRect = (
+    p1: Point,
+    p2: Point,
+    rects: any[],
+  ): boolean => {
+    for (const rect of rects) {
+      if (segmentIntersectsRect(p1, p2, rect)) {
+        return true
+      }
+    }
+    return false
+  }
+
+  const filteredLabels = allLabelPlacements.filter((label) => {
+    const originalNetIds = mergedLabelNetIdMap[label.globalConnNetId]
+    if (originalNetIds) {
+      return !originalNetIds.has(targetTrace.globalConnNetId)
+    }
+    return label.globalConnNetId !== targetTrace.globalConnNetId
+  })
+
+  const labelBounds = 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 newPath = [...targetTrace.tracePath]
+
+  if (newPath.length < 4) {
+    return { ...targetTrace }
+  }
+
+  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, combinedObstacles) ||
+      segmentIntersectsAnyRect(p1New, p2New, combinedObstacles) ||
+      segmentIntersectsAnyRect(p2New, p3, combinedObstacles) ||
+      segmentIntersectsAnyRect(p0, p1New, labelBounds) ||
+      segmentIntersectsAnyRect(p1New, p2New, labelBounds) ||
+      segmentIntersectsAnyRect(p2New, p3, labelBounds)
+
+    if (!collides) {
+      newPath[1] = p1New
+      newPath[2] = p2New
+    }
+
+    return { ...targetTrace, 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, combinedObstacles) ||
+      segmentIntersectsAnyRect(p2New, p3New, combinedObstacles) ||
+      segmentIntersectsAnyRect(p3New, p4, combinedObstacles) ||
+      segmentIntersectsAnyRect(p1, p2New, labelBounds) ||
+      segmentIntersectsAnyRect(p2New, p3New, labelBounds) ||
+      segmentIntersectsAnyRect(p3New, p4, labelBounds)
+
+    if (!collides) {
+      newPath[i + 1] = p2New
+      newPath[i + 2] = p3New
+      i = 0
+    }
+  }
+
+  const finalSimplifiedPath = simplifyPath(newPath)
+  return {
+    ...targetTrace,
+    tracePath: finalSimplifiedPath,
+  }
+}

package/lib/solvers/{TraceLabelOverlapAvoidanceSolver → TraceCleanupSolver}/hasCollisions.ts

@@ -1,5 +1,5 @@
 import type { Point } from "graphics-debug"
-import { segmentIntersectsRect } from "../SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions"
+import { segmentIntersectsRect } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions"
 
 export const hasCollisions = (
   pathSegments: Point[],

package/lib/solvers/{TraceLabelOverlapAvoidanceSolver → TraceCleanupSolver}/hasCollisionsWithLabels.ts

@@ -1,5 +1,5 @@
 import type { Point } from "@tscircuit/math-utils"
-import { segmentIntersectsRect } from "../SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions"
+import { segmentIntersectsRect } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions"
 
 export const hasCollisionsWithLabels = (
   pathSegments: Point[],

package/lib/solvers/TraceCleanupSolver/minimizeTurnsWithFilteredLabels.ts

@@ -0,0 +1,76 @@
+import type { InputProblem } from "lib/types/InputProblem"
+import { minimizeTurns } from "./turnMinimization"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import { getObstacleRects } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/rect"
+import type { NetLabelPlacement } from "../NetLabelPlacementSolver/NetLabelPlacementSolver"
+
+export const minimizeTurnsWithFilteredLabels = ({
+  targetMspConnectionPairId,
+  traces,
+  inputProblem,
+  allLabelPlacements,
+  mergedLabelNetIdMap,
+  paddingBuffer,
+}: {
+  targetMspConnectionPairId: string
+  traces: SolvedTracePath[]
+  inputProblem: InputProblem
+  allLabelPlacements: NetLabelPlacement[]
+  mergedLabelNetIdMap: Record<string, Set<string>>
+  paddingBuffer: number
+}): SolvedTracePath => {
+  const targetTrace = traces.find(
+    (t) => t.mspPairId === targetMspConnectionPairId,
+  )
+  if (!targetTrace) {
+    throw new Error(`Target trace ${targetMspConnectionPairId} not found`)
+  }
+
+  const obstacleTraces = traces.filter(
+    (t) => t.mspPairId !== targetMspConnectionPairId,
+  )
+
+  const TRACE_WIDTH = 0.01
+  const traceObstacles = obstacleTraces.flatMap((trace, i) =>
+    trace.tracePath.slice(0, -1).map((p1, pi) => {
+      const p2 = trace.tracePath[pi + 1]!
+      return {
+        chipId: `trace-obstacle-${i}-${pi}`,
+        minX: Math.min(p1.x, p2.x) - TRACE_WIDTH / 2,
+        minY: Math.min(p1.y, p2.y) - TRACE_WIDTH / 2,
+        maxX: Math.max(p1.x, p2.x) + TRACE_WIDTH / 2,
+        maxY: Math.max(p1.y, p2.y) + TRACE_WIDTH / 2,
+      }
+    }),
+  )
+
+  const staticObstacles = getObstacleRects(inputProblem)
+  const combinedObstacles = [...staticObstacles, ...traceObstacles]
+
+  const originalPath = targetTrace.tracePath
+  const filteredLabels = allLabelPlacements.filter((label) => {
+    const originalNetIds = mergedLabelNetIdMap[label.globalConnNetId]
+    if (originalNetIds) {
+      return !originalNetIds.has(targetTrace.globalConnNetId)
+    }
+    return label.globalConnNetId !== targetTrace.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: combinedObstacles,
+    labelBounds,
+  })
+
+  return {
+    ...targetTrace,
+    tracePath: newPath,
+  }
+}

package/lib/solvers/{TraceLabelOverlapAvoidanceSolver → TraceCleanupSolver}/simplifyPath.ts

@@ -2,7 +2,7 @@ import type { Point } from "graphics-debug"
 import {
   isHorizontal,
   isVertical,
-} from "../SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions"
+} from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions"
 
 export const simplifyPath = (path: Point[]): Point[] => {
   if (path.length < 3) return path

package/lib/solvers/{TraceLabelOverlapAvoidanceSolver → TraceCleanupSolver}/turnMinimization.ts

@@ -105,8 +105,6 @@ export const minimizeTurns = ({
 
           if (!collidesWithObstacles && !collidesWithLabels) {
             const newTurns = countTurns(testPath)
-            const turnsRemoved = stairEndIdx - startIdx - 1
-
             optimizedPath = testPath
             currentTurns = newTurns
             improved = true