@tscircuit/schematic-trace-solver 0.0.95 → 0.0.97

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

@@ -1,24 +1,29 @@
+import type { Point } from "@tscircuit/math-utils"
+import { calculateElbow } from "calculate-elbow"
 import type { GraphicsObject } from "graphics-debug"
-import { visualizeInputProblem } from "lib/solvers/SchematicTracePipelineSolver/visualizeInputProblem"
 import { BaseSolver } from "lib/solvers/BaseSolver/BaseSolver"
 import type { MspConnectionPair } from "lib/solvers/MspConnectionPairSolver/MspConnectionPairSolver"
-import type { InputChip, InputProblem, PinId } from "lib/types/InputProblem"
-import type { Point } from "@tscircuit/math-utils"
-import { calculateElbow } from "calculate-elbow"
+import { getDimsForOrientation } from "lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/geometry"
+import { visualizeInputProblem } from "lib/solvers/SchematicTracePipelineSolver/visualizeInputProblem"
+import type { InputChip, InputProblem } from "lib/types/InputProblem"
+import type { FacingDirection } from "lib/utils/dir"
+import type { RectPadding } from "lib/utils/textBoxBounds"
 import { getPinDirection } from "../SchematicTraceSingleLineSolver/getPinDirection"
-import { getObstacleRects, type ObstacleRect } from "./rect"
-import { findFirstCollision, isHorizontal, isVertical } from "./collisions"
+import { calculateDirectShortPath } from "./calculateDirectShortPath"
 import {
+  findFirstCollision,
+  isHorizontal,
+  isVertical,
+  segmentOverlapsRectBoundary,
+} from "./collisions"
+import {
+  type Axis,
   aabbFromPoints,
   candidateMidsFromSet,
   midBetweenPointAndRect,
-  type Axis,
 } from "./mid"
 import { pathKey, shiftSegmentOrth } from "./pathOps"
-import type { FacingDirection } from "lib/utils/dir"
-import { getDimsForOrientation } from "lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/geometry"
-import type { RectPadding } from "lib/utils/textBoxBounds"
-import { calculateDirectShortPath } from "./calculateDirectShortPath"
+import { getObstacleRects, type ObstacleRect } from "./rect"
 
 type PathKey = string
 
@@ -268,9 +273,42 @@ export class SchematicTraceSingleLineSolver2 extends BaseSolver {
     const collision = findFirstCollision(path, this.obstacles, {
       excludeRectsForSegment: (segIndex) => {
         const lastSegIndex = path.length - 2
+        const excludedRects = new Set<ObstacleRect>()
+
         if (segIndex === 0 || segIndex === lastSegIndex) {
-          return this.textObstacles
+          for (const textObstacle of this.textObstacles) {
+            excludedRects.add(textObstacle)
+          }
         }
+
+        const segmentStart = path[segIndex]!
+        const segmentEnd = path[segIndex + 1]!
+        const endpointEpsilon = 1e-9
+        const segmentTouchesPin = (pin: MspConnectionPair["pins"][number]) =>
+          [segmentStart, segmentEnd].some(
+            (point) =>
+              Math.abs(point.x - pin.x) <= endpointEpsilon &&
+              Math.abs(point.y - pin.y) <= endpointEpsilon,
+          )
+
+        for (const pin of this.pins) {
+          if (!segmentTouchesPin(pin)) continue
+          const endpointChipObstacle = this.obstacles.find(
+            (obstacle) =>
+              obstacle.kind === "chip" && obstacle.chipId === pin.chipId,
+          )
+          if (
+            endpointChipObstacle &&
+            segmentOverlapsRectBoundary(
+              segmentStart,
+              segmentEnd,
+              endpointChipObstacle,
+            )
+          ) {
+            excludedRects.add(endpointChipObstacle)
+          }
+        }
+
         const adjacentEndpointSegIndex =
           segIndex === 1
             ? 2
@@ -286,9 +324,12 @@ export class SchematicTraceSingleLineSolver2 extends BaseSolver {
             path[adjacentEndpointSegIndex + 1]!,
           )
         ) {
-          return this.endpointTextObstacles
+          for (const textObstacle of this.endpointTextObstacles) {
+            excludedRects.add(textObstacle)
+          }
         }
-        return new Set<ObstacleRect>()
+
+        return excludedRects
       },
     })
 

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

