@tscircuit/schematic-trace-solver 0.0.40 → 0.0.42

package/lib/solvers/TraceLabelOverlapAvoidanceSolver/sub-solvers/OverlapAvoidanceStepSolver/OverlapAvoidanceStepSolver.ts

@@ -0,0 +1,144 @@
+import type { GraphicsObject } from "graphics-debug"
+import { BaseSolver } from "lib/solvers/BaseSolver/BaseSolver"
+import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import { visualizeInputProblem } from "lib/solvers/SchematicTracePipelineSolver/visualizeInputProblem"
+import type { InputProblem } from "lib/types/InputProblem"
+import { detectTraceLabelOverlap } from "../../detectTraceLabelOverlap"
+import { SingleOverlapSolver } from "../SingleOverlapSolver/SingleOverlapSolver"
+
+type Overlap = ReturnType<typeof detectTraceLabelOverlap>[0]
+
+// Define a type for the input of the internal overlap solver to avoid conflicts
+interface OverlapCollectionSolverInput {
+  inputProblem: InputProblem
+  traces: SolvedTracePath[]
+  netLabelPlacements: NetLabelPlacement[]
+  mergedLabelNetIdMap: Record<string, Set<string>>
+}
+
+/**
+ * This is an internal solver that manages the step-by-step process of avoiding
+ * multiple overlaps. It follows the pattern of SchematicTraceLinesSolver.
+ */
+export class OverlapAvoidanceStepSolver extends BaseSolver {
+  inputProblem: InputProblem
+  netLabelPlacements: NetLabelPlacement[]
+  mergedLabelNetIdMap: Record<string, Set<string>>
+
+  allTraces: SolvedTracePath[]
+  modifiedTraces: SolvedTracePath[] = []
+
+  private detourCountByLabel: Record<string, number> = {}
+  private readonly PADDING_BUFFER = 0.1
+
+  public override activeSubSolver: SingleOverlapSolver | null = null
+  private overlapQueue: Overlap[] = []
+  private recentlyFailed: Set<string> = new Set()
+
+  constructor(solverInput: OverlapCollectionSolverInput) {
+    super()
+    this.inputProblem = solverInput.inputProblem
+    this.netLabelPlacements = solverInput.netLabelPlacements
+    this.mergedLabelNetIdMap = solverInput.mergedLabelNetIdMap
+    this.allTraces = [...solverInput.traces]
+  }
+
+  override _step() {
+    if (this.activeSubSolver) {
+      this.activeSubSolver.step()
+
+      if (this.activeSubSolver.solved) {
+        const solvedPath = this.activeSubSolver.solvedTracePath
+        if (solvedPath) {
+          const traceIndex = this.allTraces.findIndex(
+            (t) => t.mspPairId === this.activeSubSolver!.initialTrace.mspPairId,
+          )
+          if (traceIndex !== -1) {
+            this.allTraces[traceIndex].tracePath = solvedPath
+            this.modifiedTraces.push(this.allTraces[traceIndex])
+          }
+        }
+        this.activeSubSolver = null
+        this.recentlyFailed.clear()
+      } else if (this.activeSubSolver.failed) {
+        const overlapId = `${this.activeSubSolver.initialTrace.mspPairId}-${this.activeSubSolver.label.globalConnNetId}`
+        this.recentlyFailed.add(overlapId)
+        this.activeSubSolver = null
+      }
+      return
+    }
+
+    const overlaps = detectTraceLabelOverlap(
+      this.allTraces,
+      this.netLabelPlacements,
+    ).filter((o) => {
+      const originalNetIds = this.mergedLabelNetIdMap[o.label.globalConnNetId]
+      if (originalNetIds) {
+        return !originalNetIds.has(o.trace.globalConnNetId)
+      }
+      return o.trace.globalConnNetId !== o.label.globalConnNetId
+    })
+
+    if (overlaps.length === 0) {
+      this.solved = true
+      return
+    }
+
+    const nonFailedOverlaps = overlaps.filter((o) => {
+      const overlapId = `${o.trace.mspPairId}-${o.label.globalConnNetId}`
+      return !this.recentlyFailed.has(overlapId)
+    })
+
+    if (nonFailedOverlaps.length === 0) {
+      this.solved = true // No more progress can be made
+      return
+    }
+
+    this.overlapQueue = nonFailedOverlaps
+
+    const nextOverlap = this.overlapQueue.shift()
+
+    if (nextOverlap) {
+      const traceToFix = this.allTraces.find(
+        (t) => t.mspPairId === nextOverlap.trace.mspPairId,
+      )
+      if (traceToFix) {
+        const labelId = nextOverlap.label.globalConnNetId
+        const detourCount = this.detourCountByLabel[labelId] || 0
+        this.detourCountByLabel[labelId] = detourCount + 1
+
+        this.activeSubSolver = new SingleOverlapSolver({
+          trace: traceToFix,
+          label: nextOverlap.label,
+          problem: this.inputProblem,
+          paddingBuffer: this.PADDING_BUFFER,
+          detourCount,
+        })
+      }
+    }
+  }
+
+  getOutput() {
+    return {
+      allTraces: this.allTraces,
+      modifiedTraces: this.modifiedTraces,
+    }
+  }
+
+  override visualize(): GraphicsObject {
+    if (this.activeSubSolver) {
+      return this.activeSubSolver.visualize()
+    }
+    // When idle, show all the traces
+    const graphics = visualizeInputProblem(this.inputProblem)
+    if (!graphics.lines) graphics.lines = []
+    for (const trace of this.allTraces) {
+      graphics.lines!.push({
+        points: trace.tracePath,
+        strokeColor: "purple",
+      })
+    }
+    return graphics
+  }
+}

