@tscircuit/schematic-trace-solver 0.0.168 → 0.0.170

package/lib/solvers/NetLabelToTraceSolver/NetLabelToTraceSolver.ts

@@ -5,15 +5,17 @@ import {
 } from "@tscircuit/math-utils"
 import type { GraphicsObject } from "graphics-debug"
 import { BaseSolver } from "lib/solvers/BaseSolver/BaseSolver"
-import { getConnectivityMapsFromInputProblem } from "lib/solvers/MspConnectionPairSolver/getConnectivityMapFromInputProblem"
 import { doesPairCrossRestrictedCenterLines } from "lib/solvers/MspConnectionPairSolver/doesPairCrossRestrictedCenterLines"
+import { getConnectivityMapsFromInputProblem } from "lib/solvers/MspConnectionPairSolver/getConnectivityMapFromInputProblem"
 import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
+import { doesTraceRecoveryPathConflict } from "lib/solvers/NetLabelTraceRecovery/doesTraceRecoveryPathConflict"
 import {
   getTraceRecoveryConnectivityMaps,
   type TraceRecoveryPin,
 } from "lib/solvers/NetLabelTraceRecovery/getTraceRecoveryConnectivityMaps"
 import { getTraceConnectedPinComponents } from "lib/solvers/SchematicTraceLinesSolver/getTraceConnectedPinComponents"
 import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import { findFirstCollision } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions"
 import { SchematicTraceSingleLineSolver2 } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/SchematicTraceSingleLineSolver2"
 import type {
   ChipId,
@@ -22,12 +24,12 @@ import type {
   PinId,
 } from "lib/types/InputProblem"
 import { arePinsInDifferentSchematicSections } from "lib/utils/arePinsInDifferentSchematicSections"
-import { doesTraceOverlapWithExistingTraces } from "lib/utils/does-trace-overlap-with-existing-traces"
 import {
-  type InlineNetLabelPlacement,
   type InlineNetLabelOutput,
+  type InlineNetLabelPlacement,
   visualizeInlineNetLabelOutput,
 } from "../InlineNetLabelSolver/InlineNetLabelSolver"
+import { reduceTraceCrossings } from "./reduceTraceCrossings"
 
 type GlobalConnNetId = NetLabelPlacement["globalConnNetId"]
 
@@ -420,7 +422,7 @@ export class NetLabelToTraceSolver extends BaseSolver {
 
   private tryAcceptCurrentRoute() {
     const candidate = this.currentCandidate
-    const tracePath = this.activeSubSolver?.solvedTracePath
+    let tracePath = this.activeSubSolver?.solvedTracePath
     if (!candidate || !tracePath) return
 
     const retainedTraces = this.outputTraces.filter(
@@ -434,12 +436,23 @@ export class NetLabelToTraceSolver extends BaseSolver {
       )
     }
     if (
-      doesTraceOverlapWithExistingTraces(tracePath, collisionTraces) ||
+      doesTraceRecoveryPathConflict(tracePath, collisionTraces) ||
       this.routeIntersectsRemainingLabels(tracePath, candidate)
     ) {
       return
     }
 
+    tracePath = reduceTraceCrossings({
+      tracePath,
+      globalConnNetId: candidate.firstLabel.globalConnNetId,
+      otherTraces: collisionTraces,
+      isCandidateValid: (candidatePath) =>
+        findFirstCollision(candidatePath, this.activeSubSolver!.obstacles) ===
+          null &&
+        !doesTraceRecoveryPathConflict(candidatePath, collisionTraces) &&
+        !this.routeIntersectsRemainingLabels(candidatePath, candidate),
+    })
+
     const [firstPin, secondPin] = candidate.pins
     const mspPairId = `${RECOVERED_TRACE_PREFIX}${candidate.key}`
     const recoveredTrace: SolvedTracePath = {

package/lib/solvers/NetLabelToTraceSolver/reduceTraceCrossings.ts

@@ -0,0 +1,180 @@
+import type { Point } from "@tscircuit/math-utils"
+import {
+  countPathIntersections,
+  getPathLength,
+  segmentsIntersect,
+} from "lib/solvers/Example28Solver/geometry"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+
+const EPS = 1e-9
+
+const isHorizontal = (start: Point, end: Point) =>
+  Math.abs(start.y - end.y) < EPS
+
+const isVertical = (start: Point, end: Point) => Math.abs(start.x - end.x) < EPS
+
+const compactConsecutivePoints = (path: Point[]) =>
+  path.filter((point, index) => {
+    const previousPoint = path[index - 1]
+    return (
+      !previousPoint ||
+      Math.abs(point.x - previousPoint.x) >= EPS ||
+      Math.abs(point.y - previousPoint.y) >= EPS
+    )
+  })
+
+const isValidOrthogonalPath = (path: Point[]) => {
+  if (
+    path.length < 2 ||
+    !path.every((point, index) => {
+      const nextPoint = path[index + 1]
+      if (!nextPoint) return true
+      return isHorizontal(point, nextPoint) || isVertical(point, nextPoint)
+    })
+  ) {
+    return false
+  }
+
+  for (
+    let firstSegmentIndex = 0;
+    firstSegmentIndex < path.length - 1;
+    firstSegmentIndex++
+  ) {
+    for (
+      let secondSegmentIndex = firstSegmentIndex + 2;
+      secondSegmentIndex < path.length - 1;
+      secondSegmentIndex++
+    ) {
+      if (
+        segmentsIntersect(
+          path[firstSegmentIndex]!,
+          path[firstSegmentIndex + 1]!,
+          path[secondSegmentIndex]!,
+          path[secondSegmentIndex + 1]!,
+        )
+      ) {
+        return false
+      }
+    }
+  }
+
+  return true
+}
+
+const getEndpointAlignedSegmentCandidates = (tracePath: Point[]) => {
+  const candidates: Point[][] = []
+
+  // Preserve the terminal segment at each pin. For an interior segment whose
+  // neighboring segments are perpendicular, align it with either neighboring
+  // endpoint corridor. This keeps the same orthogonal topology while allowing
+  // a midpoint elbow to move away from avoidable trace crossings.
+  for (
+    let segmentIndex = 2;
+    segmentIndex <= tracePath.length - 4;
+    segmentIndex++
+  ) {
+    const previousPoint = tracePath[segmentIndex - 1]!
+    const start = tracePath[segmentIndex]!
+    const end = tracePath[segmentIndex + 1]!
+    const nextPoint = tracePath[segmentIndex + 2]!
+    const segmentIsVertical = isVertical(start, end)
+    const segmentIsHorizontal = isHorizontal(start, end)
+
+    if (
+      (!segmentIsVertical && !segmentIsHorizontal) ||
+      (segmentIsVertical &&
+        (!isHorizontal(previousPoint, start) ||
+          !isHorizontal(end, nextPoint))) ||
+      (segmentIsHorizontal &&
+        (!isVertical(previousPoint, start) || !isVertical(end, nextPoint)))
+    ) {
+      continue
+    }
+
+    const alignedCoordinates = segmentIsVertical
+      ? [previousPoint.x, nextPoint.x]
+      : [previousPoint.y, nextPoint.y]
+    for (const alignedCoordinate of alignedCoordinates) {
+      if (
+        Math.abs(alignedCoordinate - (segmentIsVertical ? start.x : start.y)) <
+        EPS
+      ) {
+        continue
+      }
+
+      const candidate = tracePath.map((point) => ({ ...point }))
+      if (segmentIsVertical) {
+        candidate[segmentIndex]!.x = alignedCoordinate
+        candidate[segmentIndex + 1]!.x = alignedCoordinate
+      } else {
+        candidate[segmentIndex]!.y = alignedCoordinate
+        candidate[segmentIndex + 1]!.y = alignedCoordinate
+      }
+
+      const compactedCandidate = compactConsecutivePoints(candidate)
+      if (isValidOrthogonalPath(compactedCandidate)) {
+        candidates.push(compactedCandidate)
+      }
+    }
+  }
+
+  return candidates
+}
+
+const countOtherNetCrossings = ({
+  tracePath,
+  globalConnNetId,
+  otherTraces,
+}: {
+  tracePath: Point[]
+  globalConnNetId: string
+  otherTraces: SolvedTracePath[]
+}) =>
+  otherTraces.reduce(
+    (crossingCount, otherTrace) =>
+      crossingCount +
+      (otherTrace.globalConnNetId === globalConnNetId
+        ? 0
+        : countPathIntersections(tracePath, otherTrace.tracePath)),
+    0,
+  )
+
+export const reduceTraceCrossings = ({
+  tracePath,
+  globalConnNetId,
+  otherTraces,
+  isCandidateValid,
+}: {
+  tracePath: Point[]
+  globalConnNetId: string
+  otherTraces: SolvedTracePath[]
+  isCandidateValid: (candidate: Point[]) => boolean
+}) => {
+  let bestPath = tracePath
+  let bestCrossingCount = countOtherNetCrossings({
+    tracePath,
+    globalConnNetId,
+    otherTraces,
+  })
+  let bestPathLength = getPathLength(tracePath)
+
+  for (const candidate of getEndpointAlignedSegmentCandidates(tracePath)) {
+    if (!isCandidateValid(candidate)) continue
+    const crossingCount = countOtherNetCrossings({
+      tracePath: candidate,
+      globalConnNetId,
+      otherTraces,
+    })
+    const pathLength = getPathLength(candidate)
+    if (
+      crossingCount < bestCrossingCount ||
+      (crossingCount === bestCrossingCount && pathLength < bestPathLength)
+    ) {
+      bestPath = candidate
+      bestCrossingCount = crossingCount
+      bestPathLength = pathLength
+    }
+  }
+
+  return bestPath
+}

package/lib/solvers/NetLabelTraceRecovery/doesTraceRecoveryPathConflict.ts

@@ -0,0 +1,112 @@
+import { doSegmentsIntersect, type Point } from "@tscircuit/math-utils"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+
+const EPSILON = 1e-6
+
+const isStrictlyBetween = ({
+  coordinate,
+  segmentStartCoordinate,
+  segmentEndCoordinate,
+}: {
+  coordinate: number
+  segmentStartCoordinate: number
+  segmentEndCoordinate: number
+}) =>
+  coordinate >
+    Math.min(segmentStartCoordinate, segmentEndCoordinate) + EPSILON &&
+  coordinate < Math.max(segmentStartCoordinate, segmentEndCoordinate) - EPSILON
+
+const isStrictInteriorPerpendicularCrossing = ({
+  firstSegmentStart,
+  firstSegmentEnd,
+  secondSegmentStart,
+  secondSegmentEnd,
+}: {
+  firstSegmentStart: Point
+  firstSegmentEnd: Point
+  secondSegmentStart: Point
+  secondSegmentEnd: Point
+}) => {
+  const firstIsHorizontal =
+    Math.abs(firstSegmentStart.y - firstSegmentEnd.y) <= EPSILON
+  const firstIsVertical =
+    Math.abs(firstSegmentStart.x - firstSegmentEnd.x) <= EPSILON
+  const secondIsHorizontal =
+    Math.abs(secondSegmentStart.y - secondSegmentEnd.y) <= EPSILON
+  const secondIsVertical =
+    Math.abs(secondSegmentStart.x - secondSegmentEnd.x) <= EPSILON
+
+  let horizontalStart: Point
+  let horizontalEnd: Point
+  if (firstIsHorizontal) {
+    horizontalStart = firstSegmentStart
+    horizontalEnd = firstSegmentEnd
+  } else if (secondIsHorizontal) {
+    horizontalStart = secondSegmentStart
+    horizontalEnd = secondSegmentEnd
+  } else {
+    return false
+  }
+
+  let verticalStart: Point
+  let verticalEnd: Point
+  if (firstIsVertical) {
+    verticalStart = firstSegmentStart
+    verticalEnd = firstSegmentEnd
+  } else if (secondIsVertical) {
+    verticalStart = secondSegmentStart
+    verticalEnd = secondSegmentEnd
+  } else {
+    return false
+  }
+
+  return (
+    isStrictlyBetween({
+      coordinate: verticalStart.x,
+      segmentStartCoordinate: horizontalStart.x,
+      segmentEndCoordinate: horizontalEnd.x,
+    }) &&
+    isStrictlyBetween({
+      coordinate: horizontalStart.y,
+      segmentStartCoordinate: verticalStart.y,
+      segmentEndCoordinate: verticalEnd.y,
+    })
+  )
+}
+
+export const doesTraceRecoveryPathConflict = (
+  tracePath: Point[],
+  collisionTraces: SolvedTracePath[],
+) => {
+  for (let pathIndex = 0; pathIndex < tracePath.length - 1; pathIndex++) {
+    const pathStart = tracePath[pathIndex]!
+    const pathEnd = tracePath[pathIndex + 1]!
+
+    for (const trace of collisionTraces) {
+      for (
+        let traceIndex = 0;
+        traceIndex < trace.tracePath.length - 1;
+        traceIndex++
+      ) {
+        const traceStart = trace.tracePath[traceIndex]!
+        const traceEnd = trace.tracePath[traceIndex + 1]!
+        if (!doSegmentsIntersect(pathStart, pathEnd, traceStart, traceEnd)) {
+          continue
+        }
+        if (
+          isStrictInteriorPerpendicularCrossing({
+            firstSegmentStart: pathStart,
+            firstSegmentEnd: pathEnd,
+            secondSegmentStart: traceStart,
+            secondSegmentEnd: traceEnd,
+          })
+        ) {
+          continue
+        }
+        return true
+      }
+    }
+  }
+
+  return false
+}

package/package.json

@@ -5,7 +5,7 @@
     "url": "https://github.com/tscircuit/schematic-trace-solver.git"
   },
   "main": "dist/index.js",
-  "version": "0.0.168",
+  "version": "0.0.170",
   "type": "module",
   "scripts": {
     "start": "cosmos",