@tscircuit/schematic-trace-solver 0.0.64 → 0.0.66

package/lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver.ts

@@ -74,6 +74,7 @@ export class NetLabelPlacementSolver extends BaseSolver {
   declare activeSubSolver: SingleNetLabelPlacementSolver | null
 
   netLabelPlacements: Array<NetLabelPlacement> = []
+  failedGroups: Array<OverlappingSameNetTraceGroup> = []
   currentGroup: OverlappingSameNetTraceGroup | null = null
   triedAnyOrientationFallbackForCurrentGroup = false
 
@@ -336,8 +337,13 @@ export class NetLabelPlacementSolver extends BaseSolver {
         return
       }
 
-      this.failed = true
-      this.error = this.activeSubSolver.error
+      // Record the failure for this group and continue to the next one
+      if (this.currentGroup) {
+        this.failedGroups.push(this.currentGroup)
+      }
+      this.activeSubSolver = null
+      this.currentGroup = null
+      this.triedAnyOrientationFallbackForCurrentGroup = false
       return
     }
 

package/lib/solvers/TraceLabelOverlapAvoidanceSolver/TraceLabelOverlapAvoidanceSolver.ts

@@ -42,10 +42,13 @@ export class TraceLabelOverlapAvoidanceSolver extends BaseSolver {
 
   labelMergingSolver?: MergedNetLabelObstacleSolver
 
+  allInputTraces: SolvedTracePath[]
+
   constructor(solverInput: TraceLabelOverlapAvoidanceSolverInput) {
     super()
     this.inputProblem = solverInput.inputProblem
     this.unprocessedTraces = [...solverInput.traces]
+    this.allInputTraces = solverInput.traces
     this.netLabelPlacements = solverInput.netLabelPlacements
     this.cleanTraces = []
     this.subSolvers = []
@@ -88,6 +91,9 @@ export class TraceLabelOverlapAvoidanceSolver extends BaseSolver {
           mergedNetLabelPlacements: mergingOutput.netLabelPlacements,
           mergedLabelNetIdMap: mergingOutput.mergedLabelNetIdMap,
           detourCounts: this.detourCounts,
+          tracesToAvoidOverlapping: this.allInputTraces.filter(
+            (t) => t.mspPairId !== currentTargetTrace.mspPairId,
+          ),
         })
         this.subSolvers.push(subSolver)
       }

package/lib/solvers/TraceLabelOverlapAvoidanceSolver/sub-solvers/OverlapAvoidanceStepSolver/OverlapAvoidanceStepSolver.ts

