@tscircuit/schematic-trace-solver 0.0.106 → 0.0.107

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.106",
+  "version": "0.0.107",
   "type": "module",
   "scripts": {
     "start": "cosmos",