@tscircuit/schematic-trace-solver 0.0.98 → 0.0.100

package/lib/solvers/MspConnectionPairSolver/MspConnectionPairSolver.ts

@@ -1,3 +1,6 @@
+import { distance } from "@tscircuit/math-utils"
+import type { ConnectivityMap } from "connectivity-map"
+import type { GraphicsObject } from "graphics-debug"
 import { BaseSolver } from "lib/solvers/BaseSolver/BaseSolver"
 import type {
   InputChip,
@@ -5,17 +8,17 @@ import type {
   InputProblem,
   PinId,
 } from "lib/types/InputProblem"
-import { ConnectivityMap } from "connectivity-map"
-import { getConnectivityMapsFromInputProblem } from "./getConnectivityMapFromInputProblem"
-import { getOrthogonalMinimumSpanningTree } from "./getMspConnectionPairsFromPins"
-import { doesPairCrossRestrictedCenterLines } from "./doesPairCrossRestrictedCenterLines"
-import type { GraphicsObject } from "graphics-debug"
 import { getColorFromString } from "lib/utils/getColorFromString"
-import { visualizeInputProblem } from "../SchematicTracePipelineSolver/visualizeInputProblem"
 import { arePinsInDifferentSchematicSections } from "../../utils/arePinsInDifferentSchematicSections"
+import { visualizeInputProblem } from "../SchematicTracePipelineSolver/visualizeInputProblem"
+import { doesPairCrossRestrictedCenterLines } from "./doesPairCrossRestrictedCenterLines"
+import { getConnectivityMapsFromInputProblem } from "./getConnectivityMapFromInputProblem"
+import { getOrthogonalMinimumSpanningTree } from "./getMspConnectionPairsFromPins"
 
 export type MspConnectionPairId = string
 
+const getPinPairKey = (pinIds: [PinId, PinId]) => [...pinIds].sort().join("::")
+
 export type MspConnectionPair = {
   mspPairId: MspConnectionPairId
   dcConnNetId: string
@@ -36,6 +39,7 @@ export class MspConnectionPairSolver extends BaseSolver {
 
   pinMap: Record<string, InputPin & { chipId: string }>
   userNetIdByPinId: Record<string, string | undefined>
+  directConnectionPinPairKeys: Set<string>
 
   constructor({ inputProblem }: { inputProblem: InputProblem }) {
     super()
@@ -62,7 +66,9 @@ export class MspConnectionPairSolver extends BaseSolver {
 
     // Build a mapping from PinId to user-provided netId (if any)
     this.userNetIdByPinId = {}
+    this.directConnectionPinPairKeys = new Set()
     for (const dc of inputProblem.directConnections) {
+      this.directConnectionPinPairKeys.add(getPinPairKey(dc.pinIds))
       if (dc.netId) {
         const [a, b] = dc.pinIds
         this.userNetIdByPinId[a] = dc.netId
@@ -105,9 +111,13 @@ export class MspConnectionPairSolver extends BaseSolver {
       const [pin1, pin2] = directlyConnectedPins
       const p1 = this.pinMap[pin1!]!
       const p2 = this.pinMap[pin2!]!
-      // Enforce max pair distance (use Manhattan to match orthogonal routing metric)
-      const manhattanDist = Math.abs(p1.x - p2.x) + Math.abs(p1.y - p2.y)
-      if (manhattanDist > this.maxMspPairDistance) {
+      const pinPairKey = getPinPairKey([pin1!, pin2!])
+      // Explicit source traces are classified by straight-line distance when
+      // their input is created; named nets retain the orthogonal route metric.
+      const pairDistance = this.directConnectionPinPairKeys.has(pinPairKey)
+        ? distance(p1, p2)
+        : Math.abs(p1.x - p2.x) + Math.abs(p1.y - p2.y)
+      if (pairDistance > this.maxMspPairDistance) {
         // Too far apart; skip creating an MSP pair for this net
         return
       }

package/lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/SchematicTraceSingleLineSolver2.ts

@@ -16,6 +16,7 @@ import {
   isVertical,
   segmentOverlapsRectBoundary,
 } from "./collisions"
+import { generateEndpointCollisionDetours } from "./generateEndpointCollisionDetours"
 import {
   type Axis,
   aabbFromPoints,
@@ -357,6 +358,35 @@ export class SchematicTraceSingleLineSolver2 extends BaseSolver {
     const isFirstSegment = segIndex === 0
     const isLastSegment = segIndex === path.length - 2
 
+    if (path.length === 3 && (isFirstSegment || isLastSegment)) {
+      const detours = generateEndpointCollisionDetours({
+        path,
+        collidingSegmentIndex: segIndex,
+        obstacle: rect,
+      })
+        .filter((detour) => {
+          const key = pathKey(detour)
+          if (this.visited.has(key)) return false
+          this.visited.add(key)
+          return true
+        })
+        .sort(
+          (a, b) =>
+            this.pathLength(a) - this.pathLength(b) ||
+            this.getPinBandPenalty(a) - this.getPinBandPenalty(b),
+        )
+
+      for (const detour of detours) {
+        const nextCollisionRects = new Set(collisionRects)
+        nextCollisionRects.add(rect)
+        this.queue.push({
+          path: detour,
+          collisionRects: nextCollisionRects,
+        })
+      }
+      return
+    }
+
     if (isFirstSegment) {
       // If first segment collides, move the second segment instead
       if (path.length < 3) {
@@ -383,6 +413,11 @@ export class SchematicTraceSingleLineSolver2 extends BaseSolver {
 
     // Note: PA and PB are already defined above
     const candidates: number[] = []
+    // Fixed MSP pairs may leave the endpoint bounds to complete a required
+    // route. Optional long-distance candidates retain their bounded search.
+    const candidateMidOptions = {
+      allowOpenSideCandidates: this.connectionPair !== undefined,
+    }
 
     if (collisionRects.size === 0) {
       // First collision on this search branch: use mid(PA, C) and mid(PB, C)
@@ -395,7 +430,13 @@ export class SchematicTraceSingleLineSolver2 extends BaseSolver {
       candidates.push(...uniqueCandidates)
     } else {
       // Subsequent collisions: mid between C and nearest rect/bounds from the set
-      const mids = candidateMidsFromSet(axis, rect, collisionRects, this.aabb)
+      const mids = candidateMidsFromSet(
+        axis,
+        rect,
+        collisionRects,
+        this.aabb,
+        candidateMidOptions,
+      )
       candidates.push(...mids)
     }
 
@@ -466,6 +507,7 @@ export class SchematicTraceSingleLineSolver2 extends BaseSolver {
             rect,
             collisionRects,
             this.aabb,
+            candidateMidOptions,
           ),
         )
       }

package/lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/generateEndpointCollisionDetours.ts

@@ -0,0 +1,84 @@
+import type { Point } from "@tscircuit/math-utils"
+import { isHorizontal, isVertical } from "./collisions"
+import { type Axis, midBetweenPointAndRect } from "./mid"
+import type { ObstacleRect } from "./rect"
+
+const getSegmentAxis = (start: Point, end: Point): Axis | null => {
+  if (isVertical(start, end)) return "x"
+  if (isHorizontal(start, end)) return "y"
+  return null
+}
+
+const hasOnlyNonzeroOrthogonalSegments = (path: Point[]) =>
+  path.every((point, index) => {
+    const nextPoint = path[index + 1]
+    if (!nextPoint) return true
+    if (!isHorizontal(point, nextPoint) && !isVertical(point, nextPoint)) {
+      return false
+    }
+    return Math.abs(point.x - nextPoint.x) + Math.abs(point.y - nextPoint.y) > 0
+  })
+
+export const generateEndpointCollisionDetours = ({
+  path,
+  collidingSegmentIndex,
+  obstacle,
+}: {
+  path: Point[]
+  collidingSegmentIndex: number
+  obstacle: ObstacleRect
+}): Point[][] => {
+  if (path.length !== 3) return []
+
+  const lastSegmentIndex = path.length - 2
+  if (
+    collidingSegmentIndex !== 0 &&
+    collidingSegmentIndex !== lastSegmentIndex
+  ) {
+    return []
+  }
+
+  const shouldReverse = collidingSegmentIndex === lastSegmentIndex
+  const orderedPath = shouldReverse ? [...path].reverse() : path
+  const [start, corner, end] = orderedPath
+  const firstSegmentAxis = getSegmentAxis(start!, corner!)
+  const secondSegmentAxis = getSegmentAxis(corner!, end!)
+  if (!firstSegmentAxis || !secondSegmentAxis) return []
+  if (firstSegmentAxis === secondSegmentAxis) return []
+
+  const escapeCoordinates = [
+    ...midBetweenPointAndRect(secondSegmentAxis, start!, obstacle),
+    ...midBetweenPointAndRect(secondSegmentAxis, end!, obstacle),
+  ]
+  const detourCoordinates = [
+    ...midBetweenPointAndRect(firstSegmentAxis, start!, obstacle),
+    ...midBetweenPointAndRect(firstSegmentAxis, end!, obstacle),
+  ]
+
+  const detours: Point[][] = []
+  for (const escapeCoordinate of [...new Set(escapeCoordinates)]) {
+    for (const detourCoordinate of [...new Set(detourCoordinates)]) {
+      const orderedDetour =
+        firstSegmentAxis === "y"
+          ? [
+              start!,
+              { x: escapeCoordinate, y: start!.y },
+              { x: escapeCoordinate, y: detourCoordinate },
+              { x: end!.x, y: detourCoordinate },
+              end!,
+            ]
+          : [
+              start!,
+              { x: start!.x, y: escapeCoordinate },
+              { x: detourCoordinate, y: escapeCoordinate },
+              { x: detourCoordinate, y: end!.y },
+              end!,
+            ]
+
+      const detour = shouldReverse ? orderedDetour.reverse() : orderedDetour
+      if (hasOnlyNonzeroOrthogonalSegments(detour)) detours.push(detour)
+    }
+  }
+
+  return detours
+}

package/lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/mid.ts

@@ -2,6 +2,7 @@ import type { Point } from "@tscircuit/math-utils"
 import type { ObstacleRect } from "./rect"
 
 const EPS = 1e-9
+const OBSTACLE_CLEARANCE = 0.2
 
 export type Axis = "x" | "y"
 
@@ -26,7 +27,7 @@ export const midBetweenPointAndRect = (
       return [(p.x + r.maxX) / 2]
     }
     // Point is within rect bounds on this axis - generate candidates on both sides
-    return [r.minX - 0.2, r.maxX + 0.2]
+    return [r.minX - OBSTACLE_CLEARANCE, r.maxX + OBSTACLE_CLEARANCE]
   } else {
     if (p.y < r.minY - eps) {
       return [(p.y + r.minY) / 2]
@@ -35,7 +36,7 @@ export const midBetweenPointAndRect = (
       return [(p.y + r.maxY) / 2]
     }
     // Point is within rect bounds on this axis - generate candidates on both sides
-    return [r.minY - 0.2, r.maxY + 0.2]
+    return [r.minY - OBSTACLE_CLEARANCE, r.maxY + OBSTACLE_CLEARANCE]
   }
 }
 
@@ -44,8 +45,9 @@ export const candidateMidsFromSet = (
   colliding: ObstacleRect,
   collisionRects: Set<ObstacleRect>,
   aabb: { minX: number; maxX: number; minY: number; maxY: number },
-  eps = EPS,
+  opts: { allowOpenSideCandidates?: boolean; eps?: number } = {},
 ): number[] => {
+  const { allowOpenSideCandidates = false, eps = EPS } = opts
   const setRects = [...collisionRects]
 
   if (axis === "x") {
@@ -64,9 +66,13 @@ export const candidateMidsFromSet = (
     const out: number[] = []
     if (leftNeighbor !== undefined) {
       out.push((leftNeighbor + colliding.minX) / 2)
+    } else if (allowOpenSideCandidates) {
+      out.push(colliding.minX - OBSTACLE_CLEARANCE)
     }
     if (rightNeighbor !== undefined) {
       out.push((colliding.maxX + rightNeighbor) / 2)
+    } else if (allowOpenSideCandidates) {
+      out.push(colliding.maxX + OBSTACLE_CLEARANCE)
     }
     return out
   } else {
@@ -85,9 +91,13 @@ export const candidateMidsFromSet = (
     const out: number[] = []
     if (bottomNeighbor !== undefined) {
       out.push((bottomNeighbor + colliding.minY) / 2)
+    } else if (allowOpenSideCandidates) {
+      out.push(colliding.minY - OBSTACLE_CLEARANCE)
     }
     if (topNeighbor !== undefined) {
       out.push((colliding.maxY + topNeighbor) / 2)
+    } else if (allowOpenSideCandidates) {
+      out.push(colliding.maxY + OBSTACLE_CLEARANCE)
     }
     return out
   }

package/package.json

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