feat: implement SameNetTraceMergeSolver for issue #29

lib/solvers/SameNetTraceMergeSolver/SameNetTraceMergeSolver.ts

@@ -0,0 +1,150 @@
+import { BaseSolver } from "../BaseSolver/BaseSolver"
+import type { SolvedTracePath } from "../SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import type { Point } from "@tscircuit/math-utils"
+
+export interface SameNetTraceMergeSolverParams {
+  traces: SolvedTracePath[]
+}
+
+export class SameNetTraceMergeSolver extends BaseSolver {
+  traces: SolvedTracePath[]
+  mergedTraces: SolvedTracePath[] = []
+
+  constructor(params: SameNetTraceMergeSolverParams) {
+    super()
+    this.traces = params.traces
+  }
+
+  override _step() {
+    this.mergedTraces = this.mergeTraces(this.traces)
+    this.solved = true
+  }
+
+  public getOutput() {
+    return {
+      traces: this.mergedTraces,
+    }
+  }
+
+  private mergeTraces(traces: SolvedTracePath[]): SolvedTracePath[] {
+    if (traces.length === 0) return []
+
+    // Group traces by globalConnNetId
+    const netGroups: Record<string, SolvedTracePath[]> = {}
+    for (const trace of traces) {
+      const netId = trace.globalConnNetId
+      if (!netGroups[netId]) {
+        netGroups[netId] = []
+      }
+      netGroups[netId].push(trace)
+    }
+
+    const allMergedTraces: SolvedTracePath[] = []
+
+    for (const netId in netGroups) {
+      const mergedForNet = this.mergeTracesForNet(netGroups[netId])
+      allMergedTraces.push(...mergedForNet)
+    }
+
+    return allMergedTraces
+  }
+
+  private mergeTracesForNet(netTraces: SolvedTracePath[]): SolvedTracePath[] {
+    let currentTraces = [...netTraces]
+    let mergedAny = true
+
+    while (mergedAny) {
+      mergedAny = false
+      const nextTraces: SolvedTracePath[] = []
+      const usedIndices = new Set<number>()
+
+      for (let i = 0; i < currentTraces.length; i++) {
+        if (usedIndices.has(i)) continue
+
+        let mergedTrace = { ...currentTraces[i] }
+        usedIndices.add(i)
+
+        for (let j = 0; j < currentTraces.length; j++) {
+          if (usedIndices.has(j)) continue
+
+          const otherTrace = currentTraces[j]
+          const joinResult = this.tryJoinPaths(mergedTrace.tracePath, otherTrace.tracePath)
+
+          if (joinResult) {
+            mergedTrace.tracePath = joinResult
+            mergedTrace.mspConnectionPairIds = Array.from(
+              new Set([...mergedTrace.mspConnectionPairIds, ...otherTrace.mspConnectionPairIds])
+            )
+            mergedTrace.pinIds = Array.from(
+              new Set([...mergedTrace.pinIds, ...otherTrace.pinIds])
+            )
+            usedIndices.add(j)
+            mergedAny = true
+            // Restart inner loop to try merging more into this trace
+            j = -1 
+          }
+        }
+        nextTraces.push(mergedTrace)
+      }
+      currentTraces = nextTraces
+    }
+
+    // After joining paths, simplify each path by removing collinear points
+    return currentTraces.map(t => ({
+      ...t,
+      tracePath: this.simplifyCollinearPoints(t.tracePath)
+    }))
+  }
+
+  private tryJoinPaths(p1: Point[], p2: Point[]): Point[] | null {
+    const threshold = 0.001
+    const dist = (a: Point, b: Point) => Math.sqrt((a.x - b.x) ** 2 + (a.y - b.y) ** 2)
+
+    // End of p1 to Start of p2
+    if (dist(p1[p1.length - 1], p2[0]) < threshold) {
+      return [...p1, ...p2.slice(1)]
+    }
+    // Start of p1 to End of p2
+    if (dist(p1[0], p2[p2.length - 1]) < threshold) {
+      return [...p2, ...p1.slice(1)]
+    }
+    // End of p1 to End of p2
+    if (dist(p1[p1.length - 1], p2[p2.length - 1]) < threshold) {
+      return [...p1, ...[...p2].reverse().slice(1)]
+    }
+    // Start of p1 to Start of p2
+    if (dist(p1[0], p2[0]) < threshold) {
+      return [...[...p1].reverse(), ...p2.slice(1)]
+    }
+
+    return null
+  }
+
+  private simplifyCollinearPoints(points: Point[]): Point[] {
+    if (points.length <= 2) return points
+
+    const simplified: Point[] = [points[0]]
+    const threshold = 0.001
+
+    for (let i = 1; i < points.length - 1; i++) {
+      const prev = simplified[simplified.length - 1]
+      const curr = points[i]
+      const next = points[i + 1]
+
+      const isCollinear = this.areCollinear(prev, curr, next, threshold)
+      if (!isCollinear) {
+        simplified.push(curr)
+      }
+    }
+
+    simplified.push(points[points.length - 1])
+    return simplified
+  }
+
+  private areCollinear(p1: Point, p2: Point, p3: Point, threshold: number): boolean {
+    // Area of triangle = 0.5 * |x1(y2-y3) + x2(y3-y1) + x3(y1-y2)|
+    // Using area / distance as a measure of collinearity
+    const area = Math.abs(p1.x * (p2.y - p3.y) + p2.x * (p3.y - p1.y) + p3.x * (p1.y - p2.y))
+    return area < threshold
+  }
+}

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>
@@ -188,9 +190,21 @@ export class SchematicTracePipelineSolver extends BaseSolver {
         ]
       },
     ),