@@ -19,6 +19,7 @@ export interface OverlapCollectionSolverInput {
   mergedNetLabelPlacements: NetLabelPlacement[]
   mergedLabelNetIdMap: Record<string, Set<string>>
   detourCounts: Map<string, number>
+  tracesToAvoidOverlapping?: SolvedTracePath[]
 }
 
 /**
@@ -32,6 +33,7 @@ export class OverlapAvoidanceStepSolver extends BaseSolver {
   mergedLabelNetIdMap: Record<string, Set<string>>
 
   allTraces: SolvedTracePath[]
+  tracesToAvoidOverlapping: SolvedTracePath[]
   modifiedTraces: SolvedTracePath[] = []
 
   private readonly PADDING_BUFFER = 0.1
@@ -51,6 +53,7 @@ export class OverlapAvoidanceStepSolver extends BaseSolver {
     this.mergedNetLabelPlacements = solverInput.mergedNetLabelPlacements
     this.mergedLabelNetIdMap = solverInput.mergedLabelNetIdMap
     this.allTraces = [...solverInput.traces]
+    this.tracesToAvoidOverlapping = solverInput.tracesToAvoidOverlapping ?? []
     this.detourCounts = solverInput.detourCounts
   }
 
@@ -150,6 +153,7 @@ export class OverlapAvoidanceStepSolver extends BaseSolver {
             problem: this.inputProblem,
             paddingBuffer: this.PADDING_BUFFER,
             detourCount: detourCount,
+            tracesToAvoidOverlapping: this.tracesToAvoidOverlapping,
           })
         } else {
           const overlapId = `${traceToFix.mspPairId}-${labelToAvoid.globalConnNetId}`
@@ -192,6 +196,7 @@ export class OverlapAvoidanceStepSolver extends BaseSolver {
             problem: this.inputProblem,
             paddingBuffer: this.PADDING_BUFFER,
             detourCount: detourCount,
+            tracesToAvoidOverlapping: this.tracesToAvoidOverlapping,
           })
         } else {
           const overlapId = `${traceToFix.mspPairId}-${labelToAvoid.globalConnNetId}`
@@ -211,6 +216,7 @@ export class OverlapAvoidanceStepSolver extends BaseSolver {
         problem: this.inputProblem,
         paddingBuffer: this.PADDING_BUFFER,
         detourCount: detourCount,
+        tracesToAvoidOverlapping: this.tracesToAvoidOverlapping,
       })
     }
   }

package/lib/solvers/TraceLabelOverlapAvoidanceSolver/sub-solvers/SingleOverlapSolver/SingleOverlapSolver.ts

@@ -16,9 +16,69 @@ interface SingleOverlapSolverInput {
   problem: InputProblem
   paddingBuffer: number
   detourCount: number
+  tracesToAvoidOverlapping?: SolvedTracePath[]
 }
 
 const MAX_TRIES = 5
+const COINCIDENT_EPS = 2e-3
+
+/**
+ * Returns true if any segment of the path is parallel and coincident
+ * (within COINCIDENT_EPS) with a segment of one of the given traces.
+ * Perpendicular crossings are allowed.
+ */
+const doesPathCoincideWithTraces = (
+  path: Point[],
+  traces: SolvedTracePath[],
+): boolean => {
+  const rangesOverlap1D = (a1: number, a2: number, b1: number, b2: number) =>
+    Math.min(Math.max(a1, a2), Math.max(b1, b2)) -
+      Math.max(Math.min(a1, a2), Math.min(b1, b2)) >
+    COINCIDENT_EPS
+
+  for (let i = 0; i < path.length - 1; i++) {
+    const pathSegStart = path[i]!
+    const pathSegEnd = path[i + 1]!
+    const isVertical = Math.abs(pathSegStart.x - pathSegEnd.x) < COINCIDENT_EPS
+    const isHorizontal =
+      Math.abs(pathSegStart.y - pathSegEnd.y) < COINCIDENT_EPS
+    if (!isVertical && !isHorizontal) continue
+
+    // For a vertical segment, coincidence is measured in x and overlap in y
+    // (and vice versa for horizontal)
+    const crossAxis = isVertical ? "x" : "y"
+    const alongAxis = isVertical ? "y" : "x"
+
+    for (const trace of traces) {
+      for (let j = 0; j < trace.tracePath.length - 1; j++) {
+        const traceSegStart = trace.tracePath[j]!
+        const traceSegEnd = trace.tracePath[j + 1]!
+
+        const isParallel =
+          Math.abs(traceSegStart[crossAxis] - traceSegEnd[crossAxis]) <
+          COINCIDENT_EPS
+        if (!isParallel) continue
+
+        const isCoincident =
+          Math.abs(pathSegStart[crossAxis] - traceSegStart[crossAxis]) <
+          COINCIDENT_EPS
+        if (!isCoincident) continue
+
+        if (
+          rangesOverlap1D(
+            pathSegStart[alongAxis],
+            pathSegEnd[alongAxis],
+            traceSegStart[alongAxis],
+            traceSegEnd[alongAxis],
+          )
+        ) {
+          return true
+        }
+      }
+    }
+  }
+  return false
+}
 
 /**
  * This solver attempts to find a valid rerouting for a single trace that is
@@ -32,6 +92,7 @@ export class SingleOverlapSolver extends BaseSolver {
   problem: InputProblem
   obstacles: ReturnType<typeof getObstacleRects>
   label: NetLabelPlacement
+  tracesToAvoidOverlapping: SolvedTracePath[]
   _tried: number = 0
 
   constructor(solverInput: SingleOverlapSolverInput) {
@@ -39,6 +100,9 @@ export class SingleOverlapSolver extends BaseSolver {
     this.initialTrace = solverInput.trace
     this.problem = solverInput.problem
     this.label = solverInput.label
+    this.tracesToAvoidOverlapping = (
+      solverInput.tracesToAvoidOverlapping ?? []
+    ).filter((t) => t.globalConnNetId !== solverInput.trace.globalConnNetId)
 
     // Calculate an effective padding for this specific run based on the detourCount.
     const effectivePadding =
@@ -77,7 +141,10 @@ export class SingleOverlapSolver extends BaseSolver {
     const nextCandidatePath = this.queuedCandidatePaths.shift()!
     const simplifiedPath = simplifyPath(nextCandidatePath)
 
-    if (!isPathCollidingWithObstacles(simplifiedPath, this.obstacles)) {
+    if (
+      !isPathCollidingWithObstacles(simplifiedPath, this.obstacles) &&
+      !doesPathCoincideWithTraces(simplifiedPath, this.tracesToAvoidOverlapping)
+    ) {
       this.solvedTracePath = simplifiedPath
       this.solved = true
     }

package/lib/solvers/TraceOverlapShiftSolver/TraceOverlapIssueSolver/TraceOverlapIssueSolver.ts

@@ -1,11 +1,16 @@
 import type { GraphicsObject } from "graphics-debug"
 import { BaseSolver } from "lib/solvers/BaseSolver/BaseSolver"
 import type { MspConnectionPairId } from "lib/solvers/MspConnectionPairSolver/MspConnectionPairSolver"
+import { findFirstCollision } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions"
+import { getObstacleRects } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/rect"
 import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import type { InputProblem } from "lib/types/InputProblem"
 import { applyJogToTerminalSegment } from "./applyJogToTrace"
 
 type ConnNetId = string
 
+const EPS = 1e-6
+
 export interface OverlappingTraceSegmentLocator {
   connNetId: string
   pathsWithOverlap: Array<{
@@ -17,18 +22,21 @@ export interface OverlappingTraceSegmentLocator {
 export class TraceOverlapIssueSolver extends BaseSolver {
   overlappingTraceSegments: OverlappingTraceSegmentLocator[]
   traceNetIslands: Record<ConnNetId, Array<SolvedTracePath>>
+  obstacleRects: ReturnType<typeof getObstacleRects>
 
   SHIFT_DISTANCE = 0.1
 
   correctedTraceMap: Record<MspConnectionPairId, SolvedTracePath> = {}
 
   constructor(params: {
+    inputProblem: InputProblem
     overlappingTraceSegments: OverlappingTraceSegmentLocator[]
     traceNetIslands: Record<ConnNetId, Array<SolvedTracePath>>
   }) {
     super()
     this.overlappingTraceSegments = params.overlappingTraceSegments
     this.traceNetIslands = params.traceNetIslands
+    this.obstacleRects = getObstacleRects(params.inputProblem)
 
     // Only add the relevant traces to the correctedTraceMap
     for (const { connNetId, pathsWithOverlap } of this
@@ -49,13 +57,34 @@ export class TraceOverlapIssueSolver extends BaseSolver {
     // Shift only the overlapping segments, and move the shared endpoints
     // (the last point of the previous segment and the first point of the next
     // segment) so the polyline remains orthogonal without self-overlap.
-    const EPS = 1e-6
+    // Groups containing a straight pin-to-pin trace (2 points, both endpoints
+    // are pins) keep their position when another group can shift instead:
+    // shifting such a trace would force jogs on an otherwise straight line.
+    const containsStraightPinToPinTrace = (
+      group: OverlappingTraceSegmentLocator,
+    ) =>
+      group.pathsWithOverlap.some(({ solvedTracePathIndex }) => {
+        const path =
+          this.traceNetIslands[group.connNetId][solvedTracePathIndex]!
+        return path.tracePath.length === 2
+      })
+
+    const groupShouldStayInPlace = this.overlappingTraceSegments.map(
+      containsStraightPinToPinTrace,
+    )
+    const someGroupCanShift = groupShouldStayInPlace.some(
+      (shouldStay) => !shouldStay,
+    )
 
     // Compute offsets for each island involved: alternate directions
-    const offsets = this.overlappingTraceSegments.map((_, idx) => {
+    const offsets = this.overlappingTraceSegments.map((group, idx) => {
+      if (someGroupCanShift && groupShouldStayInPlace[idx]) return 0
       const n = Math.floor(idx / 2) + 1
       const signed = idx % 2 === 0 ? -n : n
-      return signed * this.SHIFT_DISTANCE
+      return this.getObstacleAwareOffset({
+        group,
+        offset: signed * this.SHIFT_DISTANCE,
+      })
     })
 
     const eq = (a: number, b: number) => Math.abs(a - b) < EPS
@@ -67,6 +96,7 @@ export class TraceOverlapIssueSolver extends BaseSolver {
     // For each net island group, shift only its overlapping segments and adjust adjacent joints
     this.overlappingTraceSegments.forEach((group, gidx) => {
       const offset = offsets[gidx]!
+      if (offset === 0) return
 
       // Gather unique segment indices per path
       const byPath: Map<number, Set<number>> = new Map()
@@ -82,8 +112,6 @@ export class TraceOverlapIssueSolver extends BaseSolver {
         const current = this.correctedTraceMap[original.mspPairId] ?? original
         const pts = current.tracePath.map((p) => ({ ...p }))
 
-        const segIdxs = Array.from(segIdxSet).sort((a, b) => a - b)
-
         const segIdxsRev = Array.from(segIdxSet)
           .sort((a, b) => a - b)
           .reverse()
@@ -142,6 +170,82 @@ export class TraceOverlapIssueSolver extends BaseSolver {
     this.solved = true
   }
 
+  private getObstacleAwareOffset({
+    group,
+    offset,
+  }: {
+    group: OverlappingTraceSegmentLocator
+    offset: number
+  }) {
+    const blockingCollisions = this.getBlockingCollisions({ group, offset })
+    if (blockingCollisions.length === 0) return offset
+
+    return (
+      blockingCollisions
+        .flatMap(({ start, isVertical, obstacle }) => [
+          (isVertical ? obstacle.minX - start.x : obstacle.minY - start.y) -
+            this.SHIFT_DISTANCE,
+          (isVertical ? obstacle.maxX - start.x : obstacle.maxY - start.y) +
+            this.SHIFT_DISTANCE,
+        ])
+        .filter(
+          (candidateOffset) =>
+            this.getBlockingCollisions({ group, offset: candidateOffset })
+              .length === 0,
+        )
+        .sort((a, b) => Math.abs(a - offset) - Math.abs(b - offset))[0] ??
+      offset
+    )
+  }
+
+  private getBlockingCollisions({
+    group,
+    offset,
+  }: {
+    group: OverlappingTraceSegmentLocator
+    offset: number
+  }) {
+    const blockingCollisions: Array<{
+      start: SolvedTracePath["tracePath"][number]
+      isVertical: boolean
+      obstacle: ReturnType<typeof getObstacleRects>[number]
+    }> = []
+
+    for (const {
+      solvedTracePathIndex,
+      traceSegmentIndex,
+    } of group.pathsWithOverlap) {
+      const trace = this.traceNetIslands[group.connNetId][solvedTracePathIndex]!
+      const start = trace.tracePath[traceSegmentIndex]
+      const end = trace.tracePath[traceSegmentIndex + 1]
+      if (!start || !end) continue
+
+      const isVertical = Math.abs(start.x - end.x) < EPS
+      const isHorizontal = Math.abs(start.y - end.y) < EPS
+      if (!isVertical && !isHorizontal) continue
+
+      const shiftedSegment = isVertical
+        ? [
+            { ...start, x: start.x + offset },
+            { ...end, x: end.x + offset },
+          ]
+        : [
+            { ...start, y: start.y + offset },
+            { ...end, y: end.y + offset },
+          ]
+      const collision = findFirstCollision(shiftedSegment, this.obstacleRects)
+      if (collision) {
+        blockingCollisions.push({
+          start,
+          isVertical,
+          obstacle: collision.rect,
+        })
+      }
+    }
+
+    return blockingCollisions
+  }
+
   override visualize(): GraphicsObject {
     // Visualize overlapped segments and proposed corrections
     const graphics: GraphicsObject = {

package/lib/solvers/TraceOverlapShiftSolver/TraceOverlapIssueSolver/applyJogToTrace.ts

@@ -29,6 +29,36 @@ export const applyJogToTerminalSegment = ({
       ? 1
       : -1
 
+  if (pts.length === 2) {
+    // The segment is both the first and last segment: both endpoints are
+    // pins, so jog inward on both sides to keep the endpoints anchored
+    if (isVertical) {
+      const jogYNearStart = start.y + segDir * JOG_SIZE
+      const jogYNearEnd = end.y - segDir * JOG_SIZE
+      pts.splice(
+        1,
+        0,
+        { x: start.x, y: jogYNearStart },
+        { x: start.x + offset, y: jogYNearStart },
+        { x: end.x + offset, y: jogYNearEnd },
+        { x: end.x, y: jogYNearEnd },
+      )
+    } else {
+      // Horizontal
+      const jogXNearStart = start.x + segDir * JOG_SIZE
+      const jogXNearEnd = end.x - segDir * JOG_SIZE
+      pts.splice(
+        1,
+        0,
+        { x: jogXNearStart, y: start.y },
+        { x: jogXNearStart, y: start.y + offset },
+        { x: jogXNearEnd, y: end.y + offset },
+        { x: jogXNearEnd, y: end.y },
+      )
+    }
+    return
+  }
+
   if (si === 0) {
     if (isVertical) {
       const jogY = start.y + segDir * JOG_SIZE

package/lib/solvers/TraceOverlapShiftSolver/TraceOverlapShiftSolver.ts

@@ -309,6 +309,7 @@ export class TraceOverlapShiftSolver extends BaseSolver {
     const { overlappingTraceSegments } = overlapIssue
 
     this.activeSubSolver = new TraceOverlapIssueSolver({
+      inputProblem: this.inputProblem,
       overlappingTraceSegments,
       traceNetIslands: this.traceNetIslands,
     })

package/package.json

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