@tscircuit/schematic-trace-solver 0.0.105 → 0.0.107

package/lib/solvers/TraceCleanupSolver/minimizeTurnsWithFilteredLabels.ts

@@ -3,13 +3,18 @@ import { minimizeTurns } from "./turnMinimization"
 import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
 import { getObstacleRects } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/rect"
 import type { NetLabelPlacement } from "../NetLabelPlacementSolver/NetLabelPlacementSolver"
+import { countTurns } from "./countTurns"
+import {
+  getVisibleTraceLength,
+  getVisibleTraceSegmentCount,
+  RAIL_ALIGNMENT_EPSILON,
+} from "./sameNetRailAlignment/geometry"
 
 /**
- * Minimizes the turns of a target trace while considering different-net traces and labels as obstacles.
- * This function first identifies the target trace and separates traces from other nets, which are then treated as obstacles.
- * It also filters out labels that belong to the target trace's net, so they don't act as obstacles.
- * The function then combines static obstacles (from the input problem) with the other traces and filtered labels to create a comprehensive set of obstacles.
- * Finally, it uses a turn minimization algorithm to find a new path for the target trace that avoids these combined obstacles.
+ * Minimizes turns with a strict pass that treats every other trace as an
+ * obstacle and a relaxed pass that permits joining endpoint-sharing same-net
+ * branches. Equivalent-turn routes are compared by their rendered same-net
+ * complexity so aligned rails win without arbitrarily shifting local routes.
  */
 export const minimizeTurnsWithFilteredLabels = ({
   targetMspConnectionPairId,
@@ -33,27 +38,31 @@ export const minimizeTurnsWithFilteredLabels = ({
     throw new Error(`Target trace ${targetMspConnectionPairId} not found`)
   }
 
-  // Same-net traces are valid connection targets: letting the candidate path
-  // coincide with them removes unnecessary detours and forms clean junctions.
-  const obstacleTraces = traces.filter(
-    (t) =>
-      t.mspPairId !== targetMspConnectionPairId &&
-      t.globalConnNetId !== targetTrace.globalConnNetId,
+  const targetPinIds = new Set(targetTrace.pinIds)
+  const otherTraces = traces.filter(
+    (trace) => trace.mspPairId !== targetMspConnectionPairId,
   )
+  const relaxedObstacleTraces = otherTraces.filter((trace) => {
+    const sharesEndpoint = trace.pinIds.some((pinId) => targetPinIds.has(pinId))
+    return (
+      trace.globalConnNetId !== targetTrace.globalConnNetId || !sharesEndpoint
+    )
+  })
 
   const TRACE_WIDTH = 0.01
-  const traceObstacles = obstacleTraces.flatMap((trace, i) =>
-    trace.tracePath.slice(0, -1).map((p1, pi) => {
-      const p2 = trace.tracePath[pi + 1]!
-      return {
-        chipId: `trace-obstacle-${i}-${pi}`,
-        minX: Math.min(p1.x, p2.x) - TRACE_WIDTH / 2,
-        minY: Math.min(p1.y, p2.y) - TRACE_WIDTH / 2,
-        maxX: Math.max(p1.x, p2.x) + TRACE_WIDTH / 2,
-        maxY: Math.max(p1.y, p2.y) + TRACE_WIDTH / 2,
-      }
-    }),
-  )
+  const getTraceObstacles = (obstacleTraces: SolvedTracePath[]) =>
+    obstacleTraces.flatMap((trace, i) =>
+      trace.tracePath.slice(0, -1).map((p1, pi) => {
+        const p2 = trace.tracePath[pi + 1]!
+        return {
+          chipId: `trace-obstacle-${i}-${pi}`,
+          minX: Math.min(p1.x, p2.x) - TRACE_WIDTH / 2,
+          minY: Math.min(p1.y, p2.y) - TRACE_WIDTH / 2,
+          maxX: Math.max(p1.x, p2.x) + TRACE_WIDTH / 2,
+          maxY: Math.max(p1.y, p2.y) + TRACE_WIDTH / 2,
+        }
+      }),
+    )
 
   const staticObstaclesRaw = getObstacleRects(inputProblem)
   const PADDING = 0.01
@@ -65,8 +74,6 @@ export const minimizeTurnsWithFilteredLabels = ({
     maxY: obs.maxY + PADDING,
   }))
 
-  const combinedObstacles = [...staticObstacles, ...traceObstacles]
-
   const originalPath = targetTrace.tracePath
   const filteredLabels = allLabelPlacements.filter((label) => {
     const originalNetIds = mergedLabelNetIdMap[label.globalConnNetId]
@@ -83,13 +90,57 @@ export const minimizeTurnsWithFilteredLabels = ({
     maxY: nl.center.y + nl.height / 2 + paddingBuffer,
   }))
 
-  const newPath = minimizeTurns({
+  const strictPath = minimizeTurns({
     path: originalPath,
-    obstacles: combinedObstacles,
+    obstacles: [...staticObstacles, ...getTraceObstacles(otherTraces)],
     labelBounds,
     originalPath: originalPath,
   })
 
+  const relaxedPath = minimizeTurns({
+    path: originalPath,
+    obstacles: [
+      ...staticObstacles,
+      ...getTraceObstacles(relaxedObstacleTraces),
+    ],
+    labelBounds,
+    originalPath: originalPath,
+  })
+
+  const sameNetTraces = otherTraces.filter(
+    (trace) => trace.globalConnNetId === targetTrace.globalConnNetId,
+  )
+  const getSameNetReadability = (tracePath: SolvedTracePath["tracePath"]) => {
+    const tracesWithCandidate = [
+      ...sameNetTraces,
+      { ...targetTrace, tracePath },
+    ]
+    return {
+      segmentCount: getVisibleTraceSegmentCount(tracesWithCandidate),
+      visibleLength: getVisibleTraceLength(tracesWithCandidate),
+    }
+  }
+
+  const strictTurns = countTurns(strictPath)
+  const relaxedTurns = countTurns(relaxedPath)
+  let newPath = strictPath
+
+  if (relaxedTurns < strictTurns) {
+    newPath = relaxedPath
+  } else if (relaxedTurns === strictTurns) {
+    const strictReadability = getSameNetReadability(strictPath)
+    const relaxedReadability = getSameNetReadability(relaxedPath)
+
+    if (
+      relaxedReadability.segmentCount < strictReadability.segmentCount ||
+      (relaxedReadability.segmentCount === strictReadability.segmentCount &&
+        relaxedReadability.visibleLength <
+          strictReadability.visibleLength - RAIL_ALIGNMENT_EPSILON)
+    ) {
+      newPath = relaxedPath
+    }
+  }
+
   return {
     ...targetTrace,
     tracePath: newPath,

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

@@ -48,7 +48,7 @@ interface Interval {
   max: number
 }
 
-const getMergedIntervalLength = (intervals: Interval[]) => {
+const getMergedIntervalMetrics = (intervals: Interval[]) => {
   const groups: Interval[][] = []
   for (const interval of intervals) {
     const group = groups.find((items) =>
@@ -58,28 +58,35 @@ const getMergedIntervalLength = (intervals: Interval[]) => {
     else groups.push([interval])
   }
 
-  return groups.reduce((total, group) => {
-    const sorted = [...group].sort((a, b) => a.min - b.min)
-    let groupLength = 0
-    let currentMin = sorted[0]!.min
-    let currentMax = sorted[0]!.max
-
-    for (const interval of sorted.slice(1)) {
-      if (interval.min <= currentMax + RAIL_ALIGNMENT_EPSILON) {
-        currentMax = Math.max(currentMax, interval.max)
-      } else {
-        groupLength += currentMax - currentMin
-        currentMin = interval.min
-        currentMax = interval.max
+  return groups.reduce(
+    (total, group) => {
+      const sorted = [...group].sort((a, b) => a.min - b.min)
+      let groupLength = 0
+      let segmentCount = 1
+      let currentMin = sorted[0]!.min
+      let currentMax = sorted[0]!.max
+
+      for (const interval of sorted.slice(1)) {
+        if (interval.min <= currentMax + RAIL_ALIGNMENT_EPSILON) {
+          currentMax = Math.max(currentMax, interval.max)
+        } else {
+          groupLength += currentMax - currentMin
+          segmentCount++
+          currentMin = interval.min
+          currentMax = interval.max
+        }
       }
-    }
 
-    return total + groupLength + currentMax - currentMin
-  }, 0)
+      return {
+        length: total.length + groupLength + currentMax - currentMin,
+        segmentCount: total.segmentCount + segmentCount,
+      }
+    },
+    { length: 0, segmentCount: 0 },
+  )
 }
 
-/** Returns rendered length after overlapping collinear runs are merged. */
-export const getVisibleTraceLength = (traces: SolvedTracePath[]) => {
+const getVisibleTraceMetrics = (traces: SolvedTracePath[]) => {
   const horizontal: Interval[] = []
   const vertical: Interval[] = []
 
@@ -104,5 +111,18 @@ export const getVisibleTraceLength = (traces: SolvedTracePath[]) => {
     }
   }
 
-  return getMergedIntervalLength(horizontal) + getMergedIntervalLength(vertical)
+  const horizontalMetrics = getMergedIntervalMetrics(horizontal)
+  const verticalMetrics = getMergedIntervalMetrics(vertical)
+  return {
+    length: horizontalMetrics.length + verticalMetrics.length,
+    segmentCount: horizontalMetrics.segmentCount + verticalMetrics.segmentCount,
+  }
 }
+
+/** Returns rendered length after overlapping collinear runs are merged. */
+export const getVisibleTraceLength = (traces: SolvedTracePath[]) =>
+  getVisibleTraceMetrics(traces).length
+
+/** Returns the number of distinct collinear runs visible on the schematic. */
+export const getVisibleTraceSegmentCount = (traces: SolvedTracePath[]) =>
+  getVisibleTraceMetrics(traces).segmentCount

package/lib/solvers/TraceCleanupSolver/sub-solver/UntangleTraceSubsolver.ts

@@ -6,8 +6,14 @@ import { ChipObstacleSpatialIndex } from "lib/data-structures/ChipObstacleSpatia
 
 import { findAllLShapedTurns, type LShape } from "./findAllLShapedTurns"
 import { getTraceObstacles } from "./getTraceObstacles"
-import { findIntersectionsWithObstacles } from "./findIntersectionsWithObstacles"
-import { generateLShapeRerouteCandidates } from "./generateLShapeRerouteCandidates"
+import {
+  findIntersectionsWithObstacles,
+  findPerpendicularPathCrossings,
+} from "./findIntersectionsWithObstacles"
+import {
+  generateLShapeRerouteCandidates,
+  generatePerpendicularTraceDetours,
+} from "./generateLShapeRerouteCandidates"
 import { isPathColliding, type CollisionInfo } from "./isPathColliding"
 import {
   generateRectangleCandidates,
@@ -24,6 +30,19 @@ import { visualizeTightRectangle } from "../visualizeTightRectangle"
 import { visualizeCandidates } from "./visualizeCandidates"
 import { mergeGraphicsObjects } from "../mergeGraphicsObjects"
 import { visualizeCollision } from "./visualizeCollision"
+import {
+  getPathLength,
+  isPathCollidingWithChipInterior,
+} from "../../Example28Solver/geometry"
+import { getObstacleRects } from "../../SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/rect"
+
+interface TraceCrossing {
+  trace: SolvedTracePath
+  segmentIndex: number
+  otherTrace: SolvedTracePath
+  otherSegmentIndex: number
+  isInitialBundleCrossing: boolean
+}
 
 /**
  * Defines the input structure for the UntangleTraceSubsolver.
@@ -60,6 +79,9 @@ export class UntangleTraceSubsolver extends BaseSolver {
   private input: UntangleTraceSubsolverInput
   private chipObstacleSpatialIndex: ChipObstacleSpatialIndex
   private lShapesToProcess: LShape[] = []
+  private ignoredCrossings = new Set<string>()
+  private reroutedTraceIds = new Set<string>()
+  private processingCrossings = true
   private visualizationMode: VisualizationMode = "l_shapes"
 
   private currentLShape: LShape | null = null
@@ -95,13 +117,6 @@ export class UntangleTraceSubsolver extends BaseSolver {
       this.input.inputProblem._chipObstacleSpatialIndex =
         this.chipObstacleSpatialIndex
     }
-
-    for (const trace of this.input.allTraces) {
-      const lShapes = findAllLShapedTurns(trace.tracePath)
-      this.lShapesToProcess.push(
-        ...lShapes.map((l) => ({ ...l, traceId: trace.mspPairId as string })),
-      )
-    }
   }
 
   override _step(): void {
@@ -110,6 +125,21 @@ export class UntangleTraceSubsolver extends BaseSolver {
       return
     }
 
+    if (this.processingCrossings) {
+      // The L-shape pass below only reacts when both arms intersect obstacles.
+      // Resolve strict crossings on merged-label bundles before entering it.
+      const crossing = this._findCrossing()
+      if (crossing) {
+        if (!this._resolveCrossing(crossing)) {
+          this.ignoredCrossings.add(this._crossingKey(crossing))
+        }
+        return
+      }
+      this.processingCrossings = false
+      this._initializeLShapes()
+      return
+    }
+
     if (this.lShapeJustProcessed) {
       this._resetAfterLShapProcessing()
       return
@@ -136,6 +166,145 @@ export class UntangleTraceSubsolver extends BaseSolver {
     }
   }
 
+  private _initializeLShapes() {
+    for (const trace of this.input.allTraces) {
+      this.lShapesToProcess.push(
+        ...findAllLShapedTurns(trace.tracePath).map((lShape) => ({
+          ...lShape,
+          traceId: trace.mspPairId,
+        })),
+      )
+    }
+  }
+
+  private _crossingKey(crossing: TraceCrossing) {
+    return `${crossing.trace.mspPairId}:${crossing.segmentIndex}:${crossing.otherTrace.mspPairId}:${crossing.otherSegmentIndex}`
+  }
+
+  private _isTraceBundle(first: SolvedTracePath, second: SolvedTracePath) {
+    const componentPair = (trace: SolvedTracePath) =>
+      trace.pins
+        .map((pin) => pin.chipId)
+        .sort()
+        .join(":")
+    if (componentPair(first) !== componentPair(second)) return false
+
+    return Object.values(this.input.mergedLabelNetIdMap).some(
+      (netIds) =>
+        netIds.has(first.globalConnNetId) && netIds.has(second.globalConnNetId),
+    )
+  }
+
+  private _findCrossing(): TraceCrossing | null {
+    const traces = this.input.allTraces
+    for (let firstIndex = 0; firstIndex < traces.length; firstIndex++) {
+      const trace = traces[firstIndex]!
+      for (
+        let secondIndex = firstIndex + 1;
+        secondIndex < traces.length;
+        secondIndex++
+      ) {
+        const otherTrace = traces[secondIndex]!
+        if (trace.globalConnNetId === otherTrace.globalConnNetId) continue
+        const isInitialBundleCrossing = this._isTraceBundle(trace, otherTrace)
+        if (
+          !isInitialBundleCrossing &&
+          !this.reroutedTraceIds.has(trace.mspPairId) &&
+          !this.reroutedTraceIds.has(otherTrace.mspPairId)
+        ) {
+          continue
+        }
+
+        const crossings = findPerpendicularPathCrossings(
+          trace.tracePath,
+          otherTrace.tracePath,
+        )
+        for (const { pathSegmentIndex, otherPathSegmentIndex } of crossings) {
+          const crossing = {
+            trace,
+            segmentIndex: pathSegmentIndex,
+            otherTrace,
+            otherSegmentIndex: otherPathSegmentIndex,
+            isInitialBundleCrossing,
+          }
+          if (!this.ignoredCrossings.has(this._crossingKey(crossing))) {
+            return crossing
+          }
+        }
+      }
+    }
+    return null
+  }
+
+  private _resolveCrossing(crossing: TraceCrossing) {
+    const chipBounds = this.chipObstacleSpatialIndex.chips.map(
+      (chip) => chip.bounds,
+    )
+    const candidates = [
+      ...generatePerpendicularTraceDetours({
+        trace: crossing.trace,
+        segmentIndex: crossing.segmentIndex,
+        obstacleStart:
+          crossing.otherTrace.tracePath[crossing.otherSegmentIndex]!,
+        obstacleEnd:
+          crossing.otherTrace.tracePath[crossing.otherSegmentIndex + 1]!,
+        chipBounds,
+        clearance: this.input.paddingBuffer,
+      }),
+      ...generatePerpendicularTraceDetours({
+        trace: crossing.otherTrace,
+        segmentIndex: crossing.otherSegmentIndex,
+        obstacleStart: crossing.trace.tracePath[crossing.segmentIndex]!,
+        obstacleEnd: crossing.trace.tracePath[crossing.segmentIndex + 1]!,
+        chipBounds,
+        clearance: this.input.paddingBuffer,
+      }),
+    ]
+    const chipObstacles = getObstacleRects(this.input.inputProblem).filter(
+      (obstacle) => obstacle.kind === "chip",
+    )
+    // Prefer a globally clear route. If the initial bundle detour transfers
+    // the crossing, continue rip-up/reroute from that moved trace until clear.
+    const validCandidates = candidates
+      .map((candidate) => ({
+        ...candidate,
+        collision: isPathColliding(
+          candidate.path,
+          this.input.allTraces,
+          candidate.traceId,
+        ),
+      }))
+      .filter(
+        (candidate) =>
+          !isPathCollidingWithChipInterior(candidate.path, chipObstacles) &&
+          !isPathColliding(
+            candidate.path,
+            [crossing.trace, crossing.otherTrace],
+            candidate.traceId,
+          ).isColliding &&
+          (crossing.isInitialBundleCrossing ||
+            !candidate.collision.isColliding),
+      )
+      .sort(
+        (first, second) =>
+          Number(first.collision.isColliding) -
+            Number(second.collision.isColliding) ||
+          getPathLength(first.path) - getPathLength(second.path),
+      )
+    const bestCandidate = validCandidates[0]
+    if (!bestCandidate) return false
+
+    const traceIndex = this.input.allTraces.findIndex(
+      (trace) => trace.mspPairId === bestCandidate.traceId,
+    )
+    this.input.allTraces[traceIndex] = {
+      ...this.input.allTraces[traceIndex]!,
+      tracePath: bestCandidate.path,
+    }
+    this.reroutedTraceIds.add(bestCandidate.traceId)
+    return true
+  }
+
   private _resetAfterLShapProcessing() {
     this.lShapeProcessingStep = "idle"
     this.currentLShape = null

package/lib/solvers/TraceCleanupSolver/sub-solver/findIntersectionsWithObstacles.ts

@@ -2,6 +2,13 @@ import type { Point } from "@tscircuit/math-utils"
 import { getSegmentIntersection } from "@tscircuit/math-utils/line-intersections"
 import type { TraceObstacle } from "./getTraceObstacles"
 
+const EPS = 1e-6
+
+export interface PerpendicularPathCrossing {
+  pathSegmentIndex: number
+  otherPathSegmentIndex: number
+}
+
 /**
  * Finds all intersection points between a given line segment (p1-p2) and a list of trace obstacles.
  * It iterates through each segment of every obstacle and checks for intersections with the input segment.
@@ -34,3 +41,55 @@ export const findIntersectionsWithObstacles = (
 
   return intersections
 }
+
+const isSamePoint = (first: Point, second: Point) =>
+  Math.abs(first.x - second.x) < EPS && Math.abs(first.y - second.y) < EPS
+
+export const findPerpendicularPathCrossings = (
+  path: Point[],
+  otherPath: Point[],
+): PerpendicularPathCrossing[] => {
+  const crossings: PerpendicularPathCrossing[] = []
+
+  // Terminal segments connect to pins and are allowed to meet other traces at
+  // their endpoints. Only internal, strict crossings need to be untangled.
+  for (
+    let pathSegmentIndex = 1;
+    pathSegmentIndex < path.length - 2;
+    pathSegmentIndex++
+  ) {
+    const start = path[pathSegmentIndex]!
+    const end = path[pathSegmentIndex + 1]!
+    const isVertical = Math.abs(start.x - end.x) < EPS
+
+    for (
+      let otherPathSegmentIndex = 1;
+      otherPathSegmentIndex < otherPath.length - 2;
+      otherPathSegmentIndex++
+    ) {
+      const otherStart = otherPath[otherPathSegmentIndex]!
+      const otherEnd = otherPath[otherPathSegmentIndex + 1]!
+      const otherIsVertical = Math.abs(otherStart.x - otherEnd.x) < EPS
+      if (isVertical === otherIsVertical) continue
+
+      const intersection = getSegmentIntersection(
+        start,
+        end,
+        otherStart,
+        otherEnd,
+      )
+      if (
+        !intersection ||
+        [start, end, otherStart, otherEnd].some((point) =>
+          isSamePoint(point, intersection),
+        )
+      ) {
+        continue
+      }
+
+      crossings.push({ pathSegmentIndex, otherPathSegmentIndex })
+    }
+  }
+
+  return crossings
+}

package/lib/solvers/TraceCleanupSolver/sub-solver/generateLShapeRerouteCandidates.ts

@@ -1,6 +1,8 @@
-import type { Point } from "@tscircuit/math-utils"
+import type { Bounds, Point } from "@tscircuit/math-utils"
 import type { LShape } from "./findAllLShapedTurns"
 import type { Rectangle } from "./generateRectangleCandidates"
+import type { SolvedTracePath } from "../../SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import { simplifyPath } from "../simplifyPath"
 
 const EPS = 1e-6
 
@@ -105,3 +107,64 @@ export const generateLShapeRerouteCandidates = ({
 
   return [[i1_padded, c2, i2_padded]]
 }
+
+export interface PerpendicularTraceDetourInput {
+  trace: SolvedTracePath
+  segmentIndex: number
+  obstacleStart: Point
+  obstacleEnd: Point
+  chipBounds: Bounds[]
+  clearance: number
+}
+
+export interface TraceDetourCandidate {
+  traceId: string
+  path: Point[]
+}
+
+export const generatePerpendicularTraceDetours = ({
+  trace,
+  segmentIndex,
+  obstacleStart,
+  obstacleEnd,
+  chipBounds,
+  clearance,
+}: PerpendicularTraceDetourInput): TraceDetourCandidate[] => {
+  const buildDetours = (path: Point[], index: number) => {
+    const start = path[index]!
+    const end = path[index + 1]!
+    const movingAxis: "x" | "y" = Math.abs(start.x - end.x) < EPS ? "y" : "x"
+    const detourAxis = movingAxis === "x" ? "y" : "x"
+    const gate =
+      obstacleStart[movingAxis] +
+      Math.sign(start[movingAxis] - obstacleStart[movingAxis]) * clearance
+    const obstacleRange = [obstacleStart[detourAxis], obstacleEnd[detourAxis]]
+    const lowBound = detourAxis === "x" ? "minX" : "minY"
+    const highBound = detourAxis === "x" ? "maxX" : "maxY"
+    const detourCoordinates = [
+      Math.min(...obstacleRange) - clearance,
+      Math.max(...obstacleRange) + clearance,
+      ...chipBounds.flatMap((bounds) => [
+        bounds[lowBound] - clearance,
+        bounds[highBound] + clearance,
+      ]),
+    ]
+
+    return [...new Set(detourCoordinates)].map((detour) =>
+      simplifyPath([
+        ...path.slice(0, index + 1),
+        { ...start, [movingAxis]: gate },
+        { ...start, [movingAxis]: gate, [detourAxis]: detour },
+        { ...end, [detourAxis]: detour },
+        ...path.slice(index + 2),
+      ]),
+    )
+  }
+
+  const reversedPath = [...trace.tracePath].reverse()
+  const reversedIndex = trace.tracePath.length - 2 - segmentIndex
+  return [
+    ...buildDetours(trace.tracePath, segmentIndex),
+    ...buildDetours(reversedPath, reversedIndex).map((path) => path.reverse()),
+  ].map((path) => ({ traceId: trace.mspPairId, path }))
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tscircuit/schematic-trace-solver",
   "main": "dist/index.js",
-  "version": "0.0.105",
+  "version": "0.0.107",
   "type": "module",
   "scripts": {
     "start": "cosmos",