@tscircuit/schematic-trace-solver 0.0.124 → 0.0.126

package/lib/solvers/AvailableNetOrientationSolver/geometry.ts

@@ -41,7 +41,11 @@ export const traceCrossesBoundsInterior = (
   return false
 }
 
-const segmentCrossesBoundsInterior = (p1: Point, p2: Point, bounds: Bounds) => {
+export const segmentCrossesBoundsInterior = (
+  p1: Point,
+  p2: Point,
+  bounds: Bounds,
+) => {
   const interiorBounds = {
     minX: bounds.minX + TRACE_BOUNDARY_TOLERANCE,
     minY: bounds.minY + TRACE_BOUNDARY_TOLERANCE,

package/lib/solvers/NetLabelTraceCollisionSolver/NetLabelTraceCollisionSolver.ts

@@ -12,6 +12,7 @@ import {
 import { segmentIntersectsRect } from "lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/collisions"
 import { getColorFromString } from "lib/utils/getColorFromString"
 import type { InputProblem } from "lib/types/InputProblem"
+import type { CompletedTraceReroute } from "lib/solvers/TraceElbowTransitionSimplificationSolver/types"
 
 const ON_PATH_EPS = 1e-6
 
@@ -172,6 +173,7 @@ export class NetLabelTraceCollisionSolver extends BaseSolver {
 
   outputTraces: SolvedTracePath[]
   outputNetLabelPlacements: NetLabelPlacement[]
+  completedReroutes: CompletedTraceReroute[] = []
 
   override activeSubSolver: SingleOverlapSolver | null = null
   private recentlyFailed = new Set<string>()
@@ -208,6 +210,17 @@ export class NetLabelTraceCollisionSolver extends BaseSolver {
       if (this.activeSubSolver.solved) {
         const solvedPath = this.activeSubSolver.solvedTracePath
         if (solvedPath) {
+          this.completedReroutes.push({
+            initialTrace: {
+              ...this.activeSubSolver.initialTrace,
+              tracePath: this.activeSubSolver.initialTrace.tracePath.map(
+                (point) => ({ ...point }),
+              ),
+            },
+            reroutedTracePath: solvedPath.map((point) => ({ ...point })),
+            label: this.activeSubSolver.label,
+            detourCount: this.activeSubSolver.detourCount,
+          })
           const idx = this.outputTraces.findIndex(
             (t) => t.mspPairId === this.activeSubSolver!.initialTrace.mspPairId,
           )
@@ -282,6 +295,7 @@ export class NetLabelTraceCollisionSolver extends BaseSolver {
       paddingBuffer: PADDING_BUFFER,
       detourCount,
       tracesToAvoidOverlapping: this.outputTraces,
+      netLabelPlacements: this.outputNetLabelPlacements,
     })
   }
 
@@ -319,6 +333,7 @@ export class NetLabelTraceCollisionSolver extends BaseSolver {
   getOutput() {
     return {
       traces: this.outputTraces,
+      completedReroutes: this.completedReroutes,
       netLabelPlacements: this.outputNetLabelPlacements,
     }
   }

package/lib/solvers/RailNetLabelCornerPlacementSolver/RailNetLabelCornerPlacementSolver.ts

@@ -1,6 +1,9 @@
 import type { GraphicsObject } from "graphics-debug"
 import type { Point } from "@tscircuit/math-utils"
-import { traceCrossesBoundsInterior } from "lib/solvers/AvailableNetOrientationSolver/geometry"
+import {
+  segmentCrossesBoundsInterior,
+  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"
@@ -32,6 +35,8 @@ import type {
 import { visualizeRailNetLabelCornerPlacementSolver } from "./visualize"
 import { rectIntersectsAnyTextBox } from "lib/utils/textBoxBounds"
 
+const LABEL_TRACE_CLEARANCE = 0.1
+
 export class RailNetLabelCornerPlacementSolver extends BaseSolver {
   inputProblem: InputProblem
   traces: SolvedTracePath[]
@@ -271,11 +276,12 @@ export class RailNetLabelCornerPlacementSolver extends BaseSolver {
     const labelTraces = this.getTraceLinesForLabel(label)
     const allowRailAlignedFallback =
       this.isConfiguredRailLabel(label) &&
-      !labelTraces.some((trace) =>
-        getTraceCorners(trace.tracePath).some((corner) =>
-          this.pointsEqual(corner, label.anchorPoint),
-        ),
-      )
+      (this.isLabelCrossedByOtherNetTrace(label) ||
+        !labelTraces.some((trace) =>
+          getTraceCorners(trace.tracePath).some((corner) =>
+            this.pointsEqual(corner, label.anchorPoint),
+          ),
+        ))
 
     for (const trace of labelTraces) {
       const path = trace.tracePath
@@ -324,6 +330,17 @@ export class RailNetLabelCornerPlacementSolver extends BaseSolver {
     )
   }
 
+  private isLabelCrossedByOtherNetTrace(label: NetLabelPlacement) {
+    const bounds = getRectBounds(label.center, label.width, label.height)
+    const otherNetTraceMap = Object.fromEntries(
+      this.traces
+        .filter((trace) => trace.globalConnNetId !== label.globalConnNetId)
+        .map((trace) => [trace.mspPairId, trace]),
+    )
+
+    return traceCrossesBoundsInterior(bounds, otherNetTraceMap)
+  }
+
   private pointsEqual(a: Point, b: Point) {
     return Math.abs(a.x - b.x) <= EPS && Math.abs(a.y - b.y) <= EPS
   }
@@ -394,6 +411,32 @@ export class RailNetLabelCornerPlacementSolver extends BaseSolver {
       shiftedCoordinates.add(chipBounds.minX - label.width / 2)
       shiftedCoordinates.add(chipBounds.maxX + label.width / 2)
     }
+    for (const otherTrace of this.traces) {
+      if (otherTrace.globalConnNetId === label.globalConnNetId) continue
+
+      for (let i = 0; i < otherTrace.tracePath.length - 1; i++) {
+        const start = otherTrace.tracePath[i]!
+        const end = otherTrace.tracePath[i + 1]!
+        if (!segmentCrossesBoundsInterior(start, end, labelBounds)) continue
+
+        const halfLabelWidth = label.width / 2
+        if (Math.abs(start.x - end.x) <= EPS) {
+          shiftedCoordinates.add(
+            start.x - halfLabelWidth - LABEL_TRACE_CLEARANCE,
+          )
+          shiftedCoordinates.add(
+            start.x + halfLabelWidth + LABEL_TRACE_CLEARANCE,
+          )
+        } else {
+          shiftedCoordinates.add(
+            Math.min(start.x, end.x) - halfLabelWidth - LABEL_TRACE_CLEARANCE,
+          )
+          shiftedCoordinates.add(
+            Math.max(start.x, end.x) + halfLabelWidth + LABEL_TRACE_CLEARANCE,
+          )
+        }
+      }
+    }
 
     return [...shiftedCoordinates].flatMap((x) => {
       if (Math.abs(x - corner.x) <= EPS) return []

package/lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver.ts

@@ -30,6 +30,7 @@ import { NetLabelTraceCollisionSolver } from "../NetLabelTraceCollisionSolver/Ne
 import { NetLabelNetLabelCollisionSolver } from "../NetLabelNetLabelCollisionSolver/NetLabelNetLabelCollisionSolver"
 import { UnroutedTraceRecoverySolver } from "../UnroutedTraceRecoverySolver/UnroutedTraceRecoverySolver"
 import { SameNetJunctionAlignmentSolver } from "../SameNetJunctionAlignmentSolver/SameNetJunctionAlignmentSolver"
+import { TraceElbowTransitionSimplificationSolver } from "../TraceElbowTransitionSimplificationSolver/TraceElbowTransitionSimplificationSolver"
 
 type PipelineStep<T extends new (...args: any[]) => BaseSolver> = {
   solverName: string
@@ -88,6 +89,9 @@ export class SchematicTracePipelineSolver extends BaseSolver {
   netLabelTraceCollisionSolver?: NetLabelTraceCollisionSolver
   traceCleanupSolver2?: TraceCleanupSolver
   netLabelNetLabelCollisionSolver?: NetLabelNetLabelCollisionSolver
+  traceElbowTransitionSimplificationSolver?: TraceElbowTransitionSimplificationSolver
+  preAlignmentTraceElbowTransitionSimplificationSolver?: TraceElbowTransitionSimplificationSolver
+  finalTraceElbowTransitionSimplificationSolver?: TraceElbowTransitionSimplificationSolver
   sameNetJunctionAlignmentSolver?: SameNetJunctionAlignmentSolver
 
   startTimeOfPhase: Record<string, number>
@@ -224,9 +228,27 @@ export class SchematicTracePipelineSolver extends BaseSolver {
         ]
       },
     ),
+    definePipelineStep(
+      "traceElbowTransitionSimplificationSolver",
+      TraceElbowTransitionSimplificationSolver,
+      (instance) => {
+        const overlapAvoidanceOutput =
+          instance.traceLabelOverlapAvoidanceSolver!.getOutput()
+        return [
+          {
+            inputProblem: instance.inputProblem,
+            traces: overlapAvoidanceOutput.traces,
+            completedReroutes: overlapAvoidanceOutput.completedReroutes,
+            netLabelPlacements:
+              instance.traceLabelOverlapAvoidanceSolver!.netLabelPlacements,
+            paddingBuffer: 0.1,
+          },
+        ]
+      },
+    ),
     definePipelineStep("traceCleanupSolver", TraceCleanupSolver, (instance) => {
       const prevSolverOutput =
-        instance.traceLabelOverlapAvoidanceSolver!.getOutput()
+        instance.traceElbowTransitionSimplificationSolver!.getOutput()
       const traces = prevSolverOutput.traces
 
       const labelMergingOutput =
@@ -348,12 +370,29 @@ export class SchematicTracePipelineSolver extends BaseSolver {
         },
       ],
     ),
+    definePipelineStep(
+      "preAlignmentTraceElbowTransitionSimplificationSolver",
+      TraceElbowTransitionSimplificationSolver,
+      (instance) => {
+        const collisionOutput =
+          instance.preAlignmentNetLabelTraceCollisionSolver!.getOutput()
+        return [
+          {
+            inputProblem: instance.inputProblem,
+            traces: collisionOutput.traces,
+            completedReroutes: collisionOutput.completedReroutes,
+            netLabelPlacements: collisionOutput.netLabelPlacements,
+            paddingBuffer: 0.1,
+          },
+        ]
+      },
+    ),
     definePipelineStep(
       "traceCleanupSolver2",
       TraceCleanupSolver,
       (instance) => {
         const collisionOutput =
-          instance.preAlignmentNetLabelTraceCollisionSolver!.getOutput()
+          instance.preAlignmentTraceElbowTransitionSimplificationSolver!.getOutput()
         const labelMergingOutput =
           instance.traceLabelOverlapAvoidanceSolver!.labelMergingSolver!.getOutput()
 
@@ -416,18 +455,37 @@ export class SchematicTracePipelineSolver extends BaseSolver {
         ]
       },
     ),
+    definePipelineStep(
+      "finalTraceElbowTransitionSimplificationSolver",
+      TraceElbowTransitionSimplificationSolver,
+      (instance) => {
+        const collisionOutput =
+          instance.netLabelTraceCollisionSolver!.getOutput()
+        return [
+          {
+            inputProblem: instance.inputProblem,
+            traces: collisionOutput.traces,
+            completedReroutes: collisionOutput.completedReroutes,
+            netLabelPlacements: collisionOutput.netLabelPlacements,
+            paddingBuffer: 0.1,
+          },
+        ]
+      },
+    ),
     definePipelineStep(
       "netLabelNetLabelCollisionSolver",
       NetLabelNetLabelCollisionSolver,
-      (instance) => [
-        {
-          inputProblem: instance.inputProblem,
-          traces: instance.netLabelTraceCollisionSolver!.getOutput().traces,
-          netLabelPlacements:
-            instance.netLabelTraceCollisionSolver!.getOutput()
-              .netLabelPlacements,
-        },
-      ],
+      (instance) => {
+        const simplificationOutput =
+          instance.finalTraceElbowTransitionSimplificationSolver!.getOutput()
+        return [
+          {
+            inputProblem: instance.inputProblem,
+            traces: simplificationOutput.traces,
+            netLabelPlacements: simplificationOutput.netLabelPlacements,
+          },
+        ]
+      },
     ),
     definePipelineStep(
       "sameNetJunctionAlignmentSolver",

package/lib/solvers/TraceElbowTransitionSimplificationSolver/TraceElbowTransitionSimplificationSolver.ts

@@ -0,0 +1,216 @@
+import type { Point } from "@tscircuit/math-utils"
+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 { isPathCollidingWithObstacles } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions"
+import { getObstacleRects } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/rect"
+import { visualizeInputProblem } from "lib/solvers/SchematicTracePipelineSolver/visualizeInputProblem"
+import { preservesLabelAnchors } from "lib/solvers/TraceCleanupSolver/sameNetRailAlignment/preservesLabelAnchors"
+import { simplifyPath } from "lib/solvers/TraceCleanupSolver/simplifyPath"
+import { detectTraceLabelOverlap } from "lib/solvers/TraceLabelOverlapAvoidanceSolver/detectTraceLabelOverlap"
+import type { InputProblem } from "lib/types/InputProblem"
+import { doesPathCoincideWithTraces } from "lib/utils/doesPathCoincideWithTraces"
+import type { CompletedTraceReroute } from "./types"
+import { generateElbowTransitionSimplificationCandidates } from "./generateElbowTransitionSimplificationCandidates"
+
+interface TraceElbowTransitionSimplificationSolverInput {
+  inputProblem: InputProblem
+  traces: SolvedTracePath[]
+  completedReroutes: CompletedTraceReroute[]
+  netLabelPlacements: NetLabelPlacement[]
+  paddingBuffer: number
+}
+
+const PATH_LENGTH_EPSILON = 1e-9
+
+const getPathLength = (points: Point[]) =>
+  points.slice(1).reduce((length, point, pointIndex) => {
+    const previousPoint = points[pointIndex]!
+    return (
+      length +
+      Math.abs(point.x - previousPoint.x) +
+      Math.abs(point.y - previousPoint.y)
+    )
+  }, 0)
+
+/**
+ * Post-processes traces after trace/label overlap avoidance. It removes
+ * redundant elbow transitions and, when needed, shifts a simplified elbow
+ * around a rendered label. Every replacement is revalidated against labels,
+ * components, other-net traces, and label anchors.
+ */
+export class TraceElbowTransitionSimplificationSolver extends BaseSolver {
+  private input: TraceElbowTransitionSimplificationSolverInput
+  private outputTraces: SolvedTracePath[]
+  private traceIdQueue: string[]
+  private obstacles: ReturnType<typeof getObstacleRects>
+
+  constructor(input: TraceElbowTransitionSimplificationSolverInput) {
+    super()
+    this.input = input
+    this.outputTraces = [...input.traces]
+    const reroutedTraceIds = new Set(
+      input.completedReroutes.map(
+        (completedReroute) => completedReroute.initialTrace.mspPairId,
+      ),
+    )
+    this.traceIdQueue = input.traces
+      .map((trace) => trace.mspPairId)
+      .filter((traceId) => reroutedTraceIds.has(traceId))
+    this.obstacles = getObstacleRects(input.inputProblem)
+  }
+
+  override _step() {
+    const traceId = this.traceIdQueue.shift()
+    if (!traceId) {
+      this.solved = true
+      return
+    }
+
+    const traceIndex = this.outputTraces.findIndex(
+      (trace) => trace.mspPairId === traceId,
+    )
+    const trace = this.outputTraces[traceIndex]!
+    const tracePath = simplifyPath(trace.tracePath)
+    const initialOverlaps = detectTraceLabelOverlap({
+      traces: [{ ...trace, tracePath }],
+      netLabels: this.input.netLabelPlacements,
+    })
+    const otherNetTraces = this.outputTraces.filter(
+      (otherTrace) =>
+        otherTrace.mspPairId !== trace.mspPairId &&
+        otherTrace.globalConnNetId !== trace.globalConnNetId,
+    )
+    const candidateByPath = new Map<string, Point[]>()
+    const completedReroutes = this.input.completedReroutes.filter(
+      (completedReroute) =>
+        completedReroute.initialTrace.mspPairId === trace.mspPairId,
+    )
+
+    for (const completedReroute of completedReroutes) {
+      const initialReroutePath = simplifyPath(
+        completedReroute.initialTrace.tracePath,
+      )
+      const reroutedPath = simplifyPath(completedReroute.reroutedTracePath)
+      const initialRerouteOverlapCount = detectTraceLabelOverlap({
+        traces: [
+          { ...completedReroute.initialTrace, tracePath: initialReroutePath },
+        ],
+        netLabels: this.input.netLabelPlacements,
+      }).length
+
+      const candidates = generateElbowTransitionSimplificationCandidates({
+        trace: completedReroute.initialTrace,
+        label: completedReroute.label,
+        netLabelPlacements: this.input.netLabelPlacements,
+        paddingBuffer: this.input.paddingBuffer,
+        detourCount: completedReroute.detourCount,
+      })
+      for (const candidate of candidates) {
+        const simplifiedCandidate = simplifyPath(candidate)
+        const candidateTrace = {
+          ...completedReroute.initialTrace,
+          tracePath: simplifiedCandidate,
+        }
+        const candidateOverlapCount = detectTraceLabelOverlap({
+          traces: [candidateTrace],
+          netLabels: this.input.netLabelPlacements,
+        }).length
+        const isSimplerEquivalentReroute =
+          candidateOverlapCount < initialRerouteOverlapCount &&
+          Math.abs(
+            getPathLength(simplifiedCandidate) - getPathLength(reroutedPath),
+          ) < PATH_LENGTH_EPSILON &&
+          simplifiedCandidate.length < reroutedPath.length &&
+          preservesLabelAnchors(
+            this.input.netLabelPlacements,
+            [completedReroute.initialTrace],
+            [candidateTrace],
+          )
+
+        if (isSimplerEquivalentReroute) {
+          candidateByPath.set(
+            simplifiedCandidate
+              .map((point) => `${point.x},${point.y}`)
+              .join(";"),
+            simplifiedCandidate,
+          )
+        }
+      }
+    }
+
+    const initialOverlapIds = new Set(
+      initialOverlaps.map(
+        ({ label }) => `${label.globalConnNetId}:${label.netId}`,
+      ),
+    )
+    const initialPathLength = getPathLength(tracePath)
+
+    const validCandidates = [...candidateByPath.values()].filter(
+      (candidatePath) => {
+        const candidateTrace = { ...trace, tracePath: candidatePath }
+        const candidateOverlaps = detectTraceLabelOverlap({
+          traces: [candidateTrace],
+          netLabels: this.input.netLabelPlacements,
+        })
+        const candidateOnlyKeepsExistingOverlaps = candidateOverlaps.every(
+          ({ label }) =>
+            initialOverlapIds.has(`${label.globalConnNetId}:${label.netId}`),
+        )
+        const reducesCollisions =
+          candidateOverlaps.length < initialOverlaps.length
+        const simplifiesGeometry =
+          candidateOverlaps.length === initialOverlaps.length &&
+          getPathLength(candidatePath) <=
+            initialPathLength + PATH_LENGTH_EPSILON &&
+          candidatePath.length < tracePath.length
+
+        return (
+          candidateOnlyKeepsExistingOverlaps &&
+          (reducesCollisions || simplifiesGeometry) &&
+          preservesLabelAnchors(
+            this.input.netLabelPlacements,
+            [trace],
+            [candidateTrace],
+          ) &&
+          !isPathCollidingWithObstacles(candidatePath, this.obstacles) &&
+          !doesPathCoincideWithTraces(candidatePath, otherNetTraces)
+        )
+      },
+    )
+
+    const getOverlapCount = (candidatePath: Point[]) =>
+      detectTraceLabelOverlap({
+        traces: [{ ...trace, tracePath: candidatePath }],
+        netLabels: this.input.netLabelPlacements,
+      }).length
+    validCandidates.sort((a, b) => {
+      const overlapDifference = getOverlapCount(a) - getOverlapCount(b)
+      if (overlapDifference !== 0) return overlapDifference
+      return getPathLength(a) - getPathLength(b) || a.length - b.length
+    })
+
+    const bestCandidate = validCandidates[0]
+    if (!bestCandidate) return
+
+    this.outputTraces[traceIndex] = { ...trace, tracePath: bestCandidate }
+    this.stats.simplifiedTraceCount = (this.stats.simplifiedTraceCount ?? 0) + 1
+  }
+
+  getOutput() {
+    return {
+      traces: this.outputTraces,
+      netLabelPlacements: this.input.netLabelPlacements,
+    }
+  }
+
+  override visualize(): GraphicsObject {
+    const graphics = visualizeInputProblem(this.input.inputProblem)
+    graphics.lines ??= []
+    for (const trace of this.outputTraces) {
+      graphics.lines.push({ points: trace.tracePath, strokeColor: "purple" })
+    }
+    return graphics
+  }
+}

package/lib/solvers/TraceElbowTransitionSimplificationSolver/generateElbowTransitionSimplificationCandidates.ts

@@ -0,0 +1,186 @@
+import type { Point } from "@tscircuit/math-utils"
+import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
+import { getRectBounds } from "lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/geometry"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import {
+  isHorizontal,
+  isVertical,
+  segmentIntersectsRect,
+} from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions"
+import { shiftSegmentOrth } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/pathOps"
+import { simplifyPath } from "lib/solvers/TraceCleanupSolver/simplifyPath"
+import { detectTraceLabelOverlap } from "lib/solvers/TraceLabelOverlapAvoidanceSolver/detectTraceLabelOverlap"
+
+export const isSimpleFiveSegmentElbow = (path: Point[]): boolean => {
+  const simplifiedPath = simplifyPath(path)
+  if (simplifiedPath.length !== 6) return false
+
+  const segmentIsHorizontal = simplifiedPath
+    .slice(0, -1)
+    .map((point, index) => isHorizontal(point, simplifiedPath[index + 1]!))
+
+  return segmentIsHorizontal.every(
+    (isHorizontalSegment, index) =>
+      index === 0 || isHorizontalSegment !== segmentIsHorizontal[index - 1],
+  )
+}
+
+const generateSegmentShiftCandidates = ({
+  trace,
+  label,
+  paddingBuffer,
+  detourCount,
+}: {
+  trace: SolvedTracePath
+  label: NetLabelPlacement
+  paddingBuffer: number
+  detourCount: number
+}): Point[][] => {
+  if (trace.globalConnNetId === label.globalConnNetId) return []
+
+  const path = simplifyPath(trace.tracePath)
+  if (!isSimpleFiveSegmentElbow(path)) return []
+
+  const labelBounds = getRectBounds(label.center, label.width, label.height)
+  const effectivePadding = paddingBuffer + detourCount * paddingBuffer
+  const paddedLabelBounds = {
+    minX: labelBounds.minX - effectivePadding,
+    maxX: labelBounds.maxX + effectivePadding,
+    minY: labelBounds.minY - effectivePadding,
+    maxY: labelBounds.maxY + effectivePadding,
+  }
+  const candidates: Point[][] = []
+
+  for (let segmentIndex = 1; segmentIndex < path.length - 2; segmentIndex++) {
+    const segmentStart = path[segmentIndex]!
+    const segmentEnd = path[segmentIndex + 1]!
+    if (!segmentIntersectsRect(segmentStart, segmentEnd, labelBounds)) continue
+
+    const isHorizontalSegment = isHorizontal(segmentStart, segmentEnd)
+    const isVerticalSegment = isVertical(segmentStart, segmentEnd)
+    if (!isHorizontalSegment && !isVerticalSegment) continue
+
+    const axis = isHorizontalSegment ? "y" : "x"
+    const coordinates = isHorizontalSegment
+      ? [paddedLabelBounds.minY, paddedLabelBounds.maxY]
+      : [paddedLabelBounds.minX, paddedLabelBounds.maxX]
+
+    for (const coordinate of coordinates) {
+      const shiftedPath = shiftSegmentOrth(path, segmentIndex, axis, coordinate)
+      if (shiftedPath) candidates.push(shiftedPath)
+    }
+  }
+
+  return candidates
+}
+
+const generateTransitionShiftCandidates = ({
+  trace,
+  label,
+  paddingBuffer,
+  detourCount,
+}: {
+  trace: SolvedTracePath
+  label: NetLabelPlacement
+  paddingBuffer: number
+  detourCount: number
+}): Point[][] => {
+  const path = simplifyPath(trace.tracePath)
+  if (!isSimpleFiveSegmentElbow(path)) return []
+
+  const labelBounds = getRectBounds(label.center, label.width, label.height)
+  const effectivePadding = paddingBuffer + detourCount * paddingBuffer
+  const paddedLabelBounds = {
+    minX: labelBounds.minX - effectivePadding,
+    maxX: labelBounds.maxX + effectivePadding,
+    minY: labelBounds.minY - effectivePadding,
+    maxY: labelBounds.maxY + effectivePadding,
+  }
+  const start = path[0]!
+  const end = path[path.length - 1]!
+  const middleSegmentIndex = 2
+  const candidates: Point[][] = []
+
+  for (let segmentIndex = 0; segmentIndex < path.length - 1; segmentIndex++) {
+    const segmentStart = path[segmentIndex]!
+    const segmentEnd = path[segmentIndex + 1]!
+    if (!segmentIntersectsRect(segmentStart, segmentEnd, labelBounds)) continue
+    if (Math.abs(segmentIndex - middleSegmentIndex) !== 1) continue
+
+    const isHorizontalSegment = isHorizontal(segmentStart, segmentEnd)
+    const isVerticalSegment = isVertical(segmentStart, segmentEnd)
+    if (!isHorizontalSegment && !isVerticalSegment) continue
+
+    const axis = isHorizontalSegment ? "x" : "y"
+    const min = isHorizontalSegment
+      ? paddedLabelBounds.minX
+      : paddedLabelBounds.minY
+    const max = isHorizontalSegment
+      ? paddedLabelBounds.maxX
+      : paddedLabelBounds.maxY
+    const startCoordinate = isHorizontalSegment ? start.x : start.y
+    const endCoordinate = isHorizontalSegment ? end.x : end.y
+    const corridorCoordinates: number[] = []
+
+    if (startCoordinate < min) {
+      corridorCoordinates.push((startCoordinate + min) / 2)
+    } else if (startCoordinate > max) {
+      corridorCoordinates.push((startCoordinate + max) / 2)
+    }
+    if (endCoordinate < min) {
+      corridorCoordinates.push((endCoordinate + min) / 2)
+    } else if (endCoordinate > max) {
+      corridorCoordinates.push((endCoordinate + max) / 2)
+    }
+
+    for (const coordinate of new Set(corridorCoordinates)) {
+      const shiftedPath = shiftSegmentOrth(
+        path,
+        middleSegmentIndex,
+        axis,
+        coordinate,
+      )
+      if (shiftedPath) candidates.push(shiftedPath)
+    }
+  }
+
+  return candidates
+}
+
+export const generateElbowTransitionSimplificationCandidates = ({
+  trace,
+  label,
+  netLabelPlacements,
+  paddingBuffer,
+  detourCount,
+}: {
+  trace: SolvedTracePath
+  label: NetLabelPlacement
+  netLabelPlacements: NetLabelPlacement[]
+  paddingBuffer: number
+  detourCount: number
+}): Point[][] => {
+  const transitionCandidates = generateTransitionShiftCandidates({
+    trace,
+    label,
+    paddingBuffer,
+    detourCount,
+  })
+
+  return transitionCandidates.flatMap((tracePath) => {
+    const shiftedTrace = { ...trace, tracePath }
+    const shiftedOverlaps = detectTraceLabelOverlap({
+      traces: [shiftedTrace],
+      netLabels: netLabelPlacements,
+    })
+
+    return shiftedOverlaps.flatMap(({ label: shiftedLabel }) =>
+      generateSegmentShiftCandidates({
+        trace: shiftedTrace,
+        label: shiftedLabel,
+        paddingBuffer,
+        detourCount,
+      }),
+    )
+  })
+}

package/lib/solvers/TraceElbowTransitionSimplificationSolver/types.ts

@@ -0,0 +1,10 @@
+import type { Point } from "@tscircuit/math-utils"
+import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+
+export interface CompletedTraceReroute {
+  initialTrace: SolvedTracePath
+  reroutedTracePath: Point[]
+  label: NetLabelPlacement
+  detourCount: number
+}