package/lib/solvers/TraceLabelOverlapAvoidanceSolver/sub-solvers/SingleOverlapSolver/SingleOverlapSolver.ts

@@ -0,0 +1,117 @@
+import type { Point } from "@tscircuit/math-utils"
+import { BaseSolver } from "lib/solvers/BaseSolver/BaseSolver"
+import type { NetLabelPlacement } from "../../../NetLabelPlacementSolver/NetLabelPlacementSolver"
+import type { InputProblem } from "lib/types/InputProblem"
+import type { GraphicsObject } from "graphics-debug"
+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 { visualizeInputProblem } from "lib/solvers/SchematicTracePipelineSolver/visualizeInputProblem"
+import { generateRerouteCandidates } from "../../rerouteCollidingTrace"
+import { simplifyPath } from "../TraceCleanupSolver/simplifyPath"
+
+interface SingleOverlapSolverInput {
+  trace: SolvedTracePath
+  label: NetLabelPlacement
+  problem: InputProblem
+  paddingBuffer: number
+  detourCount: number
+}
+
+/**
+ * This solver attempts to find a valid rerouting for a single trace that is
+ * overlapping with a net label. It tries various candidate paths until it
+ * finds one that does not introduce new collisions.
+ */
+export class SingleOverlapSolver extends BaseSolver {
+  queuedCandidatePaths: Point[][]
+  solvedTracePath: Point[] | null = null
+  initialTrace: SolvedTracePath
+  problem: InputProblem
+  obstacles: ReturnType<typeof getObstacleRects>
+  label: NetLabelPlacement
+
+  constructor(solverInput: SingleOverlapSolverInput) {
+    super()
+    this.initialTrace = solverInput.trace
+    this.problem = solverInput.problem
+    this.label = solverInput.label
+
+    const candidates = generateRerouteCandidates({
+      ...solverInput,
+    })
+
+    const getPathLength = (pts: Point[]) => {
+      let len = 0
+      for (let i = 0; i < pts.length - 1; i++) {
+        const dx = pts[i + 1].x - pts[i].x
+        const dy = pts[i + 1].y - pts[i].y
+        len += Math.sqrt(dx * dx + dy * dy)
+      }
+      return len
+    }
+
+    this.queuedCandidatePaths = candidates.sort(
+      (a, b) => getPathLength(a) - getPathLength(b),
+    )
+    this.obstacles = getObstacleRects(this.problem)
+  }
+
+  override _step() {
+    if (this.queuedCandidatePaths.length === 0) {
+      this.failed = true
+      return
+    }
+
+    const nextCandidatePath = this.queuedCandidatePaths.shift()!
+    const simplifiedPath = simplifyPath(nextCandidatePath)
+
+    if (!isPathCollidingWithObstacles(simplifiedPath, this.obstacles)) {
+      this.solvedTracePath = simplifiedPath
+      this.solved = true
+    }
+  }
+
+  override visualize(): GraphicsObject {
+    const graphics = visualizeInputProblem(this.problem, {
+      chipAlpha: 0.1,
+      connectionAlpha: 0.1,
+    })
+
+    if (!graphics.lines) graphics.lines = []
+    if (!graphics.rects) graphics.rects = []
+
+    // Draw initial trace
+    graphics.lines.push({
+      points: this.initialTrace.tracePath,
+      strokeColor: "red",
+      strokeDash: "4 4",
+    })
+
+    // Draw label
+    graphics.rects.push({
+      center: this.label.center,
+      width: this.label.width,
+      height: this.label.height,
+      fill: "rgba(255, 0, 0, 0.2)",
+    })
+
+    // Draw next candidate
+    if (this.queuedCandidatePaths.length > 0) {
+      graphics.lines.push({
+        points: this.queuedCandidatePaths[0],
+        strokeColor: "orange",
+      })
+    }
+
+    // Draw solved path
+    if (this.solvedTracePath) {
+      graphics.lines.push({
+        points: this.solvedTracePath,
+        strokeColor: "green",
+      })
+    }
+
+    return graphics
+  }
+}