+    definePipelineStep(
+      "sameNetTraceMergeSolver",
+      SameNetTraceMergeSolver,
+      (instance) => {
+        const prevSolverOutput =
+          instance.traceLabelOverlapAvoidanceSolver!.getOutput()
+        return [
+          {
+            traces: prevSolverOutput.traces,
+          },
+        ]
+      },
+    ),
     definePipelineStep("traceCleanupSolver", TraceCleanupSolver, (instance) => {
-      const prevSolverOutput =
-        instance.traceLabelOverlapAvoidanceSolver!.getOutput()
+      const prevSolverOutput = instance.sameNetTraceMergeSolver!.getOutput()
       const traces = prevSolverOutput.traces
 
       const labelMergingOutput =

lib/solvers/TraceCleanupSolver/TraceCleanupSolver.ts

@@ -6,6 +6,8 @@ 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"
+import { mergeSameNetSegments } from "./mergeSameNetSegments"
+import { simplifyPath } from "./simplifyPath"
 
 /**
  * Defines the input structure for the TraceCleanupSolver.
@@ -26,6 +28,7 @@ import { is4PointRectangle } from "./is4PointRectangle"
  */
 type PipelineStep =
   | "minimizing_turns"
+  | "merging_collinear_segments"
   | "balancing_l_shapes"
   | "untangling_traces"
 
@@ -81,6 +84,9 @@ export class TraceCleanupSolver extends BaseSolver {
       case "minimizing_turns":
         this._runMinimizeTurnsStep()
         break
+      case "merging_collinear_segments":
+        this._runMergeCollinearSegmentsStep()
+        break
       case "balancing_l_shapes":
         this._runBalanceLShapesStep()
         break
@@ -96,16 +102,28 @@ export class TraceCleanupSolver extends BaseSolver {
 
   private _runMinimizeTurnsStep() {
     if (this.traceIdQueue.length === 0) {
-      this.pipelineStep = "balancing_l_shapes"
-      this.traceIdQueue = Array.from(
-        this.input.allTraces.map((e) => e.mspPairId),
-      )
+      this.pipelineStep = "merging_collinear_segments"
       return
     }
 
     this._processTrace("minimizing_turns")
   }
 
+  private _runMergeCollinearSegmentsStep() {
+    this.outputTraces = mergeSameNetSegments(this.outputTraces)
+
+    // Simplify paths after merging to remove redundant points
+    for (const trace of this.outputTraces) {
+      trace.tracePath = simplifyPath(trace.tracePath)
+    }
+
+    this.tracesMap = new Map(this.outputTraces.map((t) => [t.mspPairId, t]))
+    this.pipelineStep = "balancing_l_shapes"
+    this.traceIdQueue = Array.from(
+      this.input.allTraces.map((e) => e.mspPairId),
+    )
+  }
+
   private _runBalanceLShapesStep() {
     if (this.traceIdQueue.length === 0) {
       this.solved = true

lib/solvers/TraceCleanupSolver/mergeSameNetSegments.ts

@@ -0,0 +1,114 @@
+import type { Point } from "@tscircuit/math-utils"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import { isHorizontal, isVertical } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions"
+
+const MERGE_THRESHOLD = 0.01 // Threshold for collinearity and gap merging
+
+interface Segment {
+  p1: Point
+  p2: Point
+  traceId: string
+}
+
+/**
+ * Merges collinear segments belonging to the same net.
+ * This function processes all traces together, grouping them by their global connection net ID.
+ */
+export const mergeSameNetSegments = (traces: SolvedTracePath[]): SolvedTracePath[] => {
+  // 1. Group traces by globalConnNetId
+  const netGroups = new Map<string, SolvedTracePath[]>()
+  for (const trace of traces) {
+    const netId = trace.globalConnNetId || "unknown"
+    if (!netGroups.has(netId)) netGroups.set(netId, [])
+    netGroups.get(netId)!.push(trace)
+  }
+
+  const updatedTracesMap = new Map<string, SolvedTracePath>(traces.map(t => [t.mspPairId, t]))
+
+  for (const [netId, netTraces] of netGroups.entries()) {
+    if (netId === "unknown") continue
+
+    // 2. Extract segments
+    const hSegments: Segment[] = []
+    const vSegments: Segment[] = []
+
+    for (const trace of netTraces) {
+      for (let i = 0; i < trace.tracePath.length - 1; i++) {
+        const p1 = trace.tracePath[i]
+        const p2 = trace.tracePath[i + 1]
+
+        if (isHorizontal(p1, p2)) {
+          hSegments.push({ 
+            p1: p1.x < p2.x ? p1 : p2, 
+            p2: p1.x < p2.x ? p2 : p1, 
+            traceId: trace.mspPairId 
+          })
+        } else if (isVertical(p1, p2)) {
+          vSegments.push({ 
+            p1: p1.y < p2.y ? p1 : p2, 
+            p2: p1.y < p2.y ? p2 : p1, 
+            traceId: trace.mspPairId 
+          })
+        }
+      }
+    }
+
+    // 3. Merge Horizontal Segments
+    const mergedHSegments = mergeSegmentGroups(hSegments, "y", "x")
+    // 4. Merge Vertical Segments
+    const mergedVSegments = mergeSegmentGroups(vSegments, "x", "y")
+
+    // 5. Update Traces
+    // For now, simpler approach: update each trace by merging its OWN segments that are now collinear
+    // and removing redundant ones if they overlap exactly with other traces' segments.
+    // However, the bounty asks to "merge across different traces".
+    // This usually means if Trace A and Trace B share a corridor, they should be aligned.
+
+    // Implementation note: A full re-routing is complex. We will perform "coordinate alignment" 
+    // where segments nearly on the same line are snapped to the same coordinate.
+
+    applyAveragedCoordinates(netTraces, mergedHSegments, "y")
+    applyAveragedCoordinates(netTraces, mergedVSegments, "x")
+  }
+
+  return Array.from(updatedTracesMap.values())
+}
+
+function mergeSegmentGroups(segments: Segment[], constAxis: "x" | "y", varAxis: "x" | "y"): Map<number, Segment[]> {
+  const groups = new Map<number, Segment[]>()
+
+  for (const seg of segments) {
+    const val = seg.p1[constAxis]
+    let foundGroup = false
+    for (const groupVal of groups.keys()) {
+      if (Math.abs(groupVal - val) < MERGE_THRESHOLD) {
+        groups.get(groupVal)!.push(seg)
+        foundGroup = true
+        break
+      }
+    }
+    if (!foundGroup) {
+      groups.set(val, [seg])
+    }
+  }
+
+  return groups
+}
+
+function applyAveragedCoordinates(traces: SolvedTracePath[], groups: Map<number, Segment[]>, constAxis: "x" | "y") {
+  for (const [avgVal, segments] of groups.entries()) {
+    const sum = segments.reduce((acc, s) => acc + s.p1[constAxis], 0)
+    const targetVal = sum / segments.length
+
+    for (const seg of segments) {
+      const trace = traces.find(t => t.mspPairId === seg.traceId)
+      if (!trace) continue
+
+      for (const p of trace.tracePath) {
+        if (Math.abs(p[constAxis] - avgVal) < MERGE_THRESHOLD) {
+          p[constAxis] = targetVal
+        }
+      }
+    }
+  }
+}