@tscircuit/schematic-trace-solver 0.0.63 → 0.0.65

package/lib/solvers/AvailableNetOrientationSolver/AvailableNetOrientationSolver.ts

@@ -22,6 +22,7 @@ import {
   rectsOverlap,
   simplifyOrthogonalPath,
   traceCrossesBoundsInterior,
+  tracePathIntersectsBounds,
   tracePathCrossesAnyBounds,
   tracePathCrossesAnyTrace,
 } from "./geometry"
@@ -143,30 +144,7 @@ export class AvailableNetOrientationSolver extends BaseSolver {
     candidate: EvaluatedCandidate,
     labelIndex: number,
   ) {
-    let tracePath: Point[]
-
-    if (candidate.phase === "lateral-shift") {
-      const orientDir = dir(candidate.orientation)
-      const kickedSource = {
-        x: label.anchorPoint.x - orientDir.x * LABEL_SEARCH_STEP,
-        y: label.anchorPoint.y - orientDir.y * LABEL_SEARCH_STEP,
-      }
-      tracePath = simplifyOrthogonalPath([
-        label.anchorPoint,
-        ...getConnectorTracePath(
-          kickedSource,
-          candidate.anchorPoint,
-          candidate.orientation,
-        ),
-      ])
-    } else {
-      tracePath = getConnectorTracePath(
-        label.anchorPoint,
-        candidate.anchorPoint,
-        candidate.orientation,
-      )
-    }
-
+    const tracePath = this.getCandidateConnectorTrace(label, candidate)
     if (tracePath.length < 2) return
 
     const mspPairId = `available-net-orientation-${labelIndex}-${label.netId ?? label.globalConnNetId}`
@@ -417,8 +395,43 @@ export class AvailableNetOrientationSolver extends BaseSolver {
       distance,
       outwardDistance,
       selected: false,
-      status: this.getCandidateStatus(candidate, label, labelIndex),
+      status: this.getCandidateStatus({
+        candidate,
+        label,
+        labelIndex,
+        phase,
+      }),
+    }
+  }
+
+  private getCandidateConnectorTrace(
+    label: NetLabelPlacement,
+    candidate: Pick<
+      EvaluatedCandidate,
+      "anchorPoint" | "orientation" | "phase"
+    >,
+  ) {
+    if (candidate.phase === "lateral-shift") {
+      const orientDir = dir(candidate.orientation)
+      const kickedSource = {
+        x: label.anchorPoint.x - orientDir.x * LABEL_SEARCH_STEP,
+        y: label.anchorPoint.y - orientDir.y * LABEL_SEARCH_STEP,
+      }
+      return simplifyOrthogonalPath([
+        label.anchorPoint,
+        ...getConnectorTracePath(
+          kickedSource,
+          candidate.anchorPoint,
+          candidate.orientation,
+        ),
+      ])
     }
+
+    return getConnectorTracePath(
+      label.anchorPoint,
+      candidate.anchorPoint,
+      candidate.orientation,
+    )
   }
 
   private getSearchStartAnchor(
@@ -583,22 +596,24 @@ export class AvailableNetOrientationSolver extends BaseSolver {
     )?.netLabelHeight
   }
 
