feat: implement TraceCombineSolver pipeline phase to merge close same-net segments

lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver.ts

@@ -12,6 +12,7 @@ import {
   type SolvedTracePath,
 } from "../SchematicTraceLinesSolver/SchematicTraceLinesSolver"
 import { TraceOverlapShiftSolver } from "../TraceOverlapShiftSolver/TraceOverlapShiftSolver"
+import { TraceCombineSolver } from "../TraceCombineSolver/TraceCombineSolver"
 import { NetLabelPlacementSolver } from "../NetLabelPlacementSolver/NetLabelPlacementSolver"
 import { colorAvailableNetOrientationLabels } from "./colorAvailableNetOrientationLabels"
 import { visualizeInputProblem } from "./visualizeInputProblem"
@@ -71,6 +72,7 @@ export class SchematicTracePipelineSolver extends BaseSolver {
   schematicTraceLinesSolver?: SchematicTraceLinesSolver
   longDistancePairSolver?: LongDistancePairSolver
   traceOverlapShiftSolver?: TraceOverlapShiftSolver
+  traceCombineSolver?: TraceCombineSolver
   netLabelPlacementSolver?: NetLabelPlacementSolver
   labelMergingSolver?: MergedNetLabelObstacleSolver
   traceLabelOverlapAvoidanceSolver?: TraceLabelOverlapAvoidanceSolver
@@ -154,19 +156,21 @@ export class SchematicTracePipelineSolver extends BaseSolver {
         onSolved: (_solver) => {},
       },
     ),
+    definePipelineStep("traceCombineSolver", TraceCombineSolver, () => [
+      {
+        inputProblem: this.inputProblem,
+        inputTracePaths: Object.values(
+          this.traceOverlapShiftSolver!.correctedTraceMap,
+        ),
+      },
+    ]),
     definePipelineStep(
       "netLabelPlacementSolver",
       NetLabelPlacementSolver,
       () => [
         {
           inputProblem: this.inputProblem,
-          inputTraceMap:
-            this.traceOverlapShiftSolver?.correctedTraceMap ??
-            Object.fromEntries(
-              this.longDistancePairSolver!.getOutput().allTracesMerged.map(
-                (p) => [p.mspPairId, p],
-              ),
-            ),
+          inputTraceMap: this.getRoutedTraceMap(),
         },
       ],
       {
@@ -179,13 +183,7 @@ export class SchematicTracePipelineSolver extends BaseSolver {
       "traceLabelOverlapAvoidanceSolver",
       TraceLabelOverlapAvoidanceSolver,
       (instance) => {
-        const traceMap =
-          instance.traceOverlapShiftSolver?.correctedTraceMap ??
-          Object.fromEntries(
-            instance
-              .longDistancePairSolver!.getOutput()
-              .allTracesMerged.map((p) => [p.mspPairId, p]),
-          )
+        const traceMap = instance.getRoutedTraceMap()
         const traces = Object.values(traceMap)
         const netLabelPlacements =
           instance.netLabelPlacementSolver!.netLabelPlacements
@@ -320,6 +318,21 @@ export class SchematicTracePipelineSolver extends BaseSolver {
 
   currentPipelineStepIndex = 0
 
+  getRoutedTraceMap(): Record<string, SolvedTracePath> {
+    if (this.traceCombineSolver) {
+      return this.traceCombineSolver.correctedTraceMap
+    }
+    if (this.traceOverlapShiftSolver) {
+      return this.traceOverlapShiftSolver.correctedTraceMap
+    }
+    return Object.fromEntries(
+      this.longDistancePairSolver!.getOutput().allTracesMerged.map((p) => [
+        p.mspPairId,
+        p,
+      ]),
+    )
+  }
+
   private cloneAndCorrectInputProblem(original: InputProblem): InputProblem {
     const cloned: InputProblem = structuredClone({
       ...original,

lib/solvers/TraceCombineSolver/TraceCombineSolver.ts

@@ -0,0 +1,76 @@
+import { BaseSolver } from "lib/solvers/BaseSolver/BaseSolver"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import type { MspConnectionPairId } from "lib/solvers/MspConnectionPairSolver/MspConnectionPairSolver"
+import { visualizeInputProblem } from "lib/solvers/SchematicTracePipelineSolver/visualizeInputProblem"
+import type { InputProblem } from "lib/types/InputProblem"
+import {
+  combineSameNetTraceSegments,
+  DEFAULT_COMBINE_DISTANCE,
+} from "./combineSameNetTraceSegments"
+
+/**
+ * Pipeline phase that combines nearby parallel trace segments on the same net
+ * by snapping them to a shared X or Y coordinate.
+ */
+export class TraceCombineSolver extends BaseSolver {
+  inputProblem: InputProblem
+  inputTracePaths: SolvedTracePath[]
+  combineDistance: number
+
+  correctedTraceMap: Record<MspConnectionPairId, SolvedTracePath> = {}
+
+  constructor(params: {
+    inputProblem: InputProblem
+    inputTracePaths: SolvedTracePath[]
+    combineDistance?: number
+  }) {
+    super()
+    this.inputProblem = params.inputProblem
+    this.inputTracePaths = params.inputTracePaths
+    this.combineDistance = params.combineDistance ?? DEFAULT_COMBINE_DISTANCE
+
+    for (const tracePath of this.inputTracePaths) {
+      this.correctedTraceMap[tracePath.mspPairId] = tracePath
+    }
+  }
+
+  override getConstructorParams(): ConstructorParameters<
+    typeof TraceCombineSolver
+  >[0] {
+    return {
+      inputProblem: this.inputProblem,
+      inputTracePaths: this.inputTracePaths,
+      combineDistance: this.combineDistance,
+    }
+  }
+
+  override _step() {
+    const combined = combineSameNetTraceSegments(
+      this.inputTracePaths,
+      this.combineDistance,
+    )
+
+    this.correctedTraceMap = Object.fromEntries(
+      combined.map((trace) => [trace.mspPairId, trace]),
+    )
+    this.solved = true
+  }
+
+  getOutput(): { traces: SolvedTracePath[] } {
+    return { traces: Object.values(this.correctedTraceMap) }
+  }
+
+  override visualize() {
+    const graphics = visualizeInputProblem(this.inputProblem)
+    graphics.lines = graphics.lines || []
+
+    for (const trace of Object.values(this.correctedTraceMap)) {
+      graphics.lines.push({
+        points: trace.tracePath,
+        strokeColor: "teal",
+      })
+    }
+
+    return graphics
+  }
+}