package/lib/solvers/TraceLabelOverlapAvoidanceSolver/sub-solvers/TraceCleanupSolver/TraceCleanupSolver.ts

@@ -0,0 +1,132 @@
+import type { InputProblem } from "lib/types/InputProblem"
+import type { GraphicsObject, Line } from "graphics-debug"
+import type { NetLabelPlacement } from "../../../NetLabelPlacementSolver/NetLabelPlacementSolver"
+import { minimizeTurnsWithFilteredLabels } from "./minimizeTurnsWithFilteredLabels"
+import { balanceLShapes } from "./balanceLShapes"
+import { BaseSolver } from "lib/solvers/BaseSolver/BaseSolver"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import { visualizeInputProblem } from "lib/solvers/SchematicTracePipelineSolver/visualizeInputProblem"
+
+interface TraceCleanupSolverInput {
+  inputProblem: InputProblem
+  allTraces: SolvedTracePath[]
+  targetTraceIds: Set<string>
+  allLabelPlacements: NetLabelPlacement[]
+  mergedLabelNetIdMap: Record<string, Set<string>>
+  paddingBuffer: number
+}
+
+/**
+ * Cleans up traces by minimizing turns and balancing L-shapes to improve
+ * the overall aesthetics and readability of the schematic.
+ */
+export class TraceCleanupSolver extends BaseSolver {
+  private input: TraceCleanupSolverInput
+  private outputTraces: SolvedTracePath[]
+  private pipelineStepIndex = 0
+  private tracesToProcess: SolvedTracePath[]
+  private minimizedTraces: SolvedTracePath[] | null = null
+  private balancedTraces: SolvedTracePath[] | null = null
+
+  constructor(solverInput: TraceCleanupSolverInput) {
+    super()
+    this.input = solverInput
+    this.outputTraces = [...solverInput.allTraces]
+    this.tracesToProcess = this.outputTraces.filter((t) =>
+      this.input.targetTraceIds.has(t.mspPairId),
+    )
+  }
+
+  override _step() {
+    const {
+      targetTraceIds,
+      inputProblem,
+      allLabelPlacements,
+      mergedLabelNetIdMap,
+      paddingBuffer,
+    } = this.input
+
+    if (targetTraceIds.size === 0) {
+      this.solved = true
+      return
+    }
+
+    switch (this.pipelineStepIndex) {
+      case 0: {
+        // Step 0: Minimize turns
+        const minimizedTracesResult = minimizeTurnsWithFilteredLabels({
+          traces: this.tracesToProcess,
+          inputProblem,
+          allLabelPlacements,
+          mergedLabelNetIdMap,
+          paddingBuffer,
+        })
+
+        this.minimizedTraces = minimizedTracesResult ?? this.tracesToProcess
+
+        const tracesMap = new Map(
+          this.input.allTraces.map((t) => [t.mspPairId, t]),
+        )
+        for (const trace of this.minimizedTraces) {
+          tracesMap.set(trace.mspPairId, trace)
+        }
+        this.outputTraces = Array.from(tracesMap.values())
+        this.pipelineStepIndex++
+        break
+      }
+      case 1: {
+        // Step 1: Balance L-shapes
+        const balancedTracesResult = balanceLShapes({
+          traces: this.minimizedTraces!,
+          inputProblem,
+          allLabelPlacements,
+        })
+
+        this.balancedTraces = balancedTracesResult ?? this.minimizedTraces
+
+        const tracesMap = new Map(
+          this.input.allTraces.map((t) => [t.mspPairId, t]),
+        )
+        for (const trace of this.balancedTraces!) {
+          tracesMap.set(trace.mspPairId, trace)
+        }
+        this.outputTraces = Array.from(tracesMap.values())
+        this.pipelineStepIndex++
+        break
+      }
+      case 2: {
+        // Step 2: Done
+        this.solved = true
+        break
+      }
+    }
+  }
+
+  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 = []
+    if (!graphics.points) graphics.points = []
+    if (!graphics.rects) graphics.rects = []
+    if (!graphics.circles) graphics.circles = []
+    if (!graphics.texts) graphics.texts = []
+
+    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
+  }
+}

