@tscircuit/schematic-trace-solver 0.0.168 → 0.0.169

package/dist/index.js

@@ -15296,6 +15296,82 @@ var getTraceRecoveryConnectivityMaps = (inputProblem) => {
   return { chipMap, pinMap };
 };
 
+// lib/solvers/NetLabelTraceRecovery/doesTraceRecoveryPathConflict.ts
+import { doSegmentsIntersect as doSegmentsIntersect4 } from "@tscircuit/math-utils";
+var EPSILON = 1e-6;
+var isStrictlyBetween2 = ({
+  coordinate,
+  segmentStartCoordinate,
+  segmentEndCoordinate
+}) => coordinate > Math.min(segmentStartCoordinate, segmentEndCoordinate) + EPSILON && coordinate < Math.max(segmentStartCoordinate, segmentEndCoordinate) - EPSILON;
+var isStrictInteriorPerpendicularCrossing = ({
+  firstSegmentStart,
+  firstSegmentEnd,
+  secondSegmentStart,
+  secondSegmentEnd
+}) => {
+  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;
+  let horizontalEnd;
+  if (firstIsHorizontal) {
+    horizontalStart = firstSegmentStart;
+    horizontalEnd = firstSegmentEnd;
+  } else if (secondIsHorizontal) {
+    horizontalStart = secondSegmentStart;
+    horizontalEnd = secondSegmentEnd;
+  } else {
+    return false;
+  }
+  let verticalStart;
+  let verticalEnd;
+  if (firstIsVertical) {
+    verticalStart = firstSegmentStart;
+    verticalEnd = firstSegmentEnd;
+  } else if (secondIsVertical) {
+    verticalStart = secondSegmentStart;
+    verticalEnd = secondSegmentEnd;
+  } else {
+    return false;
+  }
+  return isStrictlyBetween2({
+    coordinate: verticalStart.x,
+    segmentStartCoordinate: horizontalStart.x,
+    segmentEndCoordinate: horizontalEnd.x
+  }) && isStrictlyBetween2({
+    coordinate: horizontalStart.y,
+    segmentStartCoordinate: verticalStart.y,
+    segmentEndCoordinate: verticalEnd.y
+  });
+};
+var doesTraceRecoveryPathConflict = (tracePath, collisionTraces) => {
+  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 (!doSegmentsIntersect4(pathStart, pathEnd, traceStart, traceEnd)) {
+          continue;
+        }
+        if (isStrictInteriorPerpendicularCrossing({
+          firstSegmentStart: pathStart,
+          firstSegmentEnd: pathEnd,
+          secondSegmentStart: traceStart,
+          secondSegmentEnd: traceEnd
+        })) {
+          continue;
+        }
+        return true;
+      }
+    }
+  }
+  return false;
+};
+
 // lib/solvers/NetLabelToTraceSolver/NetLabelToTraceSolver.ts
 var AVAILABLE_NET_ORIENTATION_PREFIX = "available-net-orientation-";
 var RECOVERED_TRACE_PREFIX = "net-label-to-trace-";
@@ -15566,7 +15642,7 @@ var NetLabelToTraceSolver = class extends BaseSolver {
         (trace) => trace.globalConnNetId !== candidate.firstLabel.globalConnNetId
       );
     }
-    if (doesTraceOverlapWithExistingTraces(tracePath, collisionTraces) || this.routeIntersectsRemainingLabels(tracePath, candidate)) {
+    if (doesTraceRecoveryPathConflict(tracePath, collisionTraces) || this.routeIntersectsRemainingLabels(tracePath, candidate)) {
       return;
     }
     const [firstPin, secondPin] = candidate.pins;

package/lib/solvers/NetLabelToTraceSolver/NetLabelToTraceSolver.ts

@@ -12,6 +12,7 @@ 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 { SchematicTraceSingleLineSolver2 } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/SchematicTraceSingleLineSolver2"
@@ -22,7 +23,6 @@ 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,
@@ -434,7 +434,7 @@ export class NetLabelToTraceSolver extends BaseSolver {
       )
     }
     if (
-      doesTraceOverlapWithExistingTraces(tracePath, collisionTraces) ||
+      doesTraceRecoveryPathConflict(tracePath, collisionTraces) ||
       this.routeIntersectsRemainingLabels(tracePath, candidate)
     ) {
       return

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.169",
   "type": "module",
   "scripts": {
     "start": "cosmos",