@tscircuit/schematic-trace-solver 0.0.37 → 0.0.38

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

@@ -55,3 +55,20 @@ export const findFirstCollision = (
   }
   return null
 }
+
+/**
+ * Checks if a given path has any intersections with a set of chip obstacles.
+ */
+export const isPathCollidingWithObstacles = (
+  path: Point[],
+  obstacles: ChipWithBounds[],
+): boolean => {
+  for (let i = 0; i < path.length - 1; i++) {
+    for (const obstacle of obstacles) {
+      if (segmentIntersectsRect(path[i], path[i + 1], obstacle)) {
+        return true // Found a collision
+      }
+    }
+  }
+  return false // No collisions found
+}

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

@@ -12,27 +12,37 @@ export const shiftSegmentOrth = (
   newCoord: number,
   eps = EPS,
 ): Point[] | null => {
-  if (segIndex < 0 || segIndex >= pts.length - 1) return null
+  if (segIndex < 0 || segIndex >= pts.length - 1) {
+    return null
+  }
   const a = pts[segIndex]!
   const b = pts[segIndex + 1]!
   const vert = isVertical(a, b, eps)
   const horz = isHorizontal(a, b, eps)
-  if (!vert && !horz) return null
+  if (!vert && !horz) {
+    return null
+  }
 
   // Ensure axis matches orthogonal shift
-  if (vert && axis !== "x") return null
-  if (horz && axis !== "y") return null
+  if (vert && axis !== "x") {
+    return null
+  }
+  if (horz && axis !== "y") {
+    return null
+  }
 
   const out = pts.map((p) => ({ ...p }))
 
   if (axis === "x") {
-    if (Math.abs(a.x - newCoord) < eps && Math.abs(b.x - newCoord) < eps)
+    if (Math.abs(a.x - newCoord) < eps && Math.abs(b.x - newCoord) < eps) {
       return null
+    }
     out[segIndex] = { ...out[segIndex], x: newCoord }
     out[segIndex + 1] = { ...out[segIndex + 1], x: newCoord }
   } else {
-    if (Math.abs(a.y - newCoord) < eps && Math.abs(b.y - newCoord) < eps)
+    if (Math.abs(a.y - newCoord) < eps && Math.abs(b.y - newCoord) < eps) {
       return null
+    }
     out[segIndex] = { ...out[segIndex], y: newCoord }
     out[segIndex + 1] = { ...out[segIndex + 1], y: newCoord }
   }
@@ -42,24 +52,33 @@ export const shiftSegmentOrth = (
     const p = out[segIndex - 1]!
     const q = out[segIndex]!
     const manhattan = Math.abs(p.x - q.x) + Math.abs(p.y - q.y)
-    if (manhattan < eps) return null
+    if (manhattan < eps) {
+      return null
+    }
   }
   if (segIndex + 2 <= out.length - 1) {
     const p = out[segIndex + 1]!
     const q = out[segIndex + 2]!
     const manhattan = Math.abs(p.x - q.x) + Math.abs(p.y - q.y)
-    if (manhattan < eps) return null
+    if (manhattan < eps) {
+      return null
+    }
   }
 
   // Sanity: still orthogonal
   for (let i = 0; i < out.length - 1; i++) {
     const u = out[i]!
     const v = out[i + 1]!
-    if (!isHorizontal(u, v, eps) && !isVertical(u, v, eps)) return null
+    if (!isHorizontal(u, v, eps) && !isVertical(u, v, eps)) {
+      return null
+    }
   }
-
   return out
 }
 
-export const pathKey = (pts: Point[], decimals = 6) =>
-  pts.map((p) => `${p.x.toFixed(decimals)},${p.y.toFixed(decimals)}`).join("|")
+export const pathKey = (pts: Point[], decimals = 6) => {
+  const key = pts
+    .map((p) => `${p.x.toFixed(decimals)},${p.y.toFixed(decimals)}`)
+    .join("|")
+  return key
+}

