@tscircuit/schematic-trace-solver 0.0.169 → 0.0.171

package/lib/solvers/NetLabelToTraceSolver/NetLabelToTraceSolver.ts

@@ -5,16 +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 { doesTraceRecoveryPathConflict } from "lib/solvers/NetLabelTraceRecovery/doesTraceRecoveryPathConflict"
 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,
@@ -24,10 +25,11 @@ import type {
 } from "lib/types/InputProblem"
 import { arePinsInDifferentSchematicSections } from "lib/utils/arePinsInDifferentSchematicSections"
 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(
@@ -440,6 +442,17 @@ export class NetLabelToTraceSolver extends BaseSolver {
       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/package.json

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