@tscircuit/schematic-trace-solver 0.0.96 → 0.0.98

package/lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/SchematicTraceSingleLineSolver2.ts

@@ -1,24 +1,29 @@
+import type { Point } from "@tscircuit/math-utils"
+import { calculateElbow } from "calculate-elbow"
 import type { GraphicsObject } from "graphics-debug"
-import { visualizeInputProblem } from "lib/solvers/SchematicTracePipelineSolver/visualizeInputProblem"
 import { BaseSolver } from "lib/solvers/BaseSolver/BaseSolver"
 import type { MspConnectionPair } from "lib/solvers/MspConnectionPairSolver/MspConnectionPairSolver"
-import type { InputChip, InputProblem, PinId } from "lib/types/InputProblem"
-import type { Point } from "@tscircuit/math-utils"
-import { calculateElbow } from "calculate-elbow"
+import { getDimsForOrientation } from "lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/geometry"
+import { visualizeInputProblem } from "lib/solvers/SchematicTracePipelineSolver/visualizeInputProblem"
+import type { InputChip, InputProblem } from "lib/types/InputProblem"
+import type { FacingDirection } from "lib/utils/dir"
+import type { RectPadding } from "lib/utils/textBoxBounds"
 import { getPinDirection } from "../SchematicTraceSingleLineSolver/getPinDirection"
-import { getObstacleRects, type ObstacleRect } from "./rect"
-import { findFirstCollision, isHorizontal, isVertical } from "./collisions"
+import { calculateDirectShortPath } from "./calculateDirectShortPath"
 import {
+  findFirstCollision,
+  isHorizontal,
+  isVertical,
+  segmentOverlapsRectBoundary,
+} from "./collisions"
+import {
+  type Axis,
   aabbFromPoints,
   candidateMidsFromSet,
   midBetweenPointAndRect,
-  type Axis,
 } from "./mid"
 import { pathKey, shiftSegmentOrth } from "./pathOps"
-import type { FacingDirection } from "lib/utils/dir"
-import { getDimsForOrientation } from "lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/geometry"
-import type { RectPadding } from "lib/utils/textBoxBounds"
-import { calculateDirectShortPath } from "./calculateDirectShortPath"
+import { getObstacleRects, type ObstacleRect } from "./rect"
 
 type PathKey = string
 
@@ -268,9 +273,42 @@ export class SchematicTraceSingleLineSolver2 extends BaseSolver {
     const collision = findFirstCollision(path, this.obstacles, {
       excludeRectsForSegment: (segIndex) => {
         const lastSegIndex = path.length - 2
+        const excludedRects = new Set<ObstacleRect>()
+
         if (segIndex === 0 || segIndex === lastSegIndex) {
-          return this.textObstacles
+          for (const textObstacle of this.textObstacles) {
+            excludedRects.add(textObstacle)
+          }
         }
+
+        const segmentStart = path[segIndex]!
+        const segmentEnd = path[segIndex + 1]!
+        const endpointEpsilon = 1e-9
+        const segmentTouchesPin = (pin: MspConnectionPair["pins"][number]) =>
+          [segmentStart, segmentEnd].some(
+            (point) =>
+              Math.abs(point.x - pin.x) <= endpointEpsilon &&
+              Math.abs(point.y - pin.y) <= endpointEpsilon,
+          )
+
+        for (const pin of this.pins) {
+          if (!segmentTouchesPin(pin)) continue
+          const endpointChipObstacle = this.obstacles.find(
+            (obstacle) =>
+              obstacle.kind === "chip" && obstacle.chipId === pin.chipId,
+          )
+          if (
+            endpointChipObstacle &&
+            segmentOverlapsRectBoundary(
+              segmentStart,
+              segmentEnd,
+              endpointChipObstacle,
+            )
+          ) {
+            excludedRects.add(endpointChipObstacle)
+          }
+        }
+
         const adjacentEndpointSegIndex =
           segIndex === 1
             ? 2
@@ -286,9 +324,12 @@ export class SchematicTraceSingleLineSolver2 extends BaseSolver {
             path[adjacentEndpointSegIndex + 1]!,
           )
         ) {
-          return this.endpointTextObstacles
+          for (const textObstacle of this.endpointTextObstacles) {
+            excludedRects.add(textObstacle)
+          }
         }
-        return new Set<ObstacleRect>()
+
+        return excludedRects
       },
     })
 