package/lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver.ts

@@ -12,6 +12,7 @@ import { TraceOverlapShiftSolver } from "../TraceOverlapShiftSolver/TraceOverlap
 import { NetLabelPlacementSolver } from "../NetLabelPlacementSolver/NetLabelPlacementSolver"
 import { visualizeInputProblem } from "./visualizeInputProblem"
 import { GuidelinesSolver } from "../GuidelinesSolver/GuidelinesSolver"
+import { TraceLabelOverlapAvoidanceSolver } from "../TraceLabelOverlapAvoidanceSolver/TraceLabelOverlapAvoidanceSolver"
 import { getInputChipBounds } from "../GuidelinesSolver/getInputChipBounds"
 import { correctPinsInsideChips } from "./correctPinsInsideChip"
 import { expandChipsToFitPins } from "./expandChipsToFitPins"
@@ -52,6 +53,7 @@ export class SchematicTracePipelineSolver extends BaseSolver {
   schematicTraceLinesSolver?: SchematicTraceLinesSolver
   traceOverlapShiftSolver?: TraceOverlapShiftSolver
   netLabelPlacementSolver?: NetLabelPlacementSolver
+  traceLabelOverlapAvoidanceSolver?: TraceLabelOverlapAvoidanceSolver
 
   startTimeOfPhase: Record<string, number>
   endTimeOfPhase: Record<string, number>
@@ -134,6 +136,44 @@ export class SchematicTracePipelineSolver extends BaseSolver {
         },
       },
     ),