@@ -35,6 +35,37 @@ export const segmentIntersectsRect = <TRect extends RectBounds>(
   }
 }
 
+export const segmentOverlapsRectBoundary = <TRect extends RectBounds>(
+  a: Point,
+  b: Point,
+  r: TRect,
+  eps = EPS,
+): boolean => {
+  if (isVertical(a, b, eps)) {
+    const onVerticalBoundary =
+      Math.abs(a.x - r.minX) <= eps || Math.abs(a.x - r.maxX) <= eps
+    if (!onVerticalBoundary) return false
+
+    const overlap =
+      Math.min(Math.max(a.y, b.y), r.maxY) -
+      Math.max(Math.min(a.y, b.y), r.minY)
+    return overlap > eps
+  }
+
+  if (isHorizontal(a, b, eps)) {
+    const onHorizontalBoundary =
+      Math.abs(a.y - r.minY) <= eps || Math.abs(a.y - r.maxY) <= eps
+    if (!onHorizontalBoundary) return false
+
+    const overlap =
+      Math.min(Math.max(a.x, b.x), r.maxX) -
+      Math.max(Math.min(a.x, b.x), r.minX)
+    return overlap > eps
+  }
+
+  return false
+}
+
 export const findFirstCollision = <TRect extends RectBounds>(
   pts: Point[],
   rects: TRect[],

package/lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver.ts

@@ -61,9 +61,8 @@ function definePipelineStep<
   }
 }
 
