@tscircuit/schematic-trace-solver 0.0.98 → 0.0.99

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) {

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/package.json

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