+    definePipelineStep(
+      "traceLabelOverlapAvoidanceSolver",
+      TraceLabelOverlapAvoidanceSolver,
+      (instance) => {
+        const traceMap =
+          instance.traceOverlapShiftSolver?.correctedTraceMap ??
+          Object.fromEntries(
+            instance.schematicTraceLinesSolver!.solvedTracePaths.map((p) => [
+              p.mspPairId,
+              p,
+            ]),
+          )
+        const traces = Object.values(traceMap)
+        const netLabelPlacements =
+          instance.netLabelPlacementSolver!.netLabelPlacements
+
+        return [
+          {
+            inputProblem: instance.inputProblem,
+            traces,
+            netLabelPlacements,
+          },
+        ]
+      },
+      {
+        onSolved: (instance) => {
+          if (
+            instance.traceLabelOverlapAvoidanceSolver &&
+            instance.netLabelPlacementSolver
+          ) {
+            const { netLabelPlacements } =
+              instance.traceLabelOverlapAvoidanceSolver.getOutput()
+            instance.netLabelPlacementSolver.netLabelPlacements =
+              netLabelPlacements
+          }
+        },
+      },
+    ),
   ]
 
   constructor(inputProblem: InputProblem) {

package/lib/solvers/TraceLabelOverlapAvoidanceSolver/TraceLabelOverlapAvoidanceSolver.ts

@@ -0,0 +1,247 @@
+import { BaseSolver } from "../BaseSolver/BaseSolver"
+import { detectTraceLabelOverlap } from "./detectTraceLabelOverlap"
+import { rerouteCollidingTrace } from "./rerouteCollidingTrace"
+import type { SolvedTracePath } from "../SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import type { NetLabelPlacement } from "../NetLabelPlacementSolver/NetLabelPlacementSolver"
+import type { GraphicsObject } from "graphics-debug"
+import { visualizeInputProblem } from "../SchematicTracePipelineSolver/visualizeInputProblem"
+import { getRectBounds } from "../NetLabelPlacementSolver/SingleNetLabelPlacementSolver/geometry"
+import { getColorFromString } from "lib/utils/getColorFromString"
+import type { InputProblem } from "lib/types/InputProblem"
+import { minimizeTurnsWithFilteredLabels } from "./turnMinimization"
+import { balanceLShapes } from "./balanceLShapes"
+import { NetLabelPlacementSolver } from "../NetLabelPlacementSolver/NetLabelPlacementSolver"
+
+interface TraceLabelOverlapAvoidanceSolverInput {
+  inputProblem: InputProblem
+  traces: SolvedTracePath[]
+  netLabelPlacements: NetLabelPlacement[]
+}
+
+export class TraceLabelOverlapAvoidanceSolver extends BaseSolver {
+  private problem: InputProblem
+  private traces: SolvedTracePath[]
+  private netTempLabelPlacements: NetLabelPlacement[]
+  private netLabelPlacements: NetLabelPlacement[]
+  private updatedTraces: SolvedTracePath[]
+  private updatedTracesMap: Map<string, SolvedTracePath>
+  private mergedLabelNetIdMap: Map<string, Set<string>>
+  private detourCountByLabel: Map<string, number>
+  private readonly PADDING_BUFFER = 0.1
+
+  constructor(solverInput: TraceLabelOverlapAvoidanceSolverInput) {
+    super()
+    this.problem = solverInput.inputProblem
+    this.traces = solverInput.traces
+    this.updatedTraces = [...solverInput.traces]
+    this.updatedTracesMap = new Map()
+    this.mergedLabelNetIdMap = new Map()
+    this.detourCountByLabel = new Map()
+
+    const originalLabels = solverInput.netLabelPlacements
+    this.netLabelPlacements = originalLabels
+    if (!originalLabels || originalLabels.length === 0) {
+      this.netTempLabelPlacements = []
+      return
+    }
+
+    const labelGroups = new Map<string, NetLabelPlacement[]>()
+
+    for (const p of originalLabels) {
+      if (p.pinIds.length === 0) continue
+      const chipId = p.pinIds[0].split(".")[0]
+      if (!chipId) continue
+      const key = `${chipId}-${p.orientation}`
+      if (!labelGroups.has(key)) {
+        labelGroups.set(key, [])
+      }
+      labelGroups.get(key)!.push(p)
+    }
+
+    const finalPlacements: NetLabelPlacement[] = []
+    for (const [key, group] of labelGroups.entries()) {
+      if (group.length <= 1) {
+        finalPlacements.push(...group)
+        continue
+      }
+
+      let minX = Infinity,
+        minY = Infinity,
+        maxX = -Infinity,
+        maxY = -Infinity
+      for (const p of group) {
+        const bounds = getRectBounds(p.center, p.width, p.height)
+        minX = Math.min(minX, bounds.minX)
+        minY = Math.min(minY, bounds.minY)
+        maxX = Math.max(maxX, bounds.maxX)
+        maxY = Math.max(maxY, bounds.maxY)
+      }
+
+      const newWidth = maxX - minX
+      const newHeight = maxY - minY
+      const template = group[0]!
+      const syntheticId = `merged-group-${key}`
+      const originalNetIds = new Set(group.map((p) => p.globalConnNetId))
+      this.mergedLabelNetIdMap.set(syntheticId, originalNetIds)
+
+      finalPlacements.push({
+        ...template,
+        globalConnNetId: syntheticId,
+        width: newWidth,
+        height: newHeight,
+        center: { x: minX + newWidth / 2, y: minY + newHeight / 2 },
+        pinIds: [...new Set(group.flatMap((p) => p.pinIds))],
+        mspConnectionPairIds: [
+          ...new Set(group.flatMap((p) => p.mspConnectionPairIds)),
+        ],
+      })
+    }
+
+    this.netTempLabelPlacements = finalPlacements
+  }
+
+  override _step() {
+    if (
+      !this.traces ||
+      this.traces.length === 0 ||
+      !this.netTempLabelPlacements ||
+      this.netTempLabelPlacements.length === 0
+    ) {
+      this.solved = true
+      return
+    }
+
+    this.detourCountByLabel.clear()
+
+    const overlaps = detectTraceLabelOverlap(
+      this.traces,
+      this.netTempLabelPlacements,
+    )
+
+    if (overlaps.length === 0) {
+      this.solved = true
+      return
+    }
+
+    const unfriendlyOverlaps = overlaps.filter((o) => {
+      const originalNetIds = this.mergedLabelNetIdMap.get(
+        o.label.globalConnNetId,
+      )
+      if (originalNetIds) {
+        return !originalNetIds.has(o.trace.globalConnNetId)
+      }
+      return o.trace.globalConnNetId !== o.label.globalConnNetId
+    })
+
+    if (unfriendlyOverlaps.length === 0) {
+      this.solved = true
+      return
+    }
+
+    const updatedTracesMap = new Map<string, SolvedTracePath>()
+    for (const trace of this.traces) {
+      updatedTracesMap.set(trace.mspPairId, trace)
+    }
+
+    const processedTraceIds = new Set<string>()
+
+    for (const overlap of unfriendlyOverlaps) {
+      if (processedTraceIds.has(overlap.trace.mspPairId)) {
+        continue
+      }
+
+      const currentTraceState = updatedTracesMap.get(overlap.trace.mspPairId)!
+      const labelId = overlap.label.globalConnNetId
+      const detourCount = this.detourCountByLabel.get(labelId) || 0
+
+      const newTrace = rerouteCollidingTrace({
+        trace: currentTraceState,
+        label: overlap.label,
+        problem: this.problem,
+        paddingBuffer: this.PADDING_BUFFER,
+        detourCount,
+      })
+
+      if (newTrace.tracePath !== currentTraceState.tracePath) {
+        this.detourCountByLabel.set(labelId, detourCount + 1)
+      }
+
+      updatedTracesMap.set(currentTraceState.mspPairId, newTrace)
+      processedTraceIds.add(currentTraceState.mspPairId)
+    }
+
+    this.updatedTraces = Array.from(updatedTracesMap.values())
+
+    const minimizedTraces = minimizeTurnsWithFilteredLabels({
+      traces: this.updatedTraces,
+      problem: this.problem,
+      allLabelPlacements: this.netTempLabelPlacements, // Use temp labels which include merged ones
+      mergedLabelNetIdMap: this.mergedLabelNetIdMap,
+      paddingBuffer: this.PADDING_BUFFER,
+    })
+    if (minimizedTraces) {
+      this.updatedTraces = minimizedTraces
+    }
+    const balancedTraces = balanceLShapes({
+      traces: this.updatedTraces,
+      problem: this.problem,
+      allLabelPlacements: this.netLabelPlacements,
+    })
+    if (balancedTraces) {
+      this.updatedTraces = balancedTraces
+    }
+
+    this.updatedTracesMap.clear()
+    for (const trace of this.updatedTraces) {
+      this.updatedTracesMap.set(trace.mspPairId, trace)
+    }
+
+    const finalLabelPlacementSolver = new NetLabelPlacementSolver({
+      inputProblem: this.problem,
+      inputTraceMap: Object.fromEntries(this.updatedTracesMap),
+    })
+    finalLabelPlacementSolver.solve()
+    this.netLabelPlacements = finalLabelPlacementSolver.netLabelPlacements
+
+    this.solved = true
+  }
+
+  getOutput() {
+    return {
+      traceMap: this.updatedTracesMap,
+      netLabelPlacements: this.netLabelPlacements,
+    }
+  }
+
+  override visualize(): GraphicsObject {
+    const graphics = visualizeInputProblem(this.problem)
+
+    if (!graphics.lines) graphics.lines = []
+    if (!graphics.circles) graphics.circles = []
+    if (!graphics.texts) graphics.texts = []
+    if (!graphics.rects) graphics.rects = []
+
+    for (const trace of Object.values(this.updatedTraces)) {
+      graphics.lines!.push({
+        points: trace.tracePath,
+        strokeColor: "purple",
+      })
+    }
+
+    for (const p of this.netLabelPlacements) {
+      graphics.rects!.push({
+        center: p.center,
+        width: p.width,
+        height: p.height,
+        fill: getColorFromString(p.globalConnNetId, 0.35),
+      })
+      graphics.points!.push({
+        x: p.anchorPoint.x,
+        y: p.anchorPoint.y,
+        color: getColorFromString(p.globalConnNetId, 0.9),
+      })
+    }
+
+    return graphics
+  }
+}

package/lib/solvers/TraceLabelOverlapAvoidanceSolver/balanceLShapes.ts

@@ -0,0 +1,207 @@
+import type { Point } from "graphics-debug"
+import type { InputProblem } from "lib/types/InputProblem"
+import type { NetLabelPlacement } from "../NetLabelPlacementSolver/NetLabelPlacementSolver"
+import { getObstacleRects } from "../SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/rect"
+import type { SolvedTracePath } from "../SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import { segmentIntersectsRect } from "../SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions"
+import { simplifyPath } from "./simplifyPath"
+
+export const balanceLShapes = ({
+  traces,
+  problem,
+  allLabelPlacements,
+}: {
+  traces: SolvedTracePath[]
+  problem: InputProblem
+  allLabelPlacements: NetLabelPlacement[]
+}): SolvedTracePath[] | null => {
+  const TOLERANCE = 1e-5
+  let changesMade = false
+
+  for (const trace of traces) {
+    if (trace.tracePath.length === 4) {
+      const [p0, p1, p2, p3] = trace.tracePath
+      const isHVHShape = p0.y === p1.y && p1.x === p2.x && p2.y === p3.y
+      const isVHVShape = p0.x === p1.x && p1.y === p2.y && p2.x === p3.x
+
+      const isCollinearHorizontal =
+        p0.y === p1.y && p1.y === p2.y && p2.y === p3.y
+      const isCollinearVertical =
+        p0.x === p1.x && p1.x === p2.x && p2.x === p3.x
+      const isCollinear = isCollinearHorizontal || isCollinearVertical
+
+      let isSameDirection = false
+      if (isHVHShape) {
+        isSameDirection = Math.sign(p1.x - p0.x) === Math.sign(p3.x - p2.x)
+      } else if (isVHVShape) {
+        isSameDirection = Math.sign(p1.y - p0.y) === Math.sign(p3.y - p2.y)
+      }
+
+      const isValidZShape =
+        (isHVHShape || isVHVShape) && !isCollinear && isSameDirection
+
+      if (!isValidZShape) {
+        return null
+      }
+    }
+  }
+
+  const obstacles = getObstacleRects(problem).map((obs) => ({
+    ...obs,
+    minX: obs.minX + TOLERANCE,
+    maxX: obs.maxX - TOLERANCE,
+    minY: obs.minY + TOLERANCE,
+    maxY: obs.maxY - TOLERANCE,
+  }))
+
+  const segmentIntersectsAnyRect = (
+    p1: Point,
+    p2: Point,
+    rects: any[],
+  ): boolean => {
+    for (const rect of rects) {
+      if (segmentIntersectsRect(p1, p2, rect)) {
+        return true
+      }
+    }
+    return false
+  }
+
+  const getLabelBounds = (labels: NetLabelPlacement[], traceNetId: string) => {
+    const filteredLabels = labels.filter(
+      (label) => label.globalConnNetId !== traceNetId,
+    )
+
+    return filteredLabels.map((nl) => ({
+      minX: nl.center.x - nl.width / 2 + TOLERANCE,
+      maxX: nl.center.x + nl.width / 2 - TOLERANCE,
+      minY: nl.center.y - nl.height / 2 + TOLERANCE,
+      maxY: nl.center.y + nl.height / 2 - TOLERANCE,
+    }))
+  }
+
+  const newTraces = traces.map((trace) => {
+    let newPath = [...trace.tracePath]
+
+    if (newPath.length < 4) {
+      return { ...trace }
+    }
+
+    const labelBounds = getLabelBounds(
+      allLabelPlacements,
+      trace.globalConnNetId,
+    )
+
+    if (newPath.length === 4) {
+      const [p0, p1, p2, p3] = newPath
+      let p1New: Point, p2New: Point
+
+      const isHVHShape = p0.y === p1.y && p1.x === p2.x && p2.y === p3.y
+
+      if (isHVHShape) {
+        const idealX = (p0.x + p3.x) / 2
+        p1New = { x: idealX, y: p1.y }
+        p2New = { x: idealX, y: p2.y }
+      } else {
+        const idealY = (p0.y + p3.y) / 2
+        p1New = { x: p1.x, y: idealY }
+        p2New = { x: p2.x, y: idealY }
+      }
+
+      const collides =
+        segmentIntersectsAnyRect(p0, p1New, obstacles) ||
+        segmentIntersectsAnyRect(p1New, p2New, obstacles) ||
+        segmentIntersectsAnyRect(p2New, p3, obstacles) ||
+        segmentIntersectsAnyRect(p0, p1New, labelBounds) ||
+        segmentIntersectsAnyRect(p1New, p2New, labelBounds) ||
+        segmentIntersectsAnyRect(p2New, p3, labelBounds)
+
+      if (!collides) {
+        newPath[1] = p1New
+        newPath[2] = p2New
+        changesMade = true
+      }
+
+      return { ...trace, tracePath: simplifyPath(newPath) }
+    }
+
+    for (let i = 1; i < newPath.length - 4; i++) {
+      const p1 = newPath[i]
+      const p2 = newPath[i + 1]
+      const p3 = newPath[i + 2]
+      const p4 = newPath[i + 3]
+
+      const isHVHZShape = p1.y === p2.y && p2.x === p3.x && p3.y === p4.y
+      const isVHVZShape = p1.x === p2.x && p2.y === p3.y && p3.x === p4.x
+
+      const isCollinearHorizontal =
+        p1.y === p2.y && p2.y === p3.y && p3.y === p4.y
+      const isCollinearVertical =
+        p1.x === p2.x && p2.x === p3.x && p3.x === p4.x
+      const isCollinear = isCollinearHorizontal || isCollinearVertical
+
+      let isSameDirection = false
+      if (isHVHZShape) {
+        isSameDirection = Math.sign(p2.x - p1.x) === Math.sign(p4.x - p3.x)
+      } else if (isVHVZShape) {
+        isSameDirection = Math.sign(p2.y - p1.y) === Math.sign(p4.y - p3.y)
+      }
+
+      const isValidZShape =
+        (isHVHZShape || isVHVZShape) && !isCollinear && isSameDirection
+
+      if (!isValidZShape) {
+        continue
+      }
+
+      let p2New: Point, p3New: Point
+      const len1Original = isHVHZShape
+        ? Math.abs(p1.x - p2.x)
+        : Math.abs(p1.y - p2.y)
+      const len2Original = isHVHZShape
+        ? Math.abs(p3.x - p4.x)
+        : Math.abs(p3.y - p4.y)
+
+      if (Math.abs(len1Original - len2Original) < 0.001) {
+        continue
+      }
+
+      if (isHVHZShape) {
+        const idealX = (p1.x + p4.x) / 2
+        p2New = { x: idealX, y: p2.y }
+        p3New = { x: idealX, y: p3.y }
+      } else {
+        const idealY = (p1.y + p4.y) / 2
+        p2New = { x: p2.x, y: idealY }
+        p3New = { x: p3.x, y: idealY }
+      }
+
+      const collides =
+        segmentIntersectsAnyRect(p1, p2New, obstacles) ||
+        segmentIntersectsAnyRect(p2New, p3New, obstacles) ||
+        segmentIntersectsAnyRect(p3New, p4, obstacles) ||
+        segmentIntersectsAnyRect(p1, p2New, labelBounds) ||
+        segmentIntersectsAnyRect(p2New, p3New, labelBounds) ||
+        segmentIntersectsAnyRect(p3New, p4, labelBounds)
+
+      if (!collides) {
+        newPath[i + 1] = p2New
+        newPath[i + 2] = p3New
+        changesMade = true
+        i = 0
+      }
+    }
+
+    const finalSimplifiedPath = simplifyPath(newPath)
+    return {
+      ...trace,
+      tracePath: finalSimplifiedPath,
+    }
+  })
+
+  if (changesMade) {
+    return newTraces
+  } else {
+    return null
+  }
+}

package/lib/solvers/TraceLabelOverlapAvoidanceSolver/countTurns.ts

@@ -0,0 +1,18 @@
+import type { Point } from "@tscircuit/math-utils"
+
+export const countTurns = (points: Point[]): number => {
+  let turns = 0
+  for (let i = 1; i < points.length - 1; i++) {
+    const prev = points[i - 1]
+    const curr = points[i]
+    const next = points[i + 1]
+
+    const prevVertical = prev.x === curr.x
+    const nextVertical = curr.x === next.x
+
+    if (prevVertical !== nextVertical) {
+      turns++
+    }
+  }
+  return turns
+}

package/lib/solvers/TraceLabelOverlapAvoidanceSolver/detectTraceLabelOverlap.ts

@@ -0,0 +1,38 @@
+import type { SolvedTracePath } from "../SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import type { NetLabelPlacement } from "../NetLabelPlacementSolver/NetLabelPlacementSolver"
+import { segmentIntersectsRect } from "../NetLabelPlacementSolver/SingleNetLabelPlacementSolver/collisions"
+import { getRectBounds } from "../NetLabelPlacementSolver/SingleNetLabelPlacementSolver/geometry"
+
+export interface TraceLabelOverlap {
+  trace: SolvedTracePath
+  label: NetLabelPlacement
+}
+
+export const detectTraceLabelOverlap = (
+  traces: SolvedTracePath[],
+  netLabels: NetLabelPlacement[],
+): TraceLabelOverlap[] => {
+  const overlaps: TraceLabelOverlap[] = []
+
+  for (const trace of traces) {
+    for (const label of netLabels) {
+      const labelBounds = getRectBounds(label.center, label.width, label.height)
+
+      for (let i = 0; i < trace.tracePath.length - 1; i++) {
+        const p1 = trace.tracePath[i]
+        const p2 = trace.tracePath[i + 1]
+
+        if (segmentIntersectsRect(p1, p2, labelBounds)) {
+          // Check if the trace and label belong to the same net.
+          // If so, it's a self-attachment, not a collision.
+          if (trace.globalConnNetId === label.globalConnNetId) {
+            break // Move to the next label
+          }
+          overlaps.push({ trace, label })
+          break // Move to the next label
+        }
+      }
+    }
+  }
+  return overlaps
+}

package/lib/solvers/TraceLabelOverlapAvoidanceSolver/hasCollisions.ts

@@ -0,0 +1,26 @@
+import type { Point } from "graphics-debug"
+import {
+  isVertical,
+  isHorizontal,
+  segmentIntersectsRect,
+} from "../SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions"
+
+export const hasCollisions = (
+  pathSegments: Point[],
+  obstacles: any[],
+): boolean => {
+  // Check each segment of the path
+  for (let i = 0; i < pathSegments.length - 1; i++) {
+    const p1 = pathSegments[i]
+    const p2 = pathSegments[i + 1]
+
+    // Check collision with each obstacle
+    for (const obstacle of obstacles) {
+      if (segmentIntersectsRect(p1, p2, obstacle)) {
+        return true
+      }
+    }
+  }
+
+  return false
+}