@tscircuit/schematic-trace-solver 0.0.107 → 0.0.109

package/lib/solvers/MspConnectionPairSolver/MspConnectionPairSolver.ts

@@ -16,6 +16,7 @@ import { getConnectivityMapsFromInputProblem } from "./getConnectivityMapFromInp
 import { getOrthogonalMinimumSpanningTree } from "./getMspConnectionPairsFromPins"
 
 export type MspConnectionPairId = string
+export const DEFAULT_MAX_MSP_PAIR_DISTANCE = 1
 
 const getPinPairKey = (pinIds: [PinId, PinId]) => [...pinIds].sort().join("::")
 
@@ -45,7 +46,8 @@ export class MspConnectionPairSolver extends BaseSolver {
     super()
 
     this.inputProblem = inputProblem
-    this.maxMspPairDistance = inputProblem.maxMspPairDistance ?? 1
+    this.maxMspPairDistance =
+      inputProblem.maxMspPairDistance ?? DEFAULT_MAX_MSP_PAIR_DISTANCE
 
     const { directConnMap, netConnMap } =
       getConnectivityMapsFromInputProblem(inputProblem)

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

@@ -7,16 +7,18 @@ import { getDimsForOrientation } from "lib/solvers/NetLabelPlacementSolver/Singl
 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 { getTextBoxBounds, type RectPadding } from "lib/utils/textBoxBounds"
 import { getPinDirection } from "../SchematicTraceSingleLineSolver/getPinDirection"
 import { calculateDirectShortPath } from "./calculateDirectShortPath"
 import {
   findFirstCollision,
   isHorizontal,
   isVertical,
+  segmentIntersectsRect,
   segmentOverlapsRectBoundary,
 } from "./collisions"
 import { generateEndpointCollisionDetours } from "./generateEndpointCollisionDetours"
+import { generateInternalSegmentCollisionDetours } from "./generateInternalSegmentCollisionDetours"
 import {
   type Axis,
   aabbFromPoints,
@@ -24,7 +26,12 @@ import {
   midBetweenPointAndRect,
 } from "./mid"
 import { pathKey, shiftSegmentOrth } from "./pathOps"
-import { getObstacleRects, type ObstacleRect } from "./rect"
+import {
+  getObstacleRects,
+  isTextBoxObstacle,
+  type ObstacleRect,
+  type TextBoxObstacleRect,
+} from "./rect"
 
 type PathKey = string
 
@@ -58,8 +65,8 @@ export class SchematicTraceSingleLineSolver2 extends BaseSolver {
   chipMap: Record<string, InputChip>
 
   obstacles: ObstacleRect[]
-  textObstacles: Set<ObstacleRect>
-  endpointTextObstacles: Set<ObstacleRect>
+  textObstacles: Set<TextBoxObstacleRect>
+  endpointTextObstacles: Set<TextBoxObstacleRect>
   aabb: { minX: number; maxX: number; minY: number; maxY: number }
 
   baseElbow: Point[]
@@ -95,18 +102,17 @@ export class SchematicTraceSingleLineSolver2 extends BaseSolver {
     this.obstacles = getObstacleRects(this.inputProblem, {
       textBoxPadding: this.getTextBoxPaddingForConnectionPair(),
     })
-    this.textObstacles = new Set(
-      this.obstacles.filter((r) => r.kind === "text_box"),
-    )
+    this.textObstacles = new Set(this.obstacles.filter(isTextBoxObstacle))
     const endpointChipIds = new Set(this.pins.map((pin) => pin.chipId))
     this.endpointTextObstacles = new Set(
       endpointChipIds.size > 1
-        ? this.obstacles.filter(
-            (r) =>
-              r.kind === "text_box" &&
-              r.textBox.chipId !== undefined &&
-              endpointChipIds.has(r.textBox.chipId),
-          )
+        ? this.obstacles
+            .filter(isTextBoxObstacle)
+            .filter(
+              (obstacle) =>
+                obstacle.textBox.chipId !== undefined &&
+                endpointChipIds.has(obstacle.textBox.chipId),
+            )
         : [],
     )
 
@@ -356,7 +362,12 @@ export class SchematicTraceSingleLineSolver2 extends BaseSolver {
           )
         ) {
           for (const textObstacle of this.endpointTextObstacles) {
-            excludedRects.add(textObstacle)
+            // Outside-pin-band routing may cross label padding around endpoint
+            // text, but the actual text bounds remain a hard obstacle.
+            const textBounds = getTextBoxBounds(textObstacle.textBox)
+            if (!segmentIntersectsRect(segmentStart, segmentEnd, textBounds)) {
+              excludedRects.add(textObstacle)
+            }
           }
         }
 
@@ -500,18 +511,7 @@ export class SchematicTraceSingleLineSolver2 extends BaseSolver {
       pinBandPenalty: number
     }> = []
 
-    const addShiftedCandidate = (
-      candidateSegIndex: number,
-      candidateAxis: Axis,
-      coord: number,
-    ) => {
-      const newPath = shiftSegmentOrth(
-        path,
-        candidateSegIndex,
-        candidateAxis,
-        coord,
-      )
-      if (!newPath) return
+    const addPathCandidate = (newPath: Point[]) => {
       const key = pathKey(newPath)
       if (this.visited.has(key)) return
       this.visited.add(key)
@@ -525,11 +525,42 @@ export class SchematicTraceSingleLineSolver2 extends BaseSolver {
       })
     }
 
+    const addShiftedCandidate = (
+      candidateSegIndex: number,
+      candidateAxis: Axis,
+      coord: number,
+    ) => {
+      const newPath = shiftSegmentOrth(
+        path,
+        candidateSegIndex,
+        candidateAxis,
+        coord,
+      )
+      if (newPath) addPathCandidate(newPath)
+    }
+
+    const lastSegIndex = path.length - 2
+    if (
+      this.connectionPair === undefined &&
+      rect.kind === "text_box" &&
+      this.endpointTextObstacles.has(rect) &&
+      !collisionRects.has(rect) &&
+      originalSegIndex > 0 &&
+      originalSegIndex < lastSegIndex
+    ) {
+      for (const detour of generateInternalSegmentCollisionDetours({
+        path,
+        collidingSegmentIndex: originalSegIndex,
+        obstacle: rect,
+      })) {
+        addPathCandidate(detour)
+      }
+    }
+
     for (const coord of candidates) {
       addShiftedCandidate(segIndex, axis, coord)
     }
 
-    const lastSegIndex = path.length - 2
     const adjacentSegmentIndexes =
       originalSegIndex === 1
         ? [2]

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

@@ -1,6 +1,7 @@
 import type { Point } from "@tscircuit/math-utils"
 import { isHorizontal, isVertical } from "./collisions"
 import { type Axis, midBetweenPointAndRect } from "./mid"
+import { hasOnlyNonzeroOrthogonalSegments } from "./pathOps"
 import type { ObstacleRect } from "./rect"
 
 const getSegmentAxis = (start: Point, end: Point): Axis | null => {
@@ -9,16 +10,6 @@ const getSegmentAxis = (start: Point, end: Point): Axis | null => {
   return null
 }
 
-const hasOnlyNonzeroOrthogonalSegments = (path: Point[]) =>
-  path.every((point, index) => {
-    const nextPoint = path[index + 1]
-    if (!nextPoint) return true
-    if (!isHorizontal(point, nextPoint) && !isVertical(point, nextPoint)) {
-      return false
-    }
-    return Math.abs(point.x - nextPoint.x) + Math.abs(point.y - nextPoint.y) > 0
-  })
-
 export const generateEndpointCollisionDetours = ({
   path,
   collidingSegmentIndex,

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

@@ -0,0 +1,94 @@
+import type { Point } from "@tscircuit/math-utils"
+import { isHorizontal, isVertical } from "./collisions"
+import { hasOnlyNonzeroOrthogonalSegments } from "./pathOps"
+import type { RectBounds } from "./rect"
+
+const EPS = 1e-9
+const DEFAULT_CLEARANCE = 0.2
+
+const isStrictlyBetween = (value: number, a: number, b: number) =>
+  value > Math.min(a, b) + EPS && value < Math.max(a, b) - EPS
+
+export const generateInternalSegmentCollisionDetours = ({
+  path,
+  collidingSegmentIndex,
+  obstacle,
+  clearance = DEFAULT_CLEARANCE,
+}: {
+  path: Point[]
+  collidingSegmentIndex: number
+  obstacle: RectBounds
+  clearance?: number
+}): Point[][] => {
+  if (collidingSegmentIndex <= 0 || collidingSegmentIndex >= path.length - 2) {
+    return []
+  }
+
+  const start = path[collidingSegmentIndex]!
+  const end = path[collidingSegmentIndex + 1]!
+  const detourPoints: Point[][] = []
+
+  if (isHorizontal(start, end)) {
+    const movingRight = start.x < end.x
+    const entryX = movingRight
+      ? obstacle.minX - clearance
+      : obstacle.maxX + clearance
+    const exitX = movingRight
+      ? obstacle.maxX + clearance
+      : obstacle.minX - clearance
+
+    if (
+      !isStrictlyBetween(entryX, start.x, end.x) ||
+      !isStrictlyBetween(exitX, start.x, end.x)
+    ) {
+      return []
+    }
+
+    for (const detourY of [
+      obstacle.minY - clearance,
+      obstacle.maxY + clearance,
+    ]) {
+      detourPoints.push([
+        { x: entryX, y: start.y },
+        { x: entryX, y: detourY },
+        { x: exitX, y: detourY },
+        { x: exitX, y: end.y },
+      ])
+    }
+  } else if (isVertical(start, end)) {
+    const movingUp = start.y < end.y
+    const entryY = movingUp
+      ? obstacle.minY - clearance
+      : obstacle.maxY + clearance
+    const exitY = movingUp
+      ? obstacle.maxY + clearance
+      : obstacle.minY - clearance
+
+    if (
+      !isStrictlyBetween(entryY, start.y, end.y) ||
+      !isStrictlyBetween(exitY, start.y, end.y)
+    ) {
+      return []
+    }
+
+    for (const detourX of [
+      obstacle.minX - clearance,
+      obstacle.maxX + clearance,
+    ]) {
+      detourPoints.push([
+        { x: start.x, y: entryY },
+        { x: detourX, y: entryY },
+        { x: detourX, y: exitY },
+        { x: end.x, y: exitY },
+      ])
+    }
+  }
+
+  return detourPoints
+    .map((points) => [
+      ...path.slice(0, collidingSegmentIndex + 1),
+      ...points,
+      ...path.slice(collidingSegmentIndex + 1),
+    ])
+    .filter(hasOnlyNonzeroOrthogonalSegments)
+}

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

@@ -5,6 +5,16 @@ const EPS = 1e-9
 
 export type Axis = "x" | "y"
 
+export const hasOnlyNonzeroOrthogonalSegments = (path: Point[]) =>
+  path.every((point, index) => {
+    const nextPoint = path[index + 1]
+    if (!nextPoint) return true
+    if (!isHorizontal(point, nextPoint) && !isVertical(point, nextPoint)) {
+      return false
+    }
+    return Math.abs(point.x - nextPoint.x) + Math.abs(point.y - nextPoint.y) > 0
+  })
+
 export const shiftSegmentOrth = (
   pts: Point[],
   segIndex: number,

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

@@ -1,5 +1,5 @@
-import type { InputChip, InputProblem } from "lib/types/InputProblem"
 import { getInputChipBounds } from "lib/solvers/GuidelinesSolver/getInputChipBounds"
+import type { InputChip, InputProblem } from "lib/types/InputProblem"
 import { getTextBoxBounds, type RectPadding } from "lib/utils/textBoxBounds"
 
 export type RectBounds = {
@@ -21,6 +21,10 @@ export type TextBoxObstacleRect = RectBounds & {
 
 export type ObstacleRect = ChipObstacleRect | TextBoxObstacleRect
 
+export const isTextBoxObstacle = (
+  obstacle: ObstacleRect,
+): obstacle is TextBoxObstacleRect => obstacle.kind === "text_box"
+
 export const chipToRect = (chip: InputChip): ChipObstacleRect => {
   const b = getInputChipBounds(chip)
   return { kind: "chip", chipId: chip.chipId, ...b }

package/lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver.ts

@@ -27,6 +27,7 @@ import { RailNetLabelCornerPlacementSolver } from "../RailNetLabelCornerPlacemen
 import { TraceAnchoredNetLabelOverlapSolver } from "../TraceAnchoredNetLabelOverlapSolver/TraceAnchoredNetLabelOverlapSolver"
 import { NetLabelTraceCollisionSolver } from "../NetLabelTraceCollisionSolver/NetLabelTraceCollisionSolver"
 import { NetLabelNetLabelCollisionSolver } from "../NetLabelNetLabelCollisionSolver/NetLabelNetLabelCollisionSolver"
+import { UnroutedTraceRecoverySolver } from "../UnroutedTraceRecoverySolver/UnroutedTraceRecoverySolver"
 
 type PipelineStep<T extends new (...args: any[]) => BaseSolver> = {
   solverName: string
@@ -70,6 +71,7 @@ export class SchematicTracePipelineSolver extends BaseSolver {
   // guidelinesSolver?: GuidelinesSolver
   schematicTraceLinesSolver?: SchematicTraceLinesSolver
   longDistancePairSolver?: LongDistancePairSolver
+  unroutedTraceRecoverySolver?: UnroutedTraceRecoverySolver
   traceOverlapShiftSolver?: TraceOverlapShiftSolver
   netLabelPlacementSolver?: NetLabelPlacementSolver
   labelMergingSolver?: MergedNetLabelObstacleSolver
@@ -143,6 +145,19 @@ export class SchematicTracePipelineSolver extends BaseSolver {
         onSolved: (schematicTraceLinesSolver) => {},
       },
     ),
+    definePipelineStep(
+      "unroutedTraceRecoverySolver",
+      UnroutedTraceRecoverySolver,
+      (instance) => [
+        {
+          inputProblem: instance.inputProblem,
+          failedConnectionPairs:
+            instance.schematicTraceLinesSolver!.failedConnectionPairs,
+          alreadySolvedTraces:
+            instance.longDistancePairSolver!.getOutput().allTracesMerged,
+        },
+      ],
+    ),
     definePipelineStep(
       "traceOverlapShiftSolver",
       TraceOverlapShiftSolver,
@@ -150,7 +165,7 @@ export class SchematicTracePipelineSolver extends BaseSolver {
         {
           inputProblem: this.inputProblem,
           inputTracePaths:
-            this.longDistancePairSolver?.getOutput().allTracesMerged!,
+            this.unroutedTraceRecoverySolver?.getOutput().allTracesMerged!,
           globalConnMap: this.mspConnectionPairSolver!.globalConnMap,
         },
       ],
@@ -167,7 +182,7 @@ export class SchematicTracePipelineSolver extends BaseSolver {
           inputTraceMap:
             this.traceOverlapShiftSolver?.correctedTraceMap ??
             Object.fromEntries(
-              this.longDistancePairSolver!.getOutput().allTracesMerged.map(
+              this.unroutedTraceRecoverySolver!.getOutput().allTracesMerged.map(
                 (p) => [p.mspPairId, p],
               ),
             ),
@@ -187,7 +202,7 @@ export class SchematicTracePipelineSolver extends BaseSolver {
           instance.traceOverlapShiftSolver?.correctedTraceMap ??
           Object.fromEntries(
             instance
-              .longDistancePairSolver!.getOutput()
+              .unroutedTraceRecoverySolver!.getOutput()
               .allTracesMerged.map((p) => [p.mspPairId, p]),
           )
         const traces = Object.values(traceMap)