package/lib/solvers/TraceLabelOverlapAvoidanceSolver/{balanceLShapes.ts → sub-solvers/TraceCleanupSolver/balanceLShapes.ts}

@@ -1,18 +1,18 @@
 import type { Point } from "graphics-debug"
 import type { InputProblem } from "lib/types/InputProblem"
-import type { NetLabelPlacement } from "../NetLabelPlacementSolver/NetLabelPlacementSolver"
-import { getObstacleRects } from "../SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/rect"
-import type { SolvedTracePath } from "../SchematicTraceLinesSolver/SchematicTraceLinesSolver"
-import { segmentIntersectsRect } from "../SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions"
+import type { NetLabelPlacement } from "../../../NetLabelPlacementSolver/NetLabelPlacementSolver"
 import { simplifyPath } from "./simplifyPath"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import { segmentIntersectsRect } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions"
+import { getObstacleRects } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/rect"
 
 export const balanceLShapes = ({
   traces,
-  problem,
+  inputProblem,
   allLabelPlacements,
 }: {
   traces: SolvedTracePath[]
-  problem: InputProblem
+  inputProblem: InputProblem
   allLabelPlacements: NetLabelPlacement[]
 }): SolvedTracePath[] | null => {
   const TOLERANCE = 1e-5
@@ -46,7 +46,7 @@ export const balanceLShapes = ({
     }
   }
 
-  const obstacles = getObstacleRects(problem).map((obs) => ({
+  const obstacles = getObstacleRects(inputProblem).map((obs) => ({
     ...obs,
     minX: obs.minX + TOLERANCE,
     maxX: obs.maxX - TOLERANCE,
@@ -81,7 +81,7 @@ export const balanceLShapes = ({
   }
 
   const newTraces = traces.map((trace) => {
-    let newPath = [...trace.tracePath]
+    const newPath = [...trace.tracePath]
 
     if (newPath.length < 4) {
       return { ...trace }
@@ -94,7 +94,8 @@ export const balanceLShapes = ({
 
     if (newPath.length === 4) {
       const [p0, p1, p2, p3] = newPath
-      let p1New: Point, p2New: Point
+      let p1New: Point
+      let p2New: Point
 
       const isHVHShape = p0.y === p1.y && p1.x === p2.x && p2.y === p3.y
 
@@ -154,7 +155,8 @@ export const balanceLShapes = ({
         continue
       }
 
-      let p2New: Point, p3New: Point
+      let p2New: Point
+      let p3New: Point
       const len1Original = isHVHZShape
         ? Math.abs(p1.x - p2.x)
         : Math.abs(p1.y - p2.y)

package/lib/solvers/TraceLabelOverlapAvoidanceSolver/{hasCollisions.ts → sub-solvers/TraceCleanupSolver/hasCollisions.ts}

@@ -1,5 +1,5 @@
 import type { Point } from "graphics-debug"
-import { segmentIntersectsRect } from "../SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions"
+import { segmentIntersectsRect } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions"
 
 export const hasCollisions = (
   pathSegments: Point[],

package/lib/solvers/TraceLabelOverlapAvoidanceSolver/{hasCollisionsWithLabels.ts → sub-solvers/TraceCleanupSolver/hasCollisionsWithLabels.ts}

@@ -1,5 +1,5 @@
 import type { Point } from "@tscircuit/math-utils"
-import { segmentIntersectsRect } from "../SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions"
+import { segmentIntersectsRect } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions"
 
 export const hasCollisionsWithLabels = (
   pathSegments: Point[],

package/lib/solvers/TraceLabelOverlapAvoidanceSolver/{minimizeTurnsWithFilteredLabels.ts → sub-solvers/TraceCleanupSolver/minimizeTurnsWithFilteredLabels.ts}

@@ -1,24 +1,24 @@
 import type { InputProblem } from "lib/types/InputProblem"
-import type { NetLabelPlacement } from "../NetLabelPlacementSolver/NetLabelPlacementSolver"
-import type { SolvedTracePath } from "../SchematicTraceLinesSolver/SchematicTraceLinesSolver"
-import { getObstacleRects } from "../SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/rect"
+import type { NetLabelPlacement } from "../../../NetLabelPlacementSolver/NetLabelPlacementSolver"
 import { minimizeTurns } from "./turnMinimization"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import { getObstacleRects } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/rect"
 
 export const minimizeTurnsWithFilteredLabels = ({
   traces,
-  problem,
+  inputProblem,
   allLabelPlacements,
   mergedLabelNetIdMap,
   paddingBuffer,
 }: {
   traces: SolvedTracePath[]
-  problem: InputProblem
+  inputProblem: InputProblem
   allLabelPlacements: NetLabelPlacement[]
   mergedLabelNetIdMap: Record<string, Set<string>>
   paddingBuffer: number
 }): SolvedTracePath[] | null => {
   let changesMade = false
-  const obstacles = getObstacleRects(problem)
+  const obstacles = getObstacleRects(inputProblem)
 
   const newTraces = traces.map((trace) => {
     const originalPath = trace.tracePath

package/lib/solvers/TraceLabelOverlapAvoidanceSolver/{simplifyPath.ts → sub-solvers/TraceCleanupSolver/simplifyPath.ts}

@@ -2,7 +2,7 @@ import type { Point } from "graphics-debug"
 import {
   isHorizontal,
   isVertical,
-} from "../SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions"
+} from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions"
 
 export const simplifyPath = (path: Point[]): Point[] => {
   if (path.length < 3) return path

package/lib/solvers/TraceLabelOverlapAvoidanceSolver/{turnMinimization.ts → sub-solvers/TraceCleanupSolver/turnMinimization.ts}

@@ -105,8 +105,6 @@ export const minimizeTurns = ({
 
           if (!collidesWithObstacles && !collidesWithLabels) {
             const newTurns = countTurns(testPath)
-            const turnsRemoved = stairEndIdx - startIdx - 1
-
             optimizedPath = testPath
             currentTurns = newTurns
             improved = true

package/lib/solvers/TraceLabelOverlapAvoidanceSolver/tryFourPointDetour.ts

@@ -0,0 +1,104 @@
+import type { Point } from "graphics-debug"
+import type { NetLabelPlacement } from "../NetLabelPlacementSolver/NetLabelPlacementSolver"
+import { getRectBounds } from "../NetLabelPlacementSolver/SingleNetLabelPlacementSolver/geometry"
+import type { SolvedTracePath } from "../SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import {
+  segmentIntersectsRect,
+  isVertical,
+} from "../SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions"
+
+export const generateFourPointDetourCandidates = ({
+  initialTrace,
+  label,
+  labelBounds,
+  paddingBuffer,
+  detourCount,
+}: {
+  initialTrace: SolvedTracePath
+  label: NetLabelPlacement
+  labelBounds: any
+  paddingBuffer: number
+  detourCount: number
+}): Point[][] => {
+  let collidingSegIndex = -1
+  for (let i = 0; i < initialTrace.tracePath.length - 1; i++) {
+    if (
+      segmentIntersectsRect(
+        initialTrace.tracePath[i],
+        initialTrace.tracePath[i + 1],
+        labelBounds,
+      )
+    ) {
+      collidingSegIndex = i
+      break
+    }
+  }
+
+  if (collidingSegIndex === -1) return []
+
+  const pA = initialTrace.tracePath[collidingSegIndex]
+  const pB = initialTrace.tracePath[collidingSegIndex + 1]
+
+  if (!pA || !pB) return []
+
+  const candidateDetours: Point[][] = []
+  const paddedLabelBounds = getRectBounds(
+    label.center,
+    label.width,
+    label.height,
+  )
+
+  const effectivePadding = paddingBuffer + detourCount * paddingBuffer
+
+  if (isVertical(pA, pB)) {
+    const xCandidates = [
+      paddedLabelBounds.maxX + effectivePadding,
+      paddedLabelBounds.minX - effectivePadding,
+    ]
+    for (const newX of xCandidates) {
+      candidateDetours.push(
+        pB.y > pA.y
+          ? [
+              { x: pA.x, y: paddedLabelBounds.minY - effectivePadding },
+              { x: newX, y: paddedLabelBounds.minY - effectivePadding },
+              { x: newX, y: paddedLabelBounds.maxY + effectivePadding },
+              { x: pB.x, y: paddedLabelBounds.maxY + effectivePadding },
+            ]
+          : [
+              { x: pA.x, y: paddedLabelBounds.maxY + effectivePadding },
+              { x: newX, y: paddedLabelBounds.maxY + effectivePadding },
+              { x: newX, y: paddedLabelBounds.minY - effectivePadding },
+              { x: pB.x, y: paddedLabelBounds.minY - effectivePadding },
+            ],
+      )
+    }
+  } else {
+    const yCandidates = [
+      paddedLabelBounds.maxY + effectivePadding,
+      paddedLabelBounds.minY - effectivePadding,
+    ]
+    for (const newY of yCandidates) {
+      candidateDetours.push(
+        pB.x > pA.x
+          ? [
+              { x: paddedLabelBounds.minX - effectivePadding, y: pA.y },
+              { x: paddedLabelBounds.minX - effectivePadding, y: newY },
+              { x: paddedLabelBounds.maxX + effectivePadding, y: newY },
+              { x: paddedLabelBounds.maxX + effectivePadding, y: pB.y },
+            ]
+          : [
+              { x: paddedLabelBounds.maxX + effectivePadding, y: pA.y },
+              { x: paddedLabelBounds.maxX + effectivePadding, y: newY },
+              { x: paddedLabelBounds.minX - effectivePadding, y: newY },
+              { x: paddedLabelBounds.minX - effectivePadding, y: pB.y },
+            ],
+      )
+    }
+  }
+
+  return candidateDetours.map((detourPoints) => [
+    ...initialTrace.tracePath.slice(0, collidingSegIndex + 1),
+    ...detourPoints,
+    ...initialTrace.tracePath.slice(collidingSegIndex + 1),
+  ])
+}