package/lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions.ts

@@ -35,6 +35,37 @@ export const segmentIntersectsRect = <TRect extends RectBounds>(
   }
 }
 
+export const segmentOverlapsRectBoundary = <TRect extends RectBounds>(
+  a: Point,
+  b: Point,
+  r: TRect,
+  eps = EPS,
+): boolean => {
+  if (isVertical(a, b, eps)) {
+    const onVerticalBoundary =
+      Math.abs(a.x - r.minX) <= eps || Math.abs(a.x - r.maxX) <= eps
+    if (!onVerticalBoundary) return false
+
+    const overlap =
+      Math.min(Math.max(a.y, b.y), r.maxY) -
+      Math.max(Math.min(a.y, b.y), r.minY)
+    return overlap > eps
+  }
+
+  if (isHorizontal(a, b, eps)) {
+    const onHorizontalBoundary =
+      Math.abs(a.y - r.minY) <= eps || Math.abs(a.y - r.maxY) <= eps
+    if (!onHorizontalBoundary) return false
+
+    const overlap =
+      Math.min(Math.max(a.x, b.x), r.maxX) -
+      Math.max(Math.min(a.x, b.x), r.minX)
+    return overlap > eps
+  }
+
+  return false
+}
+
 export const findFirstCollision = <TRect extends RectBounds>(
   pts: Point[],
   rects: TRect[],

package/lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver.ts

@@ -79,7 +79,9 @@ export class SchematicTracePipelineSolver extends BaseSolver {
   availableNetOrientationSolver?: AvailableNetOrientationSolver
   railNetLabelCornerPlacementSolver?: RailNetLabelCornerPlacementSolver
   traceAnchoredNetLabelOverlapSolver?: TraceAnchoredNetLabelOverlapSolver
+  preAlignmentNetLabelTraceCollisionSolver?: NetLabelTraceCollisionSolver
   netLabelTraceCollisionSolver?: NetLabelTraceCollisionSolver
+  traceCleanupSolver2?: TraceCleanupSolver
   netLabelNetLabelCollisionSolver?: NetLabelNetLabelCollisionSolver
 
   startTimeOfPhase: Record<string, number>
@@ -291,7 +293,7 @@ export class SchematicTracePipelineSolver extends BaseSolver {
       ],
     ),
     definePipelineStep(
-      "netLabelTraceCollisionSolver",
+      "preAlignmentNetLabelTraceCollisionSolver",
       NetLabelTraceCollisionSolver,
       (instance) => [
         {
@@ -303,6 +305,48 @@ export class SchematicTracePipelineSolver extends BaseSolver {
         },
       ],
     ),
+    definePipelineStep(
+      "traceCleanupSolver2",
+      TraceCleanupSolver,
+      (instance) => {
+        const collisionOutput =
+          instance.preAlignmentNetLabelTraceCollisionSolver!.getOutput()
+        const labelMergingOutput =
+          instance.traceLabelOverlapAvoidanceSolver!.labelMergingSolver!.getOutput()
+
+        return [
+          {
+            inputProblem: instance.inputProblem,
+            allTraces: collisionOutput.traces,
+            allLabelPlacements: collisionOutput.netLabelPlacements,
+            mergedLabelNetIdMap: labelMergingOutput.mergedLabelNetIdMap,
+            paddingBuffer: 0.1,
+            operations: ["aligning_same_net_rails"],
+            eligibleTraceIds: new Set(
+              instance
+                .traceCleanupSolver!.getOutput()
+                .traces.map((trace) => trace.mspPairId),
+            ),
+          },
+        ]
+      },
+    ),
+    definePipelineStep(
+      "netLabelTraceCollisionSolver",
+      NetLabelTraceCollisionSolver,
+      (instance) => {
+        const previousCollisionOutput =
+          instance.preAlignmentNetLabelTraceCollisionSolver!.getOutput()
+
+        return [
+          {
+            inputProblem: instance.inputProblem,
+            traces: instance.traceCleanupSolver2!.getOutput().traces,
+            netLabelPlacements: previousCollisionOutput.netLabelPlacements,
+          },
+        ]
+      },
+    ),
     definePipelineStep(
       "netLabelNetLabelCollisionSolver",
       NetLabelNetLabelCollisionSolver,

package/lib/solvers/TraceCleanupSolver/TraceCleanupSolver.ts

@@ -6,16 +6,25 @@ 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 { alignSameNetRails } from "./alignSameNetRails"
+
+export type TraceCleanupOperation =
+  | "untangling_traces"
+  | "minimizing_turns"
+  | "balancing_l_shapes"
+  | "aligning_same_net_rails"
 
 /**
  * Defines the input structure for the TraceCleanupSolver.
  */
-interface TraceCleanupSolverInput {
+export interface TraceCleanupSolverInput {
   inputProblem: InputProblem
   allTraces: SolvedTracePath[]
   allLabelPlacements: NetLabelPlacement[]
   mergedLabelNetIdMap: Record<string, Set<string>>
   paddingBuffer: number
+  operations?: readonly TraceCleanupOperation[]
+  eligibleTraceIds?: ReadonlySet<string>
 }
 
 import { UntangleTraceSubsolver } from "./sub-solver/UntangleTraceSubsolver"
@@ -24,10 +33,11 @@ import { is4PointRectangle } from "./is4PointRectangle"
 /**
  * Represents the different stages or steps within the trace cleanup pipeline.
  */
-type PipelineStep =
-  | "minimizing_turns"
-  | "balancing_l_shapes"
-  | "untangling_traces"
+const DEFAULT_OPERATIONS: readonly TraceCleanupOperation[] = [
+  "untangling_traces",
+  "minimizing_turns",
+  "balancing_l_shapes",
+]
 
 /**
  * The TraceCleanupSolver is responsible for improving the aesthetics and readability of schematic traces.
@@ -42,7 +52,9 @@ export class TraceCleanupSolver extends BaseSolver {
   private outputTraces: SolvedTracePath[]
   private traceIdQueue: string[]
   private tracesMap: Map<string, SolvedTracePath>
-  private pipelineStep: PipelineStep = "untangling_traces"
+  private operations: readonly TraceCleanupOperation[]
+  private operationIndex = 0
+  private pipelineStep: TraceCleanupOperation | null
   private activeTraceId: string | null = null // New property
   override activeSubSolver: BaseSolver | null = null
 
@@ -51,6 +63,8 @@ export class TraceCleanupSolver extends BaseSolver {
     this.input = solverInput
     this.outputTraces = [...solverInput.allTraces]
     this.tracesMap = new Map(this.outputTraces.map((t) => [t.mspPairId, t]))
+    this.operations = solverInput.operations ?? DEFAULT_OPERATIONS
+    this.pipelineStep = this.operations[0] ?? null
     this.traceIdQueue = Array.from(
       solverInput.allTraces.map((e) => e.mspPairId),
     )
@@ -66,14 +80,19 @@ export class TraceCleanupSolver extends BaseSolver {
         this.outputTraces = output.traces
         this.tracesMap = new Map(this.outputTraces.map((t) => [t.mspPairId, t]))
         this.activeSubSolver = null
-        this.pipelineStep = "minimizing_turns"
+        this._advancePipeline()
       } else if (this.activeSubSolver.failed) {
         this.activeSubSolver = null
-        this.pipelineStep = "minimizing_turns"
+        this._advancePipeline()
       }
       return
     }
 
+    if (!this.pipelineStep) {
+      this.solved = true
+      return
+    }
+
     switch (this.pipelineStep) {
       case "untangling_traces":
         this._runUntangleTracesStep()
@@ -84,9 +103,19 @@ export class TraceCleanupSolver extends BaseSolver {
       case "balancing_l_shapes":
         this._runBalanceLShapesStep()
         break
+      case "aligning_same_net_rails":
+        this._runAlignSameNetRailsStep()
+        break
     }
   }
 
+  private _advancePipeline() {
+    this.operationIndex++
+    this.pipelineStep = this.operations[this.operationIndex] ?? null
+    this.traceIdQueue = this.outputTraces.map((trace) => trace.mspPairId)
+    if (this.pipelineStep) this.activeTraceId = null
+  }
+
   private _runUntangleTracesStep() {
     this.activeSubSolver = new UntangleTraceSubsolver({
       ...this.input,
@@ -96,10 +125,7 @@ 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._advancePipeline()
       return
     }
 
@@ -108,7 +134,7 @@ export class TraceCleanupSolver extends BaseSolver {
 
   private _runBalanceLShapesStep() {
     if (this.traceIdQueue.length === 0) {
-      this.solved = true
+      this._advancePipeline()
       return
     }
 
@@ -146,6 +172,22 @@ export class TraceCleanupSolver extends BaseSolver {
     this.outputTraces = Array.from(this.tracesMap.values())
   }
 
+  private _runAlignSameNetRailsStep() {
+    const alignment = alignSameNetRails({
+      inputProblem: this.input.inputProblem,
+      traces: this.outputTraces,
+      netLabelPlacements: this.input.allLabelPlacements,
+      eligibleTraceIds:
+        this.input.eligibleTraceIds ??
+        new Set(this.outputTraces.map((trace) => trace.mspPairId)),
+    })
+    this.outputTraces = alignment.traces
+    this.tracesMap = new Map(this.outputTraces.map((t) => [t.mspPairId, t]))
+    this.stats.alignedRailGroupCount = alignment.alignedRailGroupCount
+    this.stats.alignedTraceCount = alignment.alignedTraceCount
+    this._advancePipeline()
+  }
+
   getOutput() {
     return {
       traces: this.outputTraces,

package/lib/solvers/TraceCleanupSolver/alignSameNetRails.ts

@@ -0,0 +1,66 @@
+import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import { getObstacleRects } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/rect"
+import type { InputProblem } from "lib/types/InputProblem"
+import { evaluateRailGroup } from "./sameNetRailAlignment/evaluateRailGroup"
+import { getRailGroups } from "./sameNetRailAlignment/getRailGroups"
+import type { AlignmentCandidate } from "./sameNetRailAlignment/types"
+
+interface AlignSameNetRailsInput {
+  inputProblem: InputProblem
+  traces: SolvedTracePath[]
+  netLabelPlacements: NetLabelPlacement[]
+  eligibleTraceIds: ReadonlySet<string>
+}
+
+export const alignSameNetRails = ({
+  inputProblem,
+  traces,
+  netLabelPlacements,
+  eligibleTraceIds,
+}: AlignSameNetRailsInput): {
+  traces: SolvedTracePath[]
+  alignedRailGroupCount: number
+  alignedTraceCount: number
+} => {
+  let outputTraces = [...traces]
+  const obstacles = getObstacleRects(inputProblem)
+  const alignedTraceIds = new Set<string>()
+  let alignedRailGroupCount = 0
+  const maximumPasses = Math.max(
+    1,
+    traces.reduce((sum, trace) => sum + trace.tracePath.length, 0),
+  )
+
+  for (let pass = 0; pass < maximumPasses; pass++) {
+    const groups = getRailGroups(
+      outputTraces,
+      eligibleTraceIds,
+      inputProblem,
+      obstacles,
+    )
+    let applied: AlignmentCandidate | null = null
+
+    for (const group of groups) {
+      applied = evaluateRailGroup({
+        group,
+        traces: outputTraces,
+        netLabelPlacements,
+        obstacles,
+        eligibleTraceIds,
+      })
+      if (applied) break
+    }
+    if (!applied) break
+
+    outputTraces = applied.traces
+    alignedRailGroupCount++
+    for (const traceId of applied.changedTraceIds) alignedTraceIds.add(traceId)
+  }
+
+  return {
+    traces: outputTraces,
+    alignedRailGroupCount,
+    alignedTraceCount: alignedTraceIds.size,
+  }
+}

package/lib/solvers/TraceCleanupSolver/sameNetRailAlignment/evaluateRailGroup.ts

@@ -0,0 +1,124 @@
+import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import { isPathCollidingWithObstacles } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions"
+import type { ObstacleRect } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/rect"
+import { detectTraceLabelOverlap } from "lib/solvers/TraceLabelOverlapAvoidanceSolver/detectTraceLabelOverlap"
+import { doesPathCoincideWithTraces } from "lib/utils/doesPathCoincideWithTraces"
+import { getDistinctCoordinates, pointsEqual } from "./geometry"
+import { moveRailSegments } from "./moveRailSegments"
+import { preservesLabelAnchors } from "./preservesLabelAnchors"
+import {
+  getTraceGeometryMetrics,
+  isReadabilityImprovement,
+  scoreIsBetter,
+} from "./scoreRailAlignment"
+import type { AlignmentCandidate, AlignmentScore, RailSegment } from "./types"
+
+interface EvaluateRailGroupInput {
+  group: RailSegment[]
+  traces: SolvedTracePath[]
+  netLabelPlacements: NetLabelPlacement[]
+  obstacles: ObstacleRect[]
+  eligibleTraceIds: ReadonlySet<string>
+}
+
+const tracePathChanged = (
+  original: SolvedTracePath,
+  candidate: SolvedTracePath,
+) =>
+  original.tracePath.length !== candidate.tracePath.length ||
+  candidate.tracePath.some(
+    (point, index) => !pointsEqual(point, original.tracePath[index]!),
+  )
+
+export const evaluateRailGroup = ({
+  group,
+  traces,
+  netLabelPlacements,
+  obstacles,
+  eligibleTraceIds,
+}: EvaluateRailGroupInput): AlignmentCandidate | null => {
+  const groupTraceIds = new Set(group.map((segment) => segment.traceId))
+  const originalGroupTraces = traces.filter((trace) =>
+    groupTraceIds.has(trace.mspPairId),
+  )
+  const baseline = getTraceGeometryMetrics(originalGroupTraces, traces)
+  const coordinates = getDistinctCoordinates(
+    group.map((segment) => segment.coordinate),
+  )
+  const otherNetTraces = traces.filter(
+    (trace) => trace.globalConnNetId !== group[0]!.globalConnNetId,
+  )
+  const immutableSameNetTraces = traces.filter(
+    (trace) =>
+      trace.globalConnNetId === group[0]!.globalConnNetId &&
+      !eligibleTraceIds.has(trace.mspPairId),
+  )
+
+  let best: AlignmentCandidate | null = null
+  for (const coordinate of coordinates) {
+    const candidateMap = new Map<string, SolvedTracePath>()
+
+    for (const trace of originalGroupTraces) {
+      const candidateTrace = moveRailSegments(
+        trace,
+        group.filter((segment) => segment.traceId === trace.mspPairId),
+        coordinate,
+      )
+      candidateMap.set(trace.mspPairId, candidateTrace)
+    }
+
+    const candidateTraces = [...candidateMap.values()]
+    const allCandidateTraces = traces.map(
+      (trace) => candidateMap.get(trace.mspPairId) ?? trace,
+    )
+    const candidatesAreClear = candidateTraces.every(
+      (candidate) =>
+        !isPathCollidingWithObstacles(candidate.tracePath, obstacles) &&
+        detectTraceLabelOverlap({
+          traces: [candidate],
+          netLabels: netLabelPlacements,
+        }).length === 0 &&
+        !doesPathCoincideWithTraces(candidate.tracePath, otherNetTraces) &&
+        !doesPathCoincideWithTraces(
+          candidate.tracePath,
+          immutableSameNetTraces.filter(
+            (trace) => trace.mspPairId !== candidate.mspPairId,
+          ),
+        ),
+    )
+    if (!candidatesAreClear) continue
+    if (
+      !preservesLabelAnchors(netLabelPlacements, traces, allCandidateTraces)
+    ) {
+      continue
+    }
+
+    const metrics = getTraceGeometryMetrics(candidateTraces, allCandidateTraces)
+    if (metrics.otherNetCrossings > baseline.otherNetCrossings) continue
+    if (!isReadabilityImprovement(metrics, baseline)) continue
+
+    const score: AlignmentScore = {
+      ...metrics,
+      displacement: group.reduce(
+        (sum, segment) => sum + Math.abs(segment.coordinate - coordinate),
+        0,
+      ),
+      coordinate,
+    }
+    const changedTraceIds = candidateTraces
+      .filter((candidate) => {
+        const original = traces.find(
+          (trace) => trace.mspPairId === candidate.mspPairId,
+        )!
+        return tracePathChanged(original, candidate)
+      })
+      .map((trace) => trace.mspPairId)
+    if (changedTraceIds.length === 0) continue
+
+    const candidate = { traces: allCandidateTraces, changedTraceIds, score }
+    if (!best || scoreIsBetter(candidate.score, best.score)) best = candidate
+  }
+
+  return best
+}

package/lib/solvers/TraceCleanupSolver/sameNetRailAlignment/geometry.ts

@@ -0,0 +1,108 @@
+import type { Point } from "@tscircuit/math-utils"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import type { RailOrientation, RailSegment } from "./types"
+
+export const RAIL_ALIGNMENT_EPSILON = 2e-3
+
+export const nearlyEqual = (a: number, b: number) =>
+  Math.abs(a - b) < RAIL_ALIGNMENT_EPSILON
+
+export const isHorizontal = (a: Point, b: Point) => nearlyEqual(a.y, b.y)
+
+export const isVertical = (a: Point, b: Point) => nearlyEqual(a.x, b.x)
+
+const isPositiveLength = (a: Point, b: Point) =>
+  Math.abs(a.x - b.x) >= RAIL_ALIGNMENT_EPSILON ||
+  Math.abs(a.y - b.y) >= RAIL_ALIGNMENT_EPSILON
+
+export const getRailOrientation = (
+  a: Point,
+  b: Point,
+): RailOrientation | null => {
+  if (!isPositiveLength(a, b)) return null
+  if (isVertical(a, b)) return "vertical"
+  if (isHorizontal(a, b)) return "horizontal"
+  return null
+}
+
+export const rangesTouchOrOverlap = (a: RailSegment, b: RailSegment) =>
+  Math.min(a.maxAlong, b.maxAlong) - Math.max(a.minAlong, b.minAlong) >=
+  -RAIL_ALIGNMENT_EPSILON
+
+export const pointsEqual = (a: Point, b: Point) =>
+  nearlyEqual(a.x, b.x) && nearlyEqual(a.y, b.y)
+
+export const getDistinctCoordinates = (coordinates: number[]) => {
+  const distinct: number[] = []
+  for (const coordinate of coordinates) {
+    if (!distinct.some((item) => nearlyEqual(item, coordinate))) {
+      distinct.push(coordinate)
+    }
+  }
+  return distinct
+}
+
+interface Interval {
+  coordinate: number
+  min: number
+  max: number
+}
+
+const getMergedIntervalLength = (intervals: Interval[]) => {
+  const groups: Interval[][] = []
+  for (const interval of intervals) {
+    const group = groups.find((items) =>
+      nearlyEqual(items[0]!.coordinate, interval.coordinate),
+    )
+    if (group) group.push(interval)
+    else groups.push([interval])
+  }
+
+  return groups.reduce((total, group) => {
+    const sorted = [...group].sort((a, b) => a.min - b.min)
+    let groupLength = 0
+    let currentMin = sorted[0]!.min
+    let currentMax = sorted[0]!.max
+
+    for (const interval of sorted.slice(1)) {
+      if (interval.min <= currentMax + RAIL_ALIGNMENT_EPSILON) {
+        currentMax = Math.max(currentMax, interval.max)
+      } else {
+        groupLength += currentMax - currentMin
+        currentMin = interval.min
+        currentMax = interval.max
+      }
+    }
+
+    return total + groupLength + currentMax - currentMin
+  }, 0)
+}
+
+/** Returns rendered length after overlapping collinear runs are merged. */
+export const getVisibleTraceLength = (traces: SolvedTracePath[]) => {
+  const horizontal: Interval[] = []
+  const vertical: Interval[] = []
+
+  for (const trace of traces) {
+    for (let index = 0; index < trace.tracePath.length - 1; index++) {
+      const start = trace.tracePath[index]!
+      const end = trace.tracePath[index + 1]!
+
+      if (isHorizontal(start, end)) {
+        horizontal.push({
+          coordinate: start.y,
+          min: Math.min(start.x, end.x),
+          max: Math.max(start.x, end.x),
+        })
+      } else if (isVertical(start, end)) {
+        vertical.push({
+          coordinate: start.x,
+          min: Math.min(start.y, end.y),
+          max: Math.max(start.y, end.y),
+        })
+      }
+    }
+  }
+
+  return getMergedIntervalLength(horizontal) + getMergedIntervalLength(vertical)
+}