-export interface SchematicTracePipelineSolverParams {
-  inputProblem: InputProblem
-  allowLongDistanceTraces?: boolean
+interface Options {
+  hideRatsNet?: boolean
 }
 
 export class SchematicTracePipelineSolver extends BaseSolver {
@@ -89,6 +88,7 @@ export class SchematicTracePipelineSolver extends BaseSolver {
   firstIterationOfPhase: Record<string, number>
 
   inputProblem: InputProblem
+  hideRatsNet: boolean
 
   pipelineDef = [
     definePipelineStep(
@@ -318,8 +318,9 @@ export class SchematicTracePipelineSolver extends BaseSolver {
     ),
   ]
 
-  constructor(inputProblem: InputProblem) {
+  constructor(inputProblem: InputProblem, opts?: Options) {
     super()
+    this.hideRatsNet = opts?.hideRatsNet ?? false
     this.inputProblem = this.cloneAndCorrectInputProblem(inputProblem)
     this.MAX_ITERATIONS = 1e6
     this.startTimeOfPhase = {}
@@ -330,8 +331,8 @@ export class SchematicTracePipelineSolver extends BaseSolver {
 
   override getConstructorParams(): ConstructorParameters<
     typeof SchematicTracePipelineSolver
-  >[0] {
-    return this.inputProblem
+  > {
+    return [this.inputProblem, { hideRatsNet: this.hideRatsNet }]
   }
 
   currentPipelineStepIndex = 0
@@ -340,6 +341,7 @@ export class SchematicTracePipelineSolver extends BaseSolver {
     const cloned: InputProblem = structuredClone({
       ...original,
       _chipObstacleSpatialIndex: undefined,
+      _hideRatsNet: this.hideRatsNet,
     })
 
     // First, expand chips so existing pin coordinates sit on or within their edges without shrinking.
@@ -399,7 +401,9 @@ export class SchematicTracePipelineSolver extends BaseSolver {
       return this.activeSubSolver.visualize()
 
     const visualizations = [
-      visualizeInputProblem(this.inputProblem),
+      visualizeInputProblem(this.inputProblem, {
+        hideRatsNet: this.hideRatsNet,
+      }),
       ...(this.pipelineDef
         .map((p) => (this as any)[p.solverName]?.visualize())
         .filter(Boolean)

package/lib/solvers/SchematicTracePipelineSolver/visualizeInputProblem.ts

@@ -9,9 +9,14 @@ export const visualizeInputProblem = (
   opts: {
     chipAlpha?: number
     connectionAlpha?: number
+    hideRatsNet?: boolean
   } = {},
 ): GraphicsObject => {
-  const { connectionAlpha = 0.8, chipAlpha = 0.8 } = opts
+  const {
+    connectionAlpha = 0.8,
+    chipAlpha = 0.8,
+    hideRatsNet = inputProblem._hideRatsNet ?? false,
+  } = opts
   const graphics: Pick<
     Required<GraphicsObject>,
     "lines" | "points" | "rects"
@@ -58,48 +63,50 @@ export const visualizeInputProblem = (
     } as any)
   }
 
-  for (const directConn of inputProblem.directConnections) {
-    const [pinId1, pinId2] = directConn.pinIds
-    const pin1 = pinIdMap.get(pinId1)!
-    const pin2 = pinIdMap.get(pinId2)!
-    if (arePinsInDifferentSchematicSections(inputProblem, pin1, pin2)) {
-      continue
+  if (!hideRatsNet) {
+    for (const directConn of inputProblem.directConnections) {
+      const [pinId1, pinId2] = directConn.pinIds
+      const pin1 = pinIdMap.get(pinId1)!
+      const pin2 = pinIdMap.get(pinId2)!
+      if (arePinsInDifferentSchematicSections(inputProblem, pin1, pin2)) {
+        continue
+      }
+      graphics.lines.push({
+        points: [
+          {
+            x: pin1.x,
+            y: pin1.y,
+          },
+          {
+            x: pin2.x,
+            y: pin2.y,
+          },
+        ],
+        strokeColor: getColorFromString(
+          directConn.netId ?? `${pinId1}-${pinId2}`,
+          connectionAlpha,
+        ),
+      })
     }
-    graphics.lines.push({
-      points: [
-        {
-          x: pin1.x,
-          y: pin1.y,
-        },
-        {
-          x: pin2.x,
-          y: pin2.y,
-        },
-      ],
-      strokeColor: getColorFromString(
-        directConn.netId ?? `${pinId1}-${pinId2}`,
-        connectionAlpha,
-      ),
-    })
-  }
 
-  for (const netConn of inputProblem.netConnections) {
-    const pins = netConn.pinIds.map((pinId) => pinIdMap.get(pinId)!)
-    for (let i = 0; i < pins.length - 1; i++) {
-      for (let j = i + 1; j < pins.length; j++) {
-        const pin1 = pins[i]!
-        const pin2 = pins[j]!
-        if (arePinsInDifferentSchematicSections(inputProblem, pin1, pin2)) {
-          continue
+    for (const netConn of inputProblem.netConnections) {
+      const pins = netConn.pinIds.map((pinId) => pinIdMap.get(pinId)!)
+      for (let i = 0; i < pins.length - 1; i++) {
+        for (let j = i + 1; j < pins.length; j++) {
+          const pin1 = pins[i]!
+          const pin2 = pins[j]!
+          if (arePinsInDifferentSchematicSections(inputProblem, pin1, pin2)) {
+            continue
+          }
+          graphics.lines.push({
+            points: [
+              { x: pin1.x, y: pin1.y },
+              { x: pin2.x, y: pin2.y },
+            ],
+            strokeColor: getColorFromString(netConn.netId, connectionAlpha),
+            strokeDash: "4 2",
+          })
         }
-        graphics.lines.push({
-          points: [
-            { x: pin1.x, y: pin1.y },
-            { x: pin2.x, y: pin2.y },
-          ],
-          strokeColor: getColorFromString(netConn.netId, connectionAlpha),
-          strokeDash: "4 2",
-        })
       }
     }
   }

package/lib/types/InputProblem.ts

@@ -53,4 +53,5 @@ export interface InputProblem {
   maxMspPairDistance?: number
 
   _chipObstacleSpatialIndex?: ChipObstacleSpatialIndex
+  _hideRatsNet?: boolean
 }

package/package.json

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