feat: add SameNetTraceMergeSolver to combine close same-net trace segments

Adds a new pipeline phase that identifies same-net trace segments running
in parallel within a small gap threshold (0.15 units) and merges them by
averaging their fixed coordinate. This reduces visual clutter where the
MSP tree creates multiple nearby parallel wires for the same electrical net.

The solver runs after TraceCleanupSolver in the pipeline, before the final
NetLabelPlacementSolver pass.

Fixes #29

Author: Francisco

lib/solvers/SameNetTraceMergeSolver/SameNetTraceMergeSolver.ts

@@ -0,0 +1,204 @@
+import { BaseSolver } from "lib/solvers/BaseSolver/BaseSolver"
+import type { InputProblem } from "lib/types/InputProblem"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import type { GraphicsObject, Line } from "graphics-debug"
+import { visualizeInputProblem } from "lib/solvers/SchematicTracePipelineSolver/visualizeInputProblem"
+import type { Point } from "@tscircuit/math-utils"
+
+/**
+ * The gap threshold (in schematic units) within which two parallel same-net
+ * segments are considered "close enough" to merge.
+ */
+const GAP_THRESHOLD = 0.15
+
+interface SameNetTraceMergeSolverInput {
+  inputProblem: InputProblem
+  allTraces: SolvedTracePath[]
+}
+
+interface Segment {
+  traceIndex: number
+  segIndex: number
+  p1: Point
+  p2: Point
+  orientation: "horizontal" | "vertical"
+  /** The fixed coordinate (y for horizontal, x for vertical) */
+  fixedCoord: number
+  /** min and max of the varying coordinate */
+  rangeMin: number
+  rangeMax: number
+}
+
+/**
+ * Pipeline phase that finds same-net trace segments running close together
+ * (parallel, within GAP_THRESHOLD) and merges them into a single averaged
+ * segment.  This reduces visual clutter where the MSP tree creates multiple
+ * nearby parallel wires for the same electrical net.
+ *
+ * Runs after TraceCleanupSolver in the pipeline.
+ */
+export class SameNetTraceMergeSolver extends BaseSolver {
+  private input: SameNetTraceMergeSolverInput
+  private outputTraces: SolvedTracePath[]
+  private processed = false
+
+  constructor(solverInput: SameNetTraceMergeSolverInput) {
+    super()
+    this.input = solverInput
+    this.outputTraces = solverInput.allTraces.map((t) => ({
+      ...t,
+      tracePath: [...t.tracePath],
+    }))
+  }
+
+  override _step() {
+    if (this.processed) {
+      this.solved = true
+      return
+    }
+    this.processed = true
+
+    // Group traces by globalConnNetId (same electrical net)
+    const netGroups = new Map<string, number[]>()
+    for (let i = 0; i < this.outputTraces.length; i++) {
+      const trace = this.outputTraces[i]
+      const netId = trace.globalConnNetId
+      if (!netGroups.has(netId)) {
+        netGroups.set(netId, [])
+      }
+      netGroups.get(netId)!.push(i)
+    }
+
+    // For each net group with more than one trace, try to merge close segments
+    for (const [_netId, traceIndices] of netGroups) {
+      if (traceIndices.length < 2) continue
+      this.mergeCloseSegmentsInGroup(traceIndices)
+    }
+
+    this.solved = true
+  }
+
+  private mergeCloseSegmentsInGroup(traceIndices: number[]) {
+    // Extract all orthogonal segments from the traces in this group
+    const segments: Segment[] = []
+
+    for (const traceIdx of traceIndices) {
+      const path = this.outputTraces[traceIdx].tracePath
+      for (let s = 0; s < path.length - 1; s++) {
+        const p1 = path[s]
+        const p2 = path[s + 1]
+        const dx = Math.abs(p2.x - p1.x)
+        const dy = Math.abs(p2.y - p1.y)
+
+        if (dx < 1e-9 && dy < 1e-9) continue // zero-length segment
+
+        if (dy < 1e-9) {
+          // Horizontal segment
+          segments.push({
+            traceIndex: traceIdx,
+            segIndex: s,
+            p1,
+            p2,
+            orientation: "horizontal",
+            fixedCoord: p1.y,
+            rangeMin: Math.min(p1.x, p2.x),
+            rangeMax: Math.max(p1.x, p2.x),
+          })
+        } else if (dx < 1e-9) {
+          // Vertical segment
+          segments.push({
+            traceIndex: traceIdx,
+            segIndex: s,
+            p1,
+            p2,
+            orientation: "vertical",
+            fixedCoord: p1.x,
+            rangeMin: Math.min(p1.y, p2.y),
+            rangeMax: Math.max(p1.y, p2.y),
+          })
+        }
+        // Diagonal segments are ignored
+      }
+    }
+
+    // Find pairs of segments that are close and overlapping in range
+    const merged = new Set<string>() // "traceIndex:segIndex" keys already merged
+
+    for (let i = 0; i < segments.length; i++) {
+      for (let j = i + 1; j < segments.length; j++) {
+        const a = segments[i]
+        const b = segments[j]
+
+        // Must be same orientation, different traces
+        if (a.orientation !== b.orientation) continue
+        if (a.traceIndex === b.traceIndex) continue
+
+        const gap = Math.abs(a.fixedCoord - b.fixedCoord)
+        if (gap > GAP_THRESHOLD) continue
+        if (gap < 1e-9) continue // already coincident, no merge needed
+
+        // Check that their ranges overlap
+        const overlapMin = Math.max(a.rangeMin, b.rangeMin)
+        const overlapMax = Math.min(a.rangeMax, b.rangeMax)
+        if (overlapMax - overlapMin < 1e-9) continue // no meaningful overlap
+
+        const keyA = `${a.traceIndex}:${a.segIndex}`
+        const keyB = `${b.traceIndex}:${b.segIndex}`
+        if (merged.has(keyA) || merged.has(keyB)) continue
+
+        // Merge: average the fixed coordinate on both segments
+        const avgCoord = (a.fixedCoord + b.fixedCoord) / 2
+
+        this.shiftSegmentFixedCoord(a, avgCoord)
+        this.shiftSegmentFixedCoord(b, avgCoord)
+
+        merged.add(keyA)
+        merged.add(keyB)
+      }
+    }
+  }
+
+  /**
+   * Shifts a segment's fixed coordinate to a new value, updating the trace
+   * path points in place.  Also updates the adjacent points so that the path
+   * remains connected (perpendicular legs stretch/shrink).
+   */
+  private shiftSegmentFixedCoord(seg: Segment, newFixedCoord: number) {
+    const path = this.outputTraces[seg.traceIndex].tracePath
+    const s = seg.segIndex
+
+    if (seg.orientation === "horizontal") {
+      // Shift y of both endpoints
+      path[s] = { x: path[s].x, y: newFixedCoord }
+      path[s + 1] = { x: path[s + 1].x, y: newFixedCoord }
+    } else {
+      // Shift x of both endpoints
+      path[s] = { x: newFixedCoord, y: path[s].y }
+      path[s + 1] = { x: newFixedCoord, y: path[s + 1].y }
+    }
+  }
+
+  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 = []
+
+    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
+  }
+}

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 { SameNetTraceMergeSolver } from "../SameNetTraceMergeSolver/SameNetTraceMergeSolver"
 
 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
+  sameNetTraceMergeSolver?: SameNetTraceMergeSolver
 
   startTimeOfPhase: Record<string, number>
   endTimeOfPhase: Record<string, number>
@@ -206,11 +208,27 @@ export class SchematicTracePipelineSolver extends BaseSolver {
         },
       ]
     }),
+    definePipelineStep(
+      "sameNetTraceMergeSolver",
+      SameNetTraceMergeSolver,
+      (instance) => {
+        const traces =
+          instance.traceCleanupSolver?.getOutput().traces ??
+          instance.traceLabelOverlapAvoidanceSolver!.getOutput().traces
+        return [
+          {
+            inputProblem: instance.inputProblem,
+            allTraces: traces,
+          },
+        ]
+      },
+    ),
     definePipelineStep(
       "netLabelPlacementSolver",
       NetLabelPlacementSolver,
       (instance) => {
         const traces =
+          instance.sameNetTraceMergeSolver?.getOutput().traces ??
           instance.traceCleanupSolver?.getOutput().traces ??
           instance.traceLabelOverlapAvoidanceSolver!.getOutput().traces