@tscircuit/schematic-trace-solver 0.0.120 → 0.0.122

package/lib/solvers/RailNetLabelCornerPlacementSolver/RailNetLabelCornerPlacementSolver.ts

@@ -1,13 +1,19 @@
 import type { GraphicsObject } from "graphics-debug"
+import type { Point } from "@tscircuit/math-utils"
 import { traceCrossesBoundsInterior } from "lib/solvers/AvailableNetOrientationSolver/geometry"
 import { BaseSolver } from "lib/solvers/BaseSolver/BaseSolver"
+import { moveAttachedLabelsToReroutedTrace } from "lib/solvers/Example28Solver/labelMovement"
 import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
 import {
   getCenterFromAnchor,
   getRectBounds,
 } from "lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/geometry"
 import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import { isPathCollidingWithObstacles } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions"
+import { getObstacleRects } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/rect"
+import { simplifyPath } from "lib/solvers/TraceCleanupSolver/simplifyPath"
 import type { InputProblem } from "lib/types/InputProblem"
+import { doesPathOverlapTraceStrokes } from "lib/utils/doesPathCoincideWithTraces"
 import {
   EPS,
   getDistance,
@@ -95,6 +101,7 @@ export class RailNetLabelCornerPlacementSolver extends BaseSolver {
 
   getOutput() {
     return {
+      traces: this.traces,
       netLabelPlacements: this.outputNetLabelPlacements,
     }
   }
@@ -163,7 +170,7 @@ export class RailNetLabelCornerPlacementSolver extends BaseSolver {
       center,
       width: label.width,
       height: label.height,
-      status: this.getCandidateStatus(bounds, labelIndex),
+      status: this.getCandidateStatus(bounds, labelIndex, candidate),
       selected: false,
     }
   }
@@ -171,11 +178,27 @@ export class RailNetLabelCornerPlacementSolver extends BaseSolver {
   private getCandidateStatus(
     bounds: Bounds,
     labelIndex: number,
+    candidate: TraceCornerCandidate,
   ): CornerCandidateStatus {
     if (this.intersectsAnyChip(bounds)) return "chip-collision"
     if (rectIntersectsAnyTextBox(bounds, this.inputProblem))
       return "text-collision"
-    if (traceCrossesBoundsInterior(bounds, this.traceMap)) {
+    const candidateTraceMap = candidate.reroutedTracePath
+      ? {
+          ...this.traceMap,
+          [candidate.traceId]: {
+            ...this.traceMap[candidate.traceId]!,
+            tracePath: candidate.reroutedTracePath,
+          },
+        }
+      : this.traceMap
+    if (traceCrossesBoundsInterior(bounds, candidateTraceMap)) {
+      return "trace-collision"
+    }
+    if (
+      candidate.reroutedTracePath &&
+      !this.isReroutedTraceClear(candidate, labelIndex)
+    ) {
       return "trace-collision"
     }
     if (this.intersectsAnyOtherNetLabel(bounds, labelIndex)) {
@@ -190,6 +213,24 @@ export class RailNetLabelCornerPlacementSolver extends BaseSolver {
     label: NetLabelPlacement,
     candidate: EvaluatedCornerCandidate,
   ) {
+    if (candidate.reroutedTracePath) {
+      const originalTrace = this.traceMap[candidate.traceId]!
+      const reroutedTrace = {
+        ...originalTrace,
+        tracePath: candidate.reroutedTracePath,
+      }
+      this.traces = this.traces.map((trace) =>
+        trace.mspPairId === candidate.traceId ? reroutedTrace : trace,
+      )
+      this.traceMap[candidate.traceId] = reroutedTrace
+      this.outputNetLabelPlacements = moveAttachedLabelsToReroutedTrace({
+        trace: originalTrace,
+        originalTracePath: originalTrace.tracePath,
+        reroutedTracePath: candidate.reroutedTracePath,
+        netLabelPlacements: this.outputNetLabelPlacements,
+      })
+    }
+
     this.outputNetLabelPlacements[labelIndex] = {
       ...label,
       anchorPoint: candidate.anchorPoint,
@@ -225,36 +266,197 @@ export class RailNetLabelCornerPlacementSolver extends BaseSolver {
   }
 
   private getCornerCandidatesForLabel(label: NetLabelPlacement) {
-    const isVertical = label.orientation === "y+" || label.orientation === "y-"
-    const candidates: TraceCornerCandidate[] = []
-    const seenCornerKeys = new Set<string>()
+    const anchorAlignedCandidates: TraceCornerCandidate[] = []
+    const railAlignedCandidates: TraceCornerCandidate[] = []
+    const labelTraces = this.getTraceLinesForLabel(label)
+    const allowRailAlignedFallback =
+      this.isConfiguredRailLabel(label) &&
+      !labelTraces.some((trace) =>
+        getTraceCorners(trace.tracePath).some((corner) =>
+          this.pointsEqual(corner, label.anchorPoint),
+        ),
+      )
 
-    for (const trace of this.getTraceLinesForLabel(label)) {
+    for (const trace of labelTraces) {
       const path = trace.tracePath
       const pins = [path[0]!, path[path.length - 1]!]
       for (const anchorPoint of getTraceCorners(path)) {
-        const key = `${anchorPoint.x}:${anchorPoint.y}`
-        if (seenCornerKeys.has(key)) continue
-        seenCornerKeys.add(key)
-        const pinAligned = pins.some((pin) => {
-          if (isVertical) return Math.abs(pin.x - anchorPoint.x) < EPS
-          return Math.abs(pin.y - anchorPoint.y) < EPS
-        })
-        // Only pin-aligned corners are worth snapping a rail label to (a clean
-        // stub off a pin). Non-aligned corners are no better than where the
-        // label already is, so they aren't offered as candidates — this keeps
-        // already-well-placed labels untouched.
+        const cornerIndex = path.indexOf(anchorPoint)
+        const anchorAlignedToPin = pins.some(
+          (pin) => Math.abs(pin.x - anchorPoint.x) <= EPS,
+        )
+        const pinAligned =
+          anchorAlignedToPin ||
+          (allowRailAlignedFallback &&
+            this.isPinAlignedCorner(path, cornerIndex))
         if (!pinAligned) continue
-        candidates.push({
+
+        const candidates = anchorAlignedToPin
+          ? anchorAlignedCandidates
+          : railAlignedCandidates
+        candidates.push(
+          {
+            anchorPoint,
+            traceId: trace.mspPairId,
+            distance: getDistance(anchorPoint, label.anchorPoint),
+            pinAligned,
+          },
+          ...this.getClearanceShiftedCornerCandidates({
+            label,
+            trace,
+            cornerIndex,
+            pinAligned,
+          }),
+        )
+      }
+    }
+
+    return [
+      ...anchorAlignedCandidates.sort((a, b) => a.distance - b.distance),
+      ...railAlignedCandidates.sort((a, b) => a.distance - b.distance),
+    ]
+  }
+
+  private isConfiguredRailLabel(label: NetLabelPlacement) {
+    if (!label.netId) return false
+    return this.inputProblem.availableNetLabelOrientations[label.netId]?.some(
+      (orientation) => orientation === "y+" || orientation === "y-",
+    )
+  }
+
+  private pointsEqual(a: Point, b: Point) {
+    return Math.abs(a.x - b.x) <= EPS && Math.abs(a.y - b.y) <= EPS
+  }
+
+  private getVerticalSegmentPointIndices(path: Point[], cornerIndex: number) {
+    const corner = path[cornerIndex]!
+    const previousIsVertical =
+      Math.abs(path[cornerIndex - 1]!.x - corner.x) <= EPS
+    const nextIsVertical = Math.abs(path[cornerIndex + 1]!.x - corner.x) <= EPS
+    if (previousIsVertical === nextIsVertical) return null
+
+    const indices = previousIsVertical
+      ? [cornerIndex - 1, cornerIndex]
+      : [cornerIndex, cornerIndex + 1]
+    return indices
+  }
+
+  private isPinAlignedCorner(path: Point[], cornerIndex: number) {
+    const verticalPointIndices = this.getVerticalSegmentPointIndices(
+      path,
+      cornerIndex,
+    )
+    if (!verticalPointIndices) return false
+
+    const [startIndex, endIndex] = verticalPointIndices
+    return startIndex! <= 1 || endIndex! >= path.length - 2
+  }
+
+  private getClearanceShiftedCornerCandidates({
+    label,
+    trace,
+    cornerIndex,
+    pinAligned,
+  }: {
+    label: NetLabelPlacement
+    trace: SolvedTracePath
+    cornerIndex: number
+    pinAligned: boolean
+  }): TraceCornerCandidate[] {
+    if (label.orientation !== "y+" && label.orientation !== "y-") return []
+
+    const path = trace.tracePath
+    const corner = path[cornerIndex]!
+    const verticalPointIndices = this.getVerticalSegmentPointIndices(
+      path,
+      cornerIndex,
+    )
+    if (
+      !verticalPointIndices ||
+      verticalPointIndices.includes(0) ||
+      verticalPointIndices.includes(path.length - 1)
+    ) {
+      return []
+    }
+
+    const center = getCenterFromAnchor(
+      corner,
+      label.orientation,
+      label.width,
+      label.height,
+    )
+    const labelBounds = getRectBounds(center, label.width, label.height)
+    const collidingChipBounds = this.inputProblem.chips
+      .map((chip) => getRectBounds(chip.center, chip.width, chip.height))
+      .filter((chipBounds) => rectsOverlap(labelBounds, chipBounds))
+    const shiftedCoordinates = new Set<number>()
+    for (const chipBounds of collidingChipBounds) {
+      shiftedCoordinates.add(chipBounds.minX - label.width / 2)
+      shiftedCoordinates.add(chipBounds.maxX + label.width / 2)
+    }
+
+    return [...shiftedCoordinates].flatMap((x) => {
+      if (Math.abs(x - corner.x) <= EPS) return []
+      const reroutedTracePath = simplifyPath(
+        path.map((point, pointIndex) =>
+          verticalPointIndices.includes(pointIndex) ? { ...point, x } : point,
+        ),
+      )
+      const anchorPoint = { x, y: corner.y }
+      const remainsCorner = getTraceCorners(reroutedTracePath).some((point) =>
+        this.pointsEqual(point, anchorPoint),
+      )
+      if (!remainsCorner) return []
+
+      return [
+        {
           anchorPoint,
           traceId: trace.mspPairId,
           distance: getDistance(anchorPoint, label.anchorPoint),
           pinAligned,
-        })
-      }
+          reroutedTracePath,
+        },
+      ]
+    })
+  }
+
+  private isReroutedTraceClear(
+    candidate: TraceCornerCandidate,
+    labelIndex: number,
+  ) {
+    const reroutedTracePath = candidate.reroutedTracePath!
+    if (
+      isPathCollidingWithObstacles(
+        reroutedTracePath,
+        getObstacleRects(this.inputProblem),
+      )
+    ) {
+      return false
+    }
+
+    const candidateTrace = this.traceMap[candidate.traceId]!
+    const otherNetTraces = this.traces.filter(
+      (trace) =>
+        trace.mspPairId !== candidate.traceId &&
+        trace.globalConnNetId !== candidateTrace.globalConnNetId,
+    )
+    if (doesPathOverlapTraceStrokes(reroutedTracePath, otherNetTraces)) {
+      return false
     }
 
-    return candidates.sort((a, b) => a.distance - b.distance)
+    const reroutedTraceMap = {
+      [candidate.traceId]: {
+        ...candidateTrace,
+        tracePath: reroutedTracePath,
+      },
+    }
+    return this.outputNetLabelPlacements.every((label, index) => {
+      if (index === labelIndex) return true
+      return !traceCrossesBoundsInterior(
+        getRectBounds(label.center, label.width, label.height),
+        reroutedTraceMap,
+      )
+    })
   }
 
   private getTraceLinesForLabel(label: NetLabelPlacement) {

package/lib/solvers/RailNetLabelCornerPlacementSolver/types.ts

@@ -21,11 +21,11 @@ export type TraceCornerCandidate = {
   traceId: string
   distance: number
   /**
-   * True when the corner lines up with one of the trace's pins along the
-   * label's stub axis (same x for a vertical rail label), so the label reads as
-   * a clean stub off that pin rather than floating over a mid-trace bend.
+   * True when the corner is on a vertical rail that connects directly to one
+   * of the trace's endpoint pins, rather than on an arbitrary middle bend.
    */
   pinAligned: boolean
+  reroutedTracePath?: Point[]
 }
 
 export type CornerCandidateStatus =

package/lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver.ts

@@ -22,6 +22,7 @@ import { LongDistancePairSolver } from "../LongDistancePairSolver/LongDistancePa
 import { MergedNetLabelObstacleSolver } from "../TraceLabelOverlapAvoidanceSolver/sub-solvers/LabelMergingSolver/LabelMergingSolver"
 import { TraceCleanupSolver } from "../TraceCleanupSolver/TraceCleanupSolver"
 import { Example28Solver } from "../Example28Solver/Example28Solver"
+import { moveAttachedLabelsToReroutedTrace } from "../Example28Solver/labelMovement"
 import { AvailableNetOrientationSolver } from "../AvailableNetOrientationSolver/AvailableNetOrientationSolver"
 import { RailNetLabelCornerPlacementSolver } from "../RailNetLabelCornerPlacementSolver/RailNetLabelCornerPlacementSolver"
 import { TraceAnchoredNetLabelOverlapSolver } from "../TraceAnchoredNetLabelOverlapSolver/TraceAnchoredNetLabelOverlapSolver"
@@ -325,9 +326,8 @@ export class SchematicTracePipelineSolver extends BaseSolver {
       (instance) => [
         {
           inputProblem: instance.inputProblem,
-          traces: Object.values(
-            instance.postLabelTraceOverlapShiftSolver!.correctedTraceMap,
-          ),
+          traces:
+            instance.railNetLabelCornerPlacementSolver!.getOutput().traces,
           netLabelPlacements:
             instance.railNetLabelCornerPlacementSolver!
               .outputNetLabelPlacements,
@@ -340,9 +340,8 @@ export class SchematicTracePipelineSolver extends BaseSolver {
       (instance) => [
         {
           inputProblem: instance.inputProblem,
-          traces: Object.values(
-            instance.postLabelTraceOverlapShiftSolver!.correctedTraceMap,
-          ),
+          traces:
+            instance.railNetLabelCornerPlacementSolver!.getOutput().traces,
           netLabelPlacements:
             instance.traceAnchoredNetLabelOverlapSolver!
               .outputNetLabelPlacements,
@@ -379,14 +378,40 @@ export class SchematicTracePipelineSolver extends BaseSolver {
       "netLabelTraceCollisionSolver",
       NetLabelTraceCollisionSolver,
       (instance) => {
-        const previousCollisionOutput =
+        const previousOutput =
           instance.preAlignmentNetLabelTraceCollisionSolver!.getOutput()
+        const alignmentOutput = instance.traceCleanupSolver2!.getOutput()
+        const previousTraceMap = new Map(
+          previousOutput.traces.map((trace) => [trace.mspPairId, trace]),
+        )
+        let netLabelPlacements = previousOutput.netLabelPlacements
+
+        for (const trace of alignmentOutput.traces) {
+          const previousTrace = previousTraceMap.get(trace.mspPairId)
+          if (!previousTrace || previousTrace.tracePath === trace.tracePath) {
+            continue
+          }
+
+          const currentLabels = netLabelPlacements
+          const movedLabels = moveAttachedLabelsToReroutedTrace({
+            trace: previousTrace,
+            originalTracePath: previousTrace.tracePath,
+            reroutedTracePath: trace.tracePath,
+            netLabelPlacements: currentLabels,
+          })
+          netLabelPlacements = movedLabels.map((movedLabel, labelIndex) => {
+            const label = currentLabels[labelIndex]!
+            return label.orientation === "y+" || label.orientation === "y-"
+              ? movedLabel
+              : label
+          })
+        }
 
         return [
           {
             inputProblem: instance.inputProblem,
-            traces: instance.traceCleanupSolver2!.getOutput().traces,
-            netLabelPlacements: previousCollisionOutput.netLabelPlacements,
+            traces: alignmentOutput.traces,
+            netLabelPlacements,
           },
         ]
       },

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

@@ -3,8 +3,12 @@ import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/Sche
 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 {
+  doesPathCoincideWithTraces,
+  doesPathOverlapTraceStrokes,
+} from "lib/utils/doesPathCoincideWithTraces"
 import { getDistinctCoordinates, pointsEqual } from "./geometry"
+import { getRailAlignmentFallbackCoordinates } from "./getRailAlignmentFallbackCoordinates"
 import { moveRailSegments } from "./moveRailSegments"
 import { preservesLabelAnchors } from "./preservesLabelAnchors"
 import {
@@ -43,7 +47,7 @@ export const evaluateRailGroup = ({
     groupTraceIds.has(trace.mspPairId),
   )
   const baseline = getTraceGeometryMetrics(originalGroupTraces, traces)
-  const coordinates = getDistinctCoordinates(
+  const originalCoordinates = getDistinctCoordinates(
     group.map((segment) => segment.coordinate),
   )
   const otherNetTraces = traces.filter(
@@ -55,70 +59,86 @@ export const evaluateRailGroup = ({
       !eligibleTraceIds.has(trace.mspPairId),
   )
 
-  let best: AlignmentCandidate | null = null
-  for (const coordinate of coordinates) {
-    const candidateMap = new Map<string, SolvedTracePath>()
+  const evaluateCoordinates = (coordinates: number[]) => {
+    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)
-    }
+      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,
+      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 &&
+          !doesPathOverlapTraceStrokes(candidate.tracePath, otherNetTraces) &&
+          !doesPathCoincideWithTraces(
+            candidate.tracePath,
+            immutableSameNetTraces.filter(
+              (trace) => trace.mspPairId !== candidate.mspPairId,
+            ),
           ),
-        ),
-    )
-    if (!candidatesAreClear) continue
-    if (
-      !preservesLabelAnchors(netLabelPlacements, traces, allCandidateTraces)
-    ) {
-      continue
-    }
+      )
+      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 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 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
     }
-    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
   }
 
-  return best
+  const originalCandidate = evaluateCoordinates(originalCoordinates)
+  if (originalCandidate) return originalCandidate
+
+  return evaluateCoordinates(
+    getRailAlignmentFallbackCoordinates({
+      group,
+      originalCoordinates,
+      otherNetTraces,
+    }),
+  )
 }

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

@@ -0,0 +1,96 @@
+import { boundsIntersection, type Bounds } from "@tscircuit/math-utils"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import {
+  SCHEMATIC_TRACE_MIN_CENTERLINE_CLEARANCE,
+  SCHEMATIC_TRACE_MIN_VISUAL_CENTERLINE_CLEARANCE,
+} from "lib/utils/doesPathCoincideWithTraces"
+import {
+  getDistinctCoordinates,
+  getRailOrientation,
+  RAIL_ALIGNMENT_EPSILON,
+} from "./geometry"
+import type { RailOrientation, RailSegment } from "./types"
+
+const getAlongBounds = (
+  orientation: RailOrientation,
+  minAlong: number,
+  maxAlong: number,
+): Bounds =>
+  orientation === "vertical"
+    ? { minX: 0, maxX: 0, minY: minAlong, maxY: maxAlong }
+    : { minX: minAlong, maxX: maxAlong, minY: 0, maxY: 0 }
+
+const hasPositiveAlongOverlap = (
+  orientation: RailOrientation,
+  first: Bounds,
+  second: Bounds,
+) => {
+  const overlap = boundsIntersection(first, second)
+  if (!overlap) return false
+  const overlapLength =
+    orientation === "vertical"
+      ? overlap.maxY - overlap.minY
+      : overlap.maxX - overlap.minX
+  return overlapLength > RAIL_ALIGNMENT_EPSILON
+}
+
+/**
+ * Derives alternatives only for original alignment coordinates whose rendered
+ * stroke touches a parallel segment from another net.
+ */
+export const getRailAlignmentFallbackCoordinates = ({
+  group,
+  originalCoordinates,
+  otherNetTraces,
+}: {
+  group: RailSegment[]
+  originalCoordinates: number[]
+  otherNetTraces: SolvedTracePath[]
+}) => {
+  const orientation = group[0]!.orientation
+  const groupAlongBounds = group.map((segment) =>
+    getAlongBounds(orientation, segment.minAlong, segment.maxAlong),
+  )
+  const fallbackClearance = SCHEMATIC_TRACE_MIN_VISUAL_CENTERLINE_CLEARANCE
+  const coordinates: number[] = []
+
+  for (const trace of otherNetTraces) {
+    for (let index = 0; index < trace.tracePath.length - 1; index++) {
+      const start = trace.tracePath[index]!
+      const end = trace.tracePath[index + 1]!
+      if (getRailOrientation(start, end) !== orientation) continue
+
+      const minAlong =
+        orientation === "vertical"
+          ? Math.min(start.y, end.y)
+          : Math.min(start.x, end.x)
+      const maxAlong =
+        orientation === "vertical"
+          ? Math.max(start.y, end.y)
+          : Math.max(start.x, end.x)
+      const traceAlongBounds = getAlongBounds(orientation, minAlong, maxAlong)
+      if (
+        !groupAlongBounds.some((bounds) =>
+          hasPositiveAlongOverlap(orientation, bounds, traceAlongBounds),
+        )
+      ) {
+        continue
+      }
+
+      const coordinate = orientation === "vertical" ? start.x : start.y
+      const touchesOriginalCandidate = originalCoordinates.some(
+        (originalCoordinate) =>
+          Math.abs(originalCoordinate - coordinate) <=
+          SCHEMATIC_TRACE_MIN_CENTERLINE_CLEARANCE,
+      )
+      if (!touchesOriginalCandidate) continue
+
+      coordinates.push(
+        coordinate - fallbackClearance,
+        coordinate + fallbackClearance,
+      )
+    }
+  }
+
+  return getDistinctCoordinates(coordinates)
+}