-  private getCandidateStatus(
-    candidate: CandidateLabel,
-    label: NetLabelPlacement,
-    labelIndex: number,
-  ) {
+  private getCandidateStatus(params: {
+    candidate: CandidateLabel
+    label: NetLabelPlacement
+    labelIndex: number
+    phase: CandidatePhase
+  }) {
+    const { candidate, label, labelIndex, phase } = params
     const boundsStatus = this.getBoundsStatus(
       getRectBounds(candidate.center, candidate.width, candidate.height),
       labelIndex,
     )
     if (boundsStatus !== "valid") return boundsStatus
 
-    const connectorTrace = getConnectorTracePath(
-      label.anchorPoint,
-      candidate.anchorPoint,
-      candidate.orientation,
-    )
+    const connectorTrace = this.getCandidateConnectorTrace(label, {
+      anchorPoint: candidate.anchorPoint,
+      orientation: candidate.orientation,
+      phase,
+    })
 
     if (tracePathCrossesAnyTrace(connectorTrace, this.traceMap)) {
       return "trace-collision"
@@ -614,7 +629,7 @@ export class AvailableNetOrientationSolver extends BaseSolver {
       if (i === labelIndex) continue
       const otherLabel = this.outputNetLabelPlacements[i]!
       if (
-        tracePathCrossesAnyBounds(
+        tracePathIntersectsBounds(
           connectorTrace,
           getRectBounds(otherLabel.center, otherLabel.width, otherLabel.height),
         )

package/lib/solvers/AvailableNetOrientationSolver/geometry.ts

@@ -2,6 +2,7 @@ import type { Point } from "@tscircuit/math-utils"
 import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
 import type { InputProblem } from "lib/types/InputProblem"
 import type { FacingDirection } from "lib/utils/dir"
+import { segmentIntersectsRect } from "lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/collisions"
 import { EPS, TRACE_BOUNDARY_TOLERANCE } from "./constants"
 import type { Bounds, ChipSide } from "./types"
 
@@ -102,6 +103,18 @@ export const tracePathCrossesAnyBounds = (
   return false
 }
 
+export const tracePathIntersectsBounds = (
+  tracePath: Point[],
+  bounds: Bounds,
+) => {
+  for (let i = 0; i < tracePath.length - 1; i++) {
+    if (segmentIntersectsRect(tracePath[i]!, tracePath[i + 1]!, bounds)) {
+      return true
+    }
+  }
+  return false
+}
+
 export const tracePathCrossesAnyTrace = (
   tracePath: Point[],
   traceMap: Record<string, SolvedTracePath>,

package/lib/solvers/NetLabelTraceCollisionSolver/NetLabelTraceCollisionSolver.ts

@@ -72,31 +72,27 @@ function buildMergedObstacleLabel(
   }
 }
 
-interface TraceInnerLabelOverlap {
+interface TraceLabelOverlap {
   trace: SolvedTracePath
   label: NetLabelPlacement
 }
 
 /**
- * Detects overlaps where a trace's INTERIOR (non-endpoint) segments cross a label.
- * Traces are allowed to boundary a label at their endpoints (pin locations),
- * just not allowed to cross through it in the middle.
+ * Detects overlaps where a trace segment intersects a label from another net.
+ * Point-only contact is allowed by segmentIntersectsRect; positive overlap on
+ * a label edge is still a visual collision and should be rerouted.
  */
-function detectInnerTraceLabelOverlaps(
+function detectTraceLabelOverlaps(
   traces: SolvedTracePath[],
   labels: NetLabelPlacement[],
-): TraceInnerLabelOverlap[] {
-  const overlaps: TraceInnerLabelOverlap[] = []
+): TraceLabelOverlap[] {
+  const overlaps: TraceLabelOverlap[] = []
   for (const trace of traces) {
     for (const label of labels) {
       if (trace.globalConnNetId === label.globalConnNetId) continue
       const bounds = getRectBounds(label.center, label.width, label.height)
       const path = trace.tracePath
-      // Skip first and last segments — trace endpoints (pins) may legitimately
-      // sit inside or adjacent to labels of neighbouring nets.
-      const innerStart = 1
-      const innerEnd = path.length - 2
-      for (let i = innerStart; i < innerEnd; i++) {
+      for (let i = 0; i < path.length - 1; i++) {
         if (segmentIntersectsRect(path[i]!, path[i + 1]!, bounds)) {
           overlaps.push({ trace, label })
           break
@@ -183,7 +179,7 @@ export class NetLabelTraceCollisionSolver extends BaseSolver {
       return
     }
 
-    const overlaps = detectInnerTraceLabelOverlaps(
+    const overlaps = detectTraceLabelOverlaps(
       this.outputTraces,
       this.outputNetLabelPlacements,
     )

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,14 @@ 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
-
     // Compute offsets for each island involved: alternate directions
-    const offsets = this.overlappingTraceSegments.map((_, idx) => {
+    const offsets = this.overlappingTraceSegments.map((group, idx) => {
       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
@@ -82,8 +91,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 +149,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/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.63",
+  "version": "0.0.65",
   "type": "module",
   "scripts": {
     "start": "cosmos",

package/tests/examples/__snapshots__/example34.snap.svg

@@ -2,56 +2,60 @@
   <rect width="100%" height="100%" fill="white" />
   <g>
     <circle data-type="point" data-label="U1.1
-x+" data-x="1.1" data-y="0.30000000000000004" cx="487.83715012722644" cy="248.75318066157763" r="3" fill="hsl(319, 100%, 50%, 0.8)" />
+x+" data-x="1.1" data-y="0.30000000000000004" cx="479.84291324526953" cy="250.0249910746162" r="3" fill="hsl(319, 100%, 50%, 0.8)" />
   </g>
   <g>
     <circle data-type="point" data-label="U1.2
-x+" data-x="1.1" data-y="0.09999999999999998" cx="487.83715012722644" cy="289.46564885496184" r="3" fill="hsl(320, 100%, 50%, 0.8)" />
+x+" data-x="1.1" data-y="0.09999999999999998" cx="479.84291324526953" cy="290.0107104605498" r="3" fill="hsl(320, 100%, 50%, 0.8)" />
   </g>
   <g>
     <circle data-type="point" data-label="U1.3
-x+" data-x="1.1" data-y="-0.10000000000000003" cx="487.83715012722644" cy="330.17811704834605" r="3" fill="hsl(321, 100%, 50%, 0.8)" />
+x+" data-x="1.1" data-y="-0.10000000000000003" cx="479.84291324526953" cy="329.9964298464834" r="3" fill="hsl(321, 100%, 50%, 0.8)" />
   </g>
   <g>
     <circle data-type="point" data-label="U1.4
-x+" data-x="1.1" data-y="-0.30000000000000004" cx="487.83715012722644" cy="370.89058524173026" r="3" fill="hsl(322, 100%, 50%, 0.8)" />
+x+" data-x="1.1" data-y="-0.30000000000000004" cx="479.84291324526953" cy="369.982149232417" r="3" fill="hsl(322, 100%, 50%, 0.8)" />
   </g>
   <g>
-    <circle data-type="point" data-label="" data-x="1.1" data-y="0.30000000000000004" cx="487.83715012722644" cy="248.75318066157763" r="3" fill="hsl(40, 100%, 50%, 0.9)" />
+    <circle data-type="point" data-label="anchorPoint
+orientation: x+" data-x="1.1" data-y="0.30000000000000004" cx="479.84291324526953" cy="250.0249910746162" r="3" fill="hsl(40, 100%, 50%, 0.9)" />
   </g>
   <g>
-    <circle data-type="point" data-label="" data-x="1.1" data-y="0.09999999999999998" cx="487.83715012722644" cy="289.46564885496184" r="3" fill="hsl(40, 100%, 50%, 0.9)" />
+    <circle data-type="point" data-label="anchorPoint
+orientation: x+" data-x="1.1" data-y="0.09999999999999998" cx="479.84291324526953" cy="290.0107104605498" r="3" fill="hsl(40, 100%, 50%, 0.9)" />
   </g>
   <g>
-    <circle data-type="point" data-label="" data-x="1.5510000000000002" data-y="0.4009999999999999" cx="579.6437659033079" cy="228.1933842239186" r="3" fill="hsl(40, 100%, 50%, 0.9)" />
+    <circle data-type="point" data-label="anchorPoint
+orientation: y+" data-x="1.601" data-y="0.4009999999999999" cx="580.0071403070332" cy="229.83220278471975" r="3" fill="hsl(40, 100%, 50%, 0.9)" />
   </g>
   <g>
-    <circle data-type="point" data-label="" data-x="1.201" data-y="-0.5010000000000001" cx="508.39694656488547" cy="411.80661577608146" r="3" fill="hsl(40, 100%, 50%, 0.9)" />
+    <circle data-type="point" data-label="anchorPoint
+orientation: y-" data-x="1.201" data-y="-0.5010000000000001" cx="500.035701535166" cy="410.1677972152803" r="3" fill="hsl(40, 100%, 50%, 0.9)" />
   </g>
   <g>
-    <polyline data-points="1.1,-0.10000000000000003 1.5510000000000002,-0.10000000000000003 1.5510000000000002,0.4009999999999999" data-type="line" data-label="" points="487.83715012722644,330.17811704834605 579.6437659033079,330.17811704834605 579.6437659033079,228.1933842239186" fill="none" stroke="purple" stroke-width="1" />
+    <polyline data-points="1.1,-0.10000000000000003 1.601,-0.10000000000000003 1.601,0.4009999999999999" data-type="line" data-label="" points="479.84291324526953,329.9964298464834 580.0071403070332,329.9964298464834 580.0071403070332,229.83220278471975" fill="none" stroke="purple" stroke-width="1" />
   </g>
   <g>
-    <polyline data-points="1.1,-0.30000000000000004 1.201,-0.30000000000000004 1.201,-0.5010000000000001" data-type="line" data-label="" points="487.83715012722644,370.89058524173026 508.39694656488547,370.89058524173026 508.39694656488547,411.80661577608146" fill="none" stroke="purple" stroke-width="1" />
+    <polyline data-points="1.1,-0.30000000000000004 1.201,-0.30000000000000004 1.201,-0.5010000000000001" data-type="line" data-label="" points="479.84291324526953,369.982149232417 500.035701535166,369.982149232417 500.035701535166,410.1677972152803" fill="none" stroke="purple" stroke-width="1" />
   </g>
   <g>
-    <rect data-type="rect" data-label="schematic_component_0" data-x="0" data-y="0" x="40" y="208.04071246819342" width="447.83715012722644" height="203.56234096692106" fill="hsl(24, 100%, 50%, 0.8)" stroke="black" stroke-width="0.004912500000000001" />
+    <rect data-type="rect" data-label="schematic_component_0" data-x="0" data-y="0" x="39.99999999999997" y="210.03927168868262" width="439.84291324526953" height="199.92859692966795" fill="hsl(24, 100%, 50%, 0.8)" stroke="black" stroke-width="0.005001785714285715" />
   </g>
   <g>
     <rect data-type="rect" data-label="netId: SCL
-globalConnNetId: connectivity_net0" data-x="1.326" data-y="0.30000000000000004" x="488.0407124681933" y="228.39694656488552" width="91.60305343511459" height="40.71246819338421" fill="hsl(40, 100%, 50%, 0.35)" stroke="black" stroke-width="0.004912500000000001" />
+globalConnNetId: connectivity_net0" data-x="1.326" data-y="0.30000000000000004" x="480.0428418421992" y="230.03213138164938" width="89.96786861835062" height="39.985719385933635" fill="hsl(40, 100%, 50%, 0.35)" stroke="black" stroke-width="0.005001785714285715" />
   </g>
   <g>
     <rect data-type="rect" data-label="netId: SDA
-globalConnNetId: connectivity_net1" data-x="1.326" data-y="0.09999999999999998" x="488.0407124681933" y="269.10941475826974" width="91.60305343511459" height="40.71246819338421" fill="hsl(40, 100%, 50%, 0.35)" stroke="black" stroke-width="0.004912500000000001" />
+globalConnNetId: connectivity_net1" data-x="1.326" data-y="0.09999999999999998" x="480.0428418421992" y="270.017850767583" width="89.96786861835062" height="39.98571938593358" fill="hsl(40, 100%, 50%, 0.35)" stroke="black" stroke-width="0.005001785714285715" />
   </g>
   <g>
     <rect data-type="rect" data-label="netId: V3_3
-globalConnNetId: connectivity_net2" data-x="1.5510000000000002" data-y="0.6259999999999999" x="559.2875318066158" y="136.59033078880412" width="40.71246819338421" height="91.60305343511448" fill="#ef444466" stroke="#ef4444" stroke-width="0.004912500000000001" />
+globalConnNetId: connectivity_net2" data-x="1.601" data-y="0.6259999999999999" x="560.0142806140664" y="139.86433416636916" width="39.985719385933635" height="89.9678686183506" fill="#ef444466" stroke="#ef4444" stroke-width="0.005001785714285715" />
   </g>
   <g>
     <rect data-type="rect" data-label="netId: GND
-globalConnNetId: connectivity_net3" data-x="1.201" data-y="-0.7260000000000001" x="488.0407124681933" y="411.80661577608146" width="40.71246819338421" height="91.60305343511448" fill="#00000066" stroke="#000000" stroke-width="0.004912500000000001" />
+globalConnNetId: connectivity_net3" data-x="1.201" data-y="-0.7260000000000001" x="480.0428418421992" y="410.1677972152803" width="39.985719385933635" height="89.96786861835051" fill="#00000066" stroke="#000000" stroke-width="0.005001785714285715" />
   </g>
   <g id="crosshair" style="display: none">
     <line id="crosshair-h" y1="0" y2="640" stroke="#666" stroke-width="0.5" />
@@ -81,12 +85,12 @@ globalConnNetId: connectivity_net3" data-x="1.201" data-y="-0.7260000000000001"
 
       // Calculate real coordinates using inverse transformation
       const matrix = {
-        "a": 203.56234096692108,
+        "a": 199.92859692966798,
         "c": 0,
-        "e": 263.9185750636132,
+        "e": 259.92145662263476,
         "b": 0,
-        "d": -203.56234096692108,
-        "f": 309.82188295165395
+        "d": -199.92859692966798,
+        "f": 310.0035701535166
       };
       // Manually invert and apply the affine transform
       // Since we only use translate and scale, we can directly compute:

package/tests/examples/example34.test.ts

@@ -2,11 +2,19 @@ import { test, expect } from "bun:test"
 import { SchematicTracePipelineSolver } from "lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver"
 import inputProblem from "../assets/example34.json"
 import "tests/fixtures/matcher"
+import { getTraceLabelCollisions } from "tests/fixtures/traceLabelCollisions"
 
 test("example34", () => {
   const solver = new SchematicTracePipelineSolver(inputProblem as any)
 
   solver.solve()
 
+  expect(
+    getTraceLabelCollisions(
+      solver.netLabelNetLabelCollisionSolver!.traces,
+      solver.netLabelNetLabelCollisionSolver!.outputNetLabelPlacements,
+    ),
+  ).toEqual([])
+
   expect(solver).toMatchSolverSnapshot(import.meta.path)
 })

package/tests/fixtures/traceLabelCollisions.ts

@@ -0,0 +1,42 @@
+import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
+import { getRectBounds } from "lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/geometry"
+import { segmentIntersectsRect } from "lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/collisions"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+
+export const getTraceLabelCollisions = (
+  traces: SolvedTracePath[],
+  labels: NetLabelPlacement[],
+) => {
+  const collisions: Array<{
+    traceId: string
+    traceNetId: string
+    labelNetId: string
+    segmentIndex: number
+  }> = []
+
+  for (const trace of traces) {
+    for (const label of labels) {
+      if (trace.globalConnNetId === label.globalConnNetId) continue
+
+      const bounds = getRectBounds(label.center, label.width, label.height)
+      for (let i = 0; i < trace.tracePath.length - 1; i++) {
+        if (
+          segmentIntersectsRect(
+            trace.tracePath[i]!,
+            trace.tracePath[i + 1]!,
+            bounds,
+          )
+        ) {
+          collisions.push({
+            traceId: trace.mspPairId,
+            traceNetId: trace.globalConnNetId,
+            labelNetId: label.globalConnNetId,
+            segmentIndex: i,
+          })
+        }
+      }
+    }
+  }
+
+  return collisions
+}