@tscircuit/schematic-trace-solver 0.0.182 → 0.0.183

package/lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver.ts

@@ -11,6 +11,7 @@ import { SchematicTraceSingleLineSolver2 } from "./SchematicTraceSingleLineSolve
 import type { Guideline } from "../GuidelinesSolver/GuidelinesSolver"
 import { visualizeGuidelines } from "../GuidelinesSolver/visualizeGuidelines"
 import type { Point } from "@tscircuit/math-utils"
+import { getPinDirectionCandidates } from "./SchematicTraceSingleLineSolver/getPinDirection"
 
 const shouldPreferExteriorDetours = ({
   connectionPair,
@@ -62,6 +63,7 @@ export class SchematicTraceLinesSolver extends BaseSolver {
   chipMap: Record<string, InputChip>
 
   currentConnectionPair: MspConnectionPair | null = null
+  retryingWithoutNetLabelClearance = false
 
   solvedTracePaths: Array<SolvedTracePath> = []
   failedConnectionPairs: Array<MspConnectionPair & { error?: string }> = []
@@ -101,6 +103,7 @@ export class SchematicTraceLinesSolver extends BaseSolver {
     if (this.activeSubSolver?.solved) {
       this.solvedTracePaths.push({
         ...this.currentConnectionPair!,
+        pins: this.activeSubSolver.pins,
         tracePath: this.activeSubSolver!.solvedTracePath!,
         mspConnectionPairIds: [this.currentConnectionPair!.mspPairId],
         pinIds: [
@@ -110,8 +113,33 @@ export class SchematicTraceLinesSolver extends BaseSolver {
       })
       this.activeSubSolver = null
       this.currentConnectionPair = null
+      this.retryingWithoutNetLabelClearance = false
     }
     if (this.activeSubSolver?.failed) {
+      if (
+        this.currentConnectionPair &&
+        !this.retryingWithoutNetLabelClearance &&
+        this.activeSubSolver.hasAmbiguousPinDirections
+      ) {
+        const connectionPair = this.currentConnectionPair
+        this.retryingWithoutNetLabelClearance = true
+        this.activeSubSolver = new SchematicTraceSingleLineSolver2({
+          inputProblem: this.inputProblem,
+          pins: connectionPair.pins.map((pin) => ({
+            ...pin,
+          })) as MspConnectionPair["pins"],
+          connectionPair,
+          chipMap: this.chipMap,
+          preferExteriorDetours: shouldPreferExteriorDetours({
+            connectionPair,
+            allConnectionPairs: this.mspConnectionPairs,
+            inputProblem: this.inputProblem,
+          }),
+          reserveNetLabelClearance: false,
+        })
+        return
+      }
+
       // Record the failure for this connection and continue to the next pair
       if (this.currentConnectionPair) {
         this.failedConnectionPairs.push({
@@ -121,6 +149,7 @@ export class SchematicTraceLinesSolver extends BaseSolver {
       }
       this.activeSubSolver = null
       this.currentConnectionPair = null
+      this.retryingWithoutNetLabelClearance = false
       // Do not fail the whole solver; proceed to schedule the next pair
     }
 
@@ -137,8 +166,22 @@ export class SchematicTraceLinesSolver extends BaseSolver {
     }
 
     this.currentConnectionPair = connectionPair
-
-    const { pins } = connectionPair
+    this.retryingWithoutNetLabelClearance = false
+
+    // Corner pins can legitimately face either adjacent edge. Keep their
+    // inferred direction local to this route so solving one branch cannot
+    // constrain a later branch that shares the same corner pin. Pins with one
+    // geometric direction retain the established shared representation.
+    const hasAmbiguousCornerPin = connectionPair.pins.some((pin) => {
+      if (pin._facingDirection) return false
+      const chip = this.chipMap[pin.chipId]
+      return chip && getPinDirectionCandidates(pin, chip).length > 1
+    })
+    const pins = hasAmbiguousCornerPin
+      ? (connectionPair.pins.map((pin) => ({
+          ...pin,
+        })) as MspConnectionPair["pins"])
+      : connectionPair.pins
 
     this.activeSubSolver = new SchematicTraceSingleLineSolver2({
       inputProblem: this.inputProblem,

package/lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver/getPinDirection.ts

@@ -1,9 +1,12 @@
 import type { InputChip, InputPin } from "lib/types/InputProblem"
 
-export const getPinDirection = (
+export type PinDirection = "x+" | "x-" | "y+" | "y-"
+
+export const getPinDirectionCandidates = (
   pin: InputPin,
   chip: InputChip,
-): "x+" | "x-" | "y+" | "y-" => {
+  connectedPin?: InputPin,
+): PinDirection[] => {
   // Determine what edge the pin lies on
   const { x, y } = pin
   const { center, width, height } = chip
@@ -26,17 +29,62 @@ export const getPinDirection = (
     xMinusDistance,
   )
 
-  if (minDistance === yPlusDistance) {
-    return "y+"
-  }
+  // Preserve the established single-direction result as the primary choice.
+  // Candidate routing may treat nearly equal edge distances as an ambiguous
+  // corner, but context-free callers (such as visualization) should not change
+  // direction solely because the candidate comparison uses a tolerance.
+  const primaryDirection: PinDirection =
+    minDistance === yPlusDistance
+      ? "y+"
+      : minDistance === yMinusDistance
+        ? "y-"
+        : minDistance === xPlusDistance
+          ? "x+"
+          : "x-"
+
+  const matchingDirections = [
+    { direction: "y+" as const, distance: yPlusDistance },
+    { direction: "y-" as const, distance: yMinusDistance },
+    { direction: "x+" as const, distance: xPlusDistance },
+    { direction: "x-" as const, distance: xMinusDistance },
+  ]
+    .filter(({ distance }) => Math.abs(distance - minDistance) <= 1e-9)
+    .map(({ direction }) => direction)
+
+  const closestDirections = [
+    primaryDirection,
+    ...matchingDirections.filter((direction) => direction !== primaryDirection),
+  ]
 
-  if (minDistance === yMinusDistance) {
-    return "y-"
+  if (!connectedPin || closestDirections.length <= 1) {
+    return closestDirections
   }
 
-  if (minDistance === xPlusDistance) {
-    return "x+"
+  const xDistance = connectedPin.x - pin.x
+  const yDistance = connectedPin.y - pin.y
+  const directionTowardConnectedPin: PinDirection =
+    Math.abs(xDistance) >= Math.abs(yDistance)
+      ? xDistance >= 0
+        ? "x+"
+        : "x-"
+      : yDistance >= 0
+        ? "y+"
+        : "y-"
+
+  if (!closestDirections.includes(directionTowardConnectedPin)) {
+    return closestDirections
   }
 
-  return "x-"
+  return [
+    directionTowardConnectedPin,
+    ...closestDirections.filter(
+      (direction) => direction !== directionTowardConnectedPin,
+    ),
+  ]
 }
+
+export const getPinDirection = (
+  pin: InputPin,
+  chip: InputChip,
+  connectedPin?: InputPin,
+): PinDirection => getPinDirectionCandidates(pin, chip, connectedPin)[0]!

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

@@ -9,8 +9,12 @@ import type { InputChip, InputProblem } from "lib/types/InputProblem"
 import type { FacingDirection } from "lib/utils/dir"
 import { getNetLabelWidthForConnection } from "lib/utils/getNetLabelWidthForConnection"
 import { getTextBoxBounds, type RectPadding } from "lib/utils/textBoxBounds"
-import { getPinDirection } from "../SchematicTraceSingleLineSolver/getPinDirection"
-import { calculateDirectShortPath } from "./calculateDirectShortPath"
+import { getPinDirectionCandidates } from "../SchematicTraceSingleLineSolver/getPinDirection"
+import {
+  calculateDirectShortPath,
+  pathMatchesPinDirections,
+  segmentDirection,
+} from "./calculateDirectShortPath"
 import {
   findFirstCollision,
   isHorizontal,
@@ -78,6 +82,55 @@ const pinsFaceEachOther = ({
     : pin1._facingDirection === "y-" && pin2._facingDirection === "y+"
 }
 
+const getPathLength = (points: Point[]) => {
+  let length = 0
+  for (let i = 0; i < points.length - 1; i++) {
+    length +=
+      Math.abs(points[i + 1]!.x - points[i]!.x) +
+      Math.abs(points[i + 1]!.y - points[i]!.y)
+  }
+  return length
+}
+
+const getInitialPathForPins = ({
+  pins,
+  obstacles,
+}: {
+  pins: MspConnectionPair["pins"]
+  obstacles: ObstacleRect[]
+}): { path: Point[]; isDirectShortPath: boolean } => {
+  const [pin1, pin2] = pins
+  const directShortPath = calculateDirectShortPath(pin1, pin2)
+  const defaultElbow = calculateElbowForPins({
+    pin1,
+    pin2,
+    overshoot: 0.2,
+  })
+  const routingDistance = Math.abs(pin1.x - pin2.x) + Math.abs(pin1.y - pin2.y)
+  const adaptiveElbow = calculateElbowForPins({
+    pin1,
+    pin2,
+    overshoot: Math.min(0.2, Math.max(0.02, routingDistance / 4)),
+  })
+  const adaptiveElbowIsShorter =
+    getPathLength(adaptiveElbow) < getPathLength(defaultElbow)
+  const defaultElbowBacktracks =
+    getPathLength(defaultElbow) > routingDistance + 1e-9
+  const shouldUseAdaptiveElbow =
+    findFirstCollision(adaptiveElbow, obstacles) === null &&
+    ((pinsFaceEachOther({ pin1, pin2 }) &&
+      defaultElbowBacktracks &&
+      adaptiveElbowIsShorter) ||
+      findFirstCollision(defaultElbow, obstacles) !== null)
+
+  return {
+    path:
+      directShortPath ??
+      (shouldUseAdaptiveElbow ? adaptiveElbow : defaultElbow),
+    isDirectShortPath: directShortPath !== null,
+  }
+}
+
 export class SchematicTraceSingleLineSolver2 extends BaseSolver {
   pins: MspConnectionPair["pins"]
   connectionPair?: MspConnectionPair
@@ -91,12 +144,18 @@ export class SchematicTraceSingleLineSolver2 extends BaseSolver {
 
   baseElbow: Point[]
   preferExteriorDetours: boolean
+  reserveNetLabelClearance: boolean
 
   solvedTracePath: Point[] | null = null
 
-  private queue: Array<{ path: Point[]; collisionRects: Set<ObstacleRect> }> =
-    []
+  private queue: Array<{
+    path: Point[]
+    collisionRects: Set<ObstacleRect>
+    directions: readonly [FacingDirection, FacingDirection]
+  }> = []
   private visited: Set<PathKey> = new Set()
+  private inferredPinIndexes = new Set<number>()
+  hasAmbiguousPinDirections = false
 
   constructor(params: {
     pins: MspConnectionPair["pins"]
@@ -104,6 +163,7 @@ export class SchematicTraceSingleLineSolver2 extends BaseSolver {
     inputProblem: InputProblem
     chipMap: Record<string, InputChip>
     preferExteriorDetours?: boolean
+    reserveNetLabelClearance?: boolean
   }) {
     super()
     this.pins = params.pins
@@ -111,19 +171,14 @@ export class SchematicTraceSingleLineSolver2 extends BaseSolver {
     this.inputProblem = params.inputProblem
     this.chipMap = params.chipMap
     this.preferExteriorDetours = params.preferExteriorDetours ?? true
-
-    // Ensure facing directions are present
-    for (const pin of this.pins) {
-      if (!pin._facingDirection) {
-        const chip = this.chipMap[pin.chipId]
-        pin._facingDirection = getPinDirection(pin, chip)
-      }
-    }
+    this.reserveNetLabelClearance = params.reserveNetLabelClearance ?? true
 
     // Build obstacle rects from chips and schematic text boxes. Text boxes are
     // padded by the label footprint for this net so labels have clearance too.
     this.obstacles = getObstacleRects(this.inputProblem, {
-      textBoxPadding: this.getTextBoxPaddingForConnectionPair(),
+      textBoxPadding: this.reserveNetLabelClearance
+        ? this.getTextBoxPaddingForConnectionPair()
+        : undefined,
     })
     this.textObstacles = new Set(this.obstacles.filter(isTextBoxObstacle))
     const endpointChipIds = new Set(this.pins.map((pin) => pin.chipId))
@@ -139,40 +194,71 @@ export class SchematicTraceSingleLineSolver2 extends BaseSolver {
         ),
     )
 
-    const [pin1, pin2] = this.pins
-    const directShortPath = calculateDirectShortPath(pin1, pin2)
-    const defaultElbow = calculateElbowForPins({
-      pin1,
-      pin2,
-      overshoot: 0.2,
-    })
-    const routingDistance =
-      Math.abs(pin1.x - pin2.x) + Math.abs(pin1.y - pin2.y)
-    const adaptiveElbow = calculateElbowForPins({
-      pin1,
-      pin2,
-      overshoot: Math.min(0.2, Math.max(0.02, routingDistance / 4)),
+    const directionOptions = this.pins.map((pin, pinIndex) => {
+      if (pin._facingDirection) return [pin._facingDirection]
+      this.inferredPinIndexes.add(pinIndex)
+      const connectedPin = this.pins[pinIndex === 0 ? 1 : 0]
+      return getPinDirectionCandidates(
+        pin,
+        this.chipMap[pin.chipId],
+        connectedPin,
+      )
     })
-    const adaptiveElbowIsShorter =
-      this.pathLength(adaptiveElbow) < this.pathLength(defaultElbow)
-    const defaultElbowBacktracks =
-      this.pathLength(defaultElbow) > routingDistance + 1e-9
-    const shouldUseAdaptiveElbow =
-      findFirstCollision(adaptiveElbow, this.obstacles) === null &&
-      ((pinsFaceEachOther({ pin1, pin2 }) &&
-        defaultElbowBacktracks &&
-        adaptiveElbowIsShorter) ||
-        findFirstCollision(defaultElbow, this.obstacles) !== null)
-
-    // Build initial elbow path
-    this.baseElbow = defaultElbow
-    if (shouldUseAdaptiveElbow) {
-      this.baseElbow = adaptiveElbow
+    const directionPairs = directionOptions[0]!.flatMap(
+      (firstDirection, firstIndex) =>
+        directionOptions[1]!.map((secondDirection, secondIndex) => ({
+          directions: [firstDirection, secondDirection] as const,
+          preferenceIndex: firstIndex + secondIndex,
+        })),
+    )
+    this.hasAmbiguousPinDirections = directionOptions.some(
+      (directions) => directions.length > 1,
+    )
+    const rankedDirectionPairs = directionPairs
+      .map(({ directions, preferenceIndex }) => {
+        const candidatePins = this.pins.map((pin, index) => ({
+          ...pin,
+          _facingDirection: directions[index]!,
+        })) as MspConnectionPair["pins"]
+        const initialPath = getInitialPathForPins({
+          pins: candidatePins,
+          obstacles: this.obstacles,
+        })
+        return {
+          directions,
+          baseElbow: initialPath.path,
+          isDirectShortPath: initialPath.isDirectShortPath,
+          preferenceIndex,
+          collisionCount:
+            findFirstCollision(initialPath.path, this.obstacles) === null
+              ? 0
+              : 1,
+          pathLength: getPathLength(initialPath.path),
+        }
+      })
+      .sort(
+        (first, second) =>
+          first.collisionCount - second.collisionCount ||
+          first.pathLength - second.pathLength ||
+          first.preferenceIndex - second.preferenceIndex,
+      )
+
+    const preferredCandidate = rankedDirectionPairs[0]!
+    for (const [pinIndex, pin] of this.pins.entries()) {
+      pin._facingDirection = preferredCandidate.directions[pinIndex]
     }
-    if (directShortPath) {
-      this.baseElbow = directShortPath
+
+    const [pin1, pin2] = this.pins
+    this.baseElbow = preferredCandidate.baseElbow
+
+    // Short paths are generated by a dedicated routine that validates both
+    // endpoint directions. Preserve the established behavior of accepting
+    // that local connection directly instead of sending it through obstacle
+    // detour search, which can turn overlapping endpoint symbols into two
+    // fallback labels.
+    if (preferredCandidate.isDirectShortPath) {
+      this.solvedTracePath = preferredCandidate.baseElbow
     }
-    this.solvedTracePath = directShortPath
 
     // Bounds defined by PA and PB
     this.aabb = aabbFromPoints(
@@ -180,9 +266,19 @@ export class SchematicTraceSingleLineSolver2 extends BaseSolver {
       { x: pin2.x, y: pin2.y },
     )
 
-    // Seed search
-    this.queue.push({ path: this.baseElbow, collisionRects: new Set() })
-    this.visited.add(pathKey(this.baseElbow))
+    // A corner pin has more than one geometrically valid outward direction.
+    // Seed each distinct elbow so obstacle routing, rather than component type,
+    // decides which direction is usable.
+    for (const candidate of rankedDirectionPairs) {
+      const key = pathKey(candidate.baseElbow)
+      if (this.visited.has(key)) continue
+      this.visited.add(key)
+      this.queue.push({
+        path: candidate.baseElbow,
+        collisionRects: new Set(),
+        directions: candidate.directions,
+      })
+    }
   }
 
   override getConstructorParams(): ConstructorParameters<
@@ -194,6 +290,7 @@ export class SchematicTraceSingleLineSolver2 extends BaseSolver {
       connectionPair: this.connectionPair,
       inputProblem: this.inputProblem,
       preferExteriorDetours: this.preferExteriorDetours,
+      reserveNetLabelClearance: this.reserveNetLabelClearance,
     }
   }
 
@@ -268,13 +365,7 @@ export class SchematicTraceSingleLineSolver2 extends BaseSolver {
   }
 
   private pathLength(pts: Point[]): number {
-    let sum = 0
-    for (let i = 0; i < pts.length - 1; i++) {
-      sum +=
-        Math.abs(pts[i + 1]!.x - pts[i]!.x) +
-        Math.abs(pts[i + 1]!.y - pts[i]!.y)
-    }
-    return sum
+    return getPathLength(pts)
   }
 
   private getPinBandPenalty(path: Point[]): number {
@@ -318,7 +409,7 @@ export class SchematicTraceSingleLineSolver2 extends BaseSolver {
       return
     }
 
-    const { path, collisionRects } = state
+    const { path, collisionRects, directions } = state
 
     const [PA, PB] = this.pins
     const collision = findFirstCollision(path, this.obstacles, {
@@ -409,8 +500,21 @@ export class SchematicTraceSingleLineSolver2 extends BaseSolver {
         Math.abs(p.x - q.x) < EPS && Math.abs(p.y - q.y) < EPS
       if (
         samePoint(first, { x: PA.x, y: PA.y }) &&
-        samePoint(last, { x: PB.x, y: PB.y })
+        samePoint(last, { x: PB.x, y: PB.y }) &&
+        (!this.hasAmbiguousPinDirections ||
+          pathMatchesPinDirections({
+            path,
+            pin1: { ...PA, _facingDirection: directions[0] },
+            pin2: { ...PB, _facingDirection: directions[1] },
+          }))
       ) {
+        for (const pinIndex of this.inferredPinIndexes) {
+          const direction =
+            pinIndex === 0
+              ? segmentDirection(path[0]!, path[1]!)
+              : segmentDirection(path.at(-1)!, path.at(-2)!)
+          if (direction) this.pins[pinIndex]!._facingDirection = direction
+        }
         this.solvedTracePath = path
         this.solved = true
       }
@@ -471,6 +575,7 @@ export class SchematicTraceSingleLineSolver2 extends BaseSolver {
         this.queue.push({
           path: detour,
           collisionRects: nextCollisionRects,
+          directions,
         })
       }
       return
@@ -630,7 +735,11 @@ export class SchematicTraceSingleLineSolver2 extends BaseSolver {
       (a, b) => a.length - b.length || a.pinBandPenalty - b.pinBandPenalty,
     )
     for (const st of newStates) {
-      this.queue.push({ path: st.path, collisionRects: st.collisionRects })
+      this.queue.push({
+        path: st.path,
+        collisionRects: st.collisionRects,
+        directions,
+      })
     }
   }
 

package/lib/solvers/TraceCleanupSolver/hasCollisionsWithLabels.ts

@@ -1,16 +1,121 @@
 import type { Point } from "@tscircuit/math-utils"
 import { segmentIntersectsRect } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions"
 
+type LabelBounds = {
+  minX: number
+  maxX: number
+  minY: number
+  maxY: number
+}
+
+const EPSILON = 1e-9
+
+const rangesMeetWithoutOverlap = (
+  firstMin: number,
+  firstMax: number,
+  secondMin: number,
+  secondMax: number,
+) =>
+  firstMax >= secondMin - EPSILON &&
+  secondMax >= firstMin - EPSILON &&
+  Math.min(firstMax, secondMax) - Math.max(firstMin, secondMin) <= EPSILON
+
+const pointsEqual = (first: Point, second: Point) =>
+  Math.abs(first.x - second.x) <= EPSILON &&
+  Math.abs(first.y - second.y) <= EPSILON
+
+const continuesExistingBoundarySegment = ({
+  start,
+  end,
+  label,
+  originalPath,
+}: {
+  start: Point
+  end: Point
+  label: LabelBounds
+  originalPath: Point[]
+}) => {
+  const isVertical = Math.abs(start.x - end.x) <= EPSILON
+  const isHorizontal = Math.abs(start.y - end.y) <= EPSILON
+  const isOnBoundary = isVertical
+    ? Math.abs(start.x - label.minX) <= EPSILON ||
+      Math.abs(start.x - label.maxX) <= EPSILON
+    : isHorizontal
+      ? Math.abs(start.y - label.minY) <= EPSILON ||
+        Math.abs(start.y - label.maxY) <= EPSILON
+      : false
+
+  if (!isOnBoundary) return false
+
+  for (let i = 0; i < originalPath.length - 1; i++) {
+    const isEndpointSegment = i === 0 || i === originalPath.length - 2
+    if (!isEndpointSegment) continue
+
+    const originalStart = originalPath[i]!
+    const originalEnd = originalPath[i + 1]!
+    const innerEndpoint = i === 0 ? originalEnd : originalStart
+    if (
+      !pointsEqual(start, innerEndpoint) &&
+      !pointsEqual(end, innerEndpoint)
+    ) {
+      continue
+    }
+    if (!segmentIntersectsRect(originalStart, originalEnd, label)) continue
+
+    if (
+      isVertical &&
+      Math.abs(originalStart.x - originalEnd.x) <= EPSILON &&
+      Math.abs(originalStart.x - start.x) <= EPSILON &&
+      rangesMeetWithoutOverlap(
+        Math.min(start.y, end.y),
+        Math.max(start.y, end.y),
+        Math.min(originalStart.y, originalEnd.y),
+        Math.max(originalStart.y, originalEnd.y),
+      )
+    ) {
+      return true
+    }
+
+    if (
+      isHorizontal &&
+      Math.abs(originalStart.y - originalEnd.y) <= EPSILON &&
+      Math.abs(originalStart.y - start.y) <= EPSILON &&
+      rangesMeetWithoutOverlap(
+        Math.min(start.x, end.x),
+        Math.max(start.x, end.x),
+        Math.min(originalStart.x, originalEnd.x),
+        Math.max(originalStart.x, originalEnd.x),
+      )
+    ) {
+      return true
+    }
+  }
+
+  return false
+}
+
 export const hasCollisionsWithLabels = (
   pathSegments: Point[],
-  labels: any[],
+  labels: LabelBounds[],
+  options: { originalPath?: Point[] } = {},
 ): boolean => {
   for (let i = 0; i < pathSegments.length - 1; i++) {
-    const p1 = pathSegments[i]
-    const p2 = pathSegments[i + 1]
+    const p1 = pathSegments[i]!
+    const p2 = pathSegments[i + 1]!
 
     for (const label of labels) {
       if (segmentIntersectsRect(p1, p2, label)) {
+        if (
+          options.originalPath &&
+          continuesExistingBoundarySegment({
+            start: p1,
+            end: p2,
+            label,
+            originalPath: options.originalPath,
+          })
+        ) {
+          continue
+        }
         return true
       }
     }