@tscircuit/schematic-trace-solver 0.0.44 → 0.0.45

package/lib/solvers/TraceCleanupSolver/sub-solver/UntangleTraceSubsolver.ts

@@ -0,0 +1,370 @@
+import { BaseSolver } from "../../BaseSolver/BaseSolver"
+import type { InputProblem } from "../../../types/InputProblem"
+import type { SolvedTracePath } from "../../SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import type { NetLabelPlacement } from "../../NetLabelPlacementSolver/NetLabelPlacementSolver"
+
+import { findAllLShapedTurns, type LShape } from "./findAllLShapedTurns"
+import { getTraceObstacles } from "./getTraceObstacles"
+import { findIntersectionsWithObstacles } from "./findIntersectionsWithObstacles"
+import { generateLShapeRerouteCandidates } from "./generateLShapeRerouteCandidates"
+import { isPathColliding, type CollisionInfo } from "./isPathColliding"
+import {
+  generateRectangleCandidates,
+  type Rectangle,
+  type RectangleCandidate,
+} from "./generateRectangleCandidates"
+
+import type { GraphicsObject } from "graphics-debug"
+import type { Point } from "@tscircuit/math-utils"
+
+import { visualizeLSapes } from "./visualizeLSapes"
+import { visualizeIntersectionPoints } from "./visualizeIntersectionPoints"
+import { visualizeTightRectangle } from "../visualizeTightRectangle"
+import { visualizeCandidates } from "./visualizeCandidates"
+import { mergeGraphicsObjects } from "../mergeGraphicsObjects"
+import { visualizeCollision } from "./visualizeCollision"
+
+/**
+ * Defines the input structure for the UntangleTraceSubsolver.
+ */
+export interface UntangleTraceSubsolverInput {
+  inputProblem: InputProblem
+  allTraces: SolvedTracePath[]
+  allLabelPlacements: NetLabelPlacement[]
+  mergedLabelNetIdMap: Record<string, Set<string>>
+  paddingBuffer: number
+}
+
+/**
+ * Represents the different visualization modes for the UntangleTraceSubsolver.
+ */
+type VisualizationMode =
+  | "l_shapes"
+  | "intersection_points"
+  | "tight_rectangle"
+  | "candidates"
+
+/**
+ * The UntangleTraceSubsolver is designed to resolve complex overlaps and improve the routing of traces,
+ * particularly focusing on "L-shaped" turns that might be causing congestion or suboptimal paths.
+ * Its main workflow involves several steps:
+ * 1. **Identify L-Shapes**: It first identifies all L-shaped turns within the traces that need processing.
+ * 2. **Find Intersections**: For each L-shape, it determines intersection points with other traces and obstacles.
+ * 3. **Generate Rectangle Candidates**: Based on these intersection points, it generates potential rectangular regions for rerouting.
+ * 4. **Evaluate Candidates**: For each rectangular candidate, it generates alternative trace paths and evaluates them for collisions.
+ * 5. **Apply Best Route**: If a collision-free and improved route is found, it updates the trace path.
+ * This iterative process aims to untangle traces and create a cleaner, more efficient layout.
+ */
+export class UntangleTraceSubsolver extends BaseSolver {
+  private input: UntangleTraceSubsolverInput
+  private lShapesToProcess: LShape[] = []
+  private visualizationMode: VisualizationMode = "l_shapes"
+
+  private currentLShape: LShape | null = null
+  private intersectionPoints: Point[] = []
+  private tightRectangle: Rectangle | null = null
+  private candidates: Point[][] = []
+  private bestRoute: Point[] | null = null
+  private lastCollision: CollisionInfo | null = null
+  private collidingCandidate: Point[] | null = null
+
+  private rectangleCandidates: RectangleCandidate[] = []
+  private currentRectangleIndex = 0
+
+  private isInitialStep = true
+  private currentCandidateIndex = 0
+  private lShapeProcessingStep:
+    | "idle"
+    | "intersections"
+    | "rectangle_selection"
+    | "candidate_evaluation" = "idle"
+  private lShapeJustProcessed = false
+  private bestRouteFound: Point[] | null = null
+
+  constructor(solverInput: UntangleTraceSubsolverInput) {
+    super()
+    this.input = solverInput
+    this.visualizationMode = "l_shapes"
+
+    for (const trace of this.input.allTraces) {
+      const lShapes = findAllLShapedTurns(trace.tracePath)
+      this.lShapesToProcess.push(
+        ...lShapes.map((l) => ({ ...l, traceId: trace.mspPairId as string })),
+      )
+    }
+  }
+
+  override _step(): void {
+    if (this.isInitialStep) {
+      this.isInitialStep = false
+      return
+    }
+
+    if (this.lShapeJustProcessed) {
+      this._resetAfterLShapProcessing()
+      return
+    }
+
+    if (this.lShapesToProcess.length === 0 && this.currentLShape === null) {
+      this.solved = true
+      return
+    }
+
+    switch (this.lShapeProcessingStep) {
+      case "idle":
+        this._handleIdleStep()
+        break
+      case "intersections":
+        this._handleIntersectionsStep()
+        break
+      case "rectangle_selection":
+        this._handleRectangleSelectionStep()
+        break
+      case "candidate_evaluation":
+        this._handleCandidateEvaluationStep()
+        break
+    }
+  }
+
+  private _resetAfterLShapProcessing() {
+    this.lShapeProcessingStep = "idle"
+    this.currentLShape = null
+    this.currentCandidateIndex = 0
+    this.lShapeJustProcessed = false
+    this.visualizationMode = "l_shapes" // Reset visualization mode
+    this.intersectionPoints = [] // Clear temporary data
+    this.tightRectangle = null
+    this.candidates = []
+    this.bestRoute = null
+    this.lastCollision = null
+    this.collidingCandidate = null
+  }
+
+  private _handleIdleStep() {
+    this.currentLShape = this.lShapesToProcess.shift()!
+    if (!this.currentLShape) {
+      this.solved = true
+      return
+    }
+    this.lShapeProcessingStep = "intersections"
+    this.visualizationMode = "l_shapes"
+  }
+
+  private _handleIntersectionsStep() {
+    if (!this.currentLShape!.traceId) {
+      this.lShapeProcessingStep = "idle"
+      return
+    }
+    const allObstacles = getTraceObstacles(
+      this.input.allTraces,
+      this.currentLShape!.traceId,
+    )
+    const intersections1 = findIntersectionsWithObstacles(
+      this.currentLShape!.p1,
+      this.currentLShape!.p2,
+      allObstacles,
+    )
+    const intersections2 = findIntersectionsWithObstacles(
+      this.currentLShape!.p2,
+      this.currentLShape!.p3,
+      allObstacles,
+    )
+
+    this.intersectionPoints = [...intersections1, ...intersections2]
+
+    if (intersections1.length === 0 || intersections2.length === 0) {
+      this.lShapeProcessingStep = "idle"
+      return
+    }
+
+    this.rectangleCandidates = generateRectangleCandidates(
+      intersections1,
+      intersections2,
+    )
+    this.currentRectangleIndex = 0
+    this.lShapeProcessingStep = "rectangle_selection"
+  }
+
+  private _handleRectangleSelectionStep() {
+    if (this.currentRectangleIndex >= this.rectangleCandidates.length) {
+      this.lShapeProcessingStep = "idle"
+      return
+    }
+
+    const { rect, i1, i2 } =
+      this.rectangleCandidates[this.currentRectangleIndex]
+    this.tightRectangle = rect
+
+    this.candidates = generateLShapeRerouteCandidates({
+      lShape: this.currentLShape!,
+      rectangle: this.tightRectangle!,
+      padding: 2 * this.input.paddingBuffer,
+      interactionPoint1: i1,
+      interactionPoint2: i2,
+    })
+    this.currentCandidateIndex = 0
+    this.lastCollision = null
+    this.collidingCandidate = null
+
+    this.visualizationMode = "candidates"
+    this.lShapeProcessingStep = "candidate_evaluation"
+  }
+
+  private _handleCandidateEvaluationStep() {
+    this.visualizationMode = "candidates"
+
+    if (this.bestRouteFound) {
+      this._applyBestRoute(this.bestRouteFound)
+      this.bestRouteFound = null
+      return
+    }
+
+    if (this.currentCandidateIndex >= this.candidates.length) {
+      this.currentRectangleIndex++
+      this.lShapeProcessingStep = "rectangle_selection"
+      return
+    }
+
+    const currentCandidate = this.candidates[this.currentCandidateIndex]
+    const collisionResult = isPathColliding(
+      currentCandidate,
+      this.input.allTraces,
+      this.currentLShape!.traceId,
+    )
+
+    if (!collisionResult?.isColliding) {
+      this.bestRouteFound = currentCandidate
+      this.lastCollision = null
+      this.collidingCandidate = null
+    } else {
+      this.lastCollision = collisionResult
+      this.collidingCandidate = currentCandidate
+      this.currentCandidateIndex++
+    }
+  }
+
+  private _applyBestRoute(bestRoute: Point[]) {
+    this.bestRoute = bestRoute
+    this.collidingCandidate = null
+    this.lastCollision = null
+
+    const traceIndex = this.input.allTraces.findIndex(
+      (trace) => trace.mspPairId === this.currentLShape!.traceId,
+    )
+    if (traceIndex !== -1) {
+      const originalTrace = this.input.allTraces[traceIndex]
+      const p2Index = originalTrace.tracePath.findIndex(
+        (p) =>
+          p.x === this.currentLShape!.p2.x && p.y === this.currentLShape!.p2.y,
+      )
+      if (p2Index !== -1) {
+        const newTracePath = [
+          ...originalTrace.tracePath.slice(0, p2Index),
+          ...bestRoute,
+          ...originalTrace.tracePath.slice(p2Index + 1),
+        ]
+        this.input.allTraces[traceIndex] = {
+          ...originalTrace,
+          tracePath: newTracePath,
+        }
+        this.lShapesToProcess = this.lShapesToProcess.filter(
+          (l) => l.traceId !== this.currentLShape!.traceId,
+        )
+      }
+    }
+    this.lShapeJustProcessed = true
+  }
+
+  getOutput(): { traces: SolvedTracePath[] } {
+    return { traces: this.input.allTraces }
+  }
+
+  override visualize(): GraphicsObject {
+    // console.log("VISUALIZE STATE:", {
+    //   step: this.lShapeProcessingStep,
+    //   vizMode: this.visualizationMode,
+    //   lShape: this.currentLShape?.traceId,
+    //   rectIdx: this.currentRectangleIndex,
+    //   rectCount: this.rectangleCandidates.length,
+    //   tightRect: this.tightRectangle,
+    //   pathIdx: this.currentCandidateIndex,
+    //   pathCount: this.candidates.length,
+    //   lastCollision: this.lastCollision?.isColliding,
+    // })
+
+    switch (this.visualizationMode) {
+      case "l_shapes":
+        return visualizeLSapes(this.lShapesToProcess)
+      case "intersection_points":
+        return mergeGraphicsObjects([
+          this.currentLShape ? visualizeLSapes(this.currentLShape) : undefined,
+          visualizeIntersectionPoints(this.intersectionPoints),
+        ])
+      case "tight_rectangle":
+        return mergeGraphicsObjects([
+          this.currentLShape ? visualizeLSapes(this.currentLShape) : undefined,
+          visualizeIntersectionPoints(this.intersectionPoints),
+          this.tightRectangle
+            ? visualizeTightRectangle(this.tightRectangle)
+            : undefined,
+        ])
+      case "candidates": {
+        if (this.lShapeJustProcessed) {
+          const allTracesGraphics: GraphicsObject = { lines: [] }
+          for (const trace of this.input.allTraces) {
+            const isUpdatedTrace =
+              trace.mspPairId === this.currentLShape?.traceId
+            for (let i = 0; i < trace.tracePath.length - 1; i++) {
+              allTracesGraphics.lines!.push({
+                points: [trace.tracePath[i], trace.tracePath[i + 1]],
+                strokeColor: isUpdatedTrace ? "green" : "#ccc",
+              })
+            }
+          }
+          return allTracesGraphics
+        }
+
+        const allTracesGraphics: GraphicsObject = { lines: [] }
+        for (const trace of this.input.allTraces) {
+          for (let i = 0; i < trace.tracePath.length - 1; i++) {
+            allTracesGraphics.lines!.push({
+              points: [trace.tracePath[i], trace.tracePath[i + 1]],
+              strokeColor: "#ccc", // Light gray for other traces
+            })
+          }
+        }
+
+        let candidateToDraw: Point[] | undefined
+        if (this.bestRouteFound) {
+          candidateToDraw = this.bestRouteFound
+        } else if (this.lastCollision?.isColliding) {
+          candidateToDraw = this.collidingCandidate ?? undefined
+        } else {
+          if (this.currentCandidateIndex < this.candidates.length) {
+            candidateToDraw = this.candidates[this.currentCandidateIndex]
+          }
+        }
+
+        return mergeGraphicsObjects([
+          allTracesGraphics,
+          this.currentLShape ? visualizeLSapes(this.currentLShape) : undefined,
+          this.tightRectangle
+            ? visualizeTightRectangle(this.tightRectangle)
+            : undefined,
+          candidateToDraw
+            ? visualizeCandidates(
+                [candidateToDraw],
+                this.bestRouteFound ? "green" : "blue",
+                this.intersectionPoints,
+              )
+            : undefined,
+          this.lastCollision
+            ? visualizeCollision(this.lastCollision)
+            : undefined,
+        ])
+      }
+      default:
+        return {}
+    }
+  }
+}

package/lib/solvers/TraceCleanupSolver/sub-solver/findAllLShapedTurns.ts

@@ -0,0 +1,48 @@
+import type { Point } from "@tscircuit/math-utils"
+
+/**
+ * Represents an L-shaped turn in a trace path, defined by three consecutive points.
+ * p1 and p3 are the endpoints of the L-shape, and p2 is the corner point.
+ */
+export interface LShape {
+  p1: Point
+  p2: Point // The corner
+  p3: Point
+  traceId?: string
+}
+
+/**
+ * Identifies and returns all L-shaped turns within a given trace path.
+ * An L-shaped turn is detected when two consecutive segments are orthogonal (one vertical, one horizontal)
+ * and both segments have a minimum length. This function iterates through the trace path,
+ * checking every sequence of three points to see if they form an L-shape.
+ */
+export const findAllLShapedTurns = (tracePath: Point[]): LShape[] => {
+  const lShapes: LShape[] = []
+  if (tracePath.length < 3) {
+    return lShapes
+  }
+
+  for (let i = 0; i < tracePath.length - 2; i++) {
+    const p1 = tracePath[i]
+    const p2 = tracePath[i + 1]
+    const p3 = tracePath[i + 2]
+
+    const dx1 = p2.x - p1.x
+    const dy1 = p2.y - p1.y
+    const dx2 = p3.x - p2.x
+    const dy2 = p3.y - p2.y
+
+    // Check for a 90-degree turn (orthogonal segments)
+    if (
+      ((dx1 === 0 && dy2 === 0 && dy1 !== 0 && dx2 !== 0) || // Vertical then Horizontal
+        (dy1 === 0 && dx2 === 0 && dx1 !== 0 && dy2 !== 0)) && // Horizontal then Vertical
+      dx1 * dx1 + dy1 * dy1 >= 0.25 && // p1-p2 arm length >= 0.5
+      dx2 * dx2 + dy2 * dy2 >= 0.25 // p2-p3 arm length >= 0.5
+    ) {
+      lShapes.push({ p1, p2, p3 })
+    }
+  }
+
+  return lShapes
+}

package/lib/solvers/TraceCleanupSolver/sub-solver/findIntersectionsWithObstacles.ts

@@ -0,0 +1,36 @@
+import type { Point } from "@tscircuit/math-utils"
+import { getSegmentIntersection } from "@tscircuit/math-utils/line-intersections"
+import type { TraceObstacle } from "./getTraceObstacles"
+
+/**
+ * Finds all intersection points between a given line segment (p1-p2) and a list of trace obstacles.
+ * It iterates through each segment of every obstacle and checks for intersections with the input segment.
+ */
+export const findIntersectionsWithObstacles = (
+  p1: Point,
+  p2: Point,
+  obstacles: TraceObstacle[],
+): Point[] => {
+  const intersections: Point[] = []
+
+  for (const obstacle of obstacles) {
+    const obstaclePath = obstacle.points
+    for (let i = 0; i < obstaclePath.length - 1; i++) {
+      const o1 = obstaclePath[i]
+      const o2 = obstaclePath[i + 1]
+
+      // Ensure both points are defined before proceeding
+      if (!o1 || !o2) {
+        // console.warn("Skipping obstacle segment due to undefined point:", { o1, o2, obstaclePath });
+        continue
+      }
+
+      const intersection = getSegmentIntersection(p1, p2, o1, o2)
+      if (intersection) {
+        intersections.push(intersection)
+      }
+    }
+  }
+
+  return intersections
+}

package/lib/solvers/TraceCleanupSolver/sub-solver/generateLShapeRerouteCandidates.ts

@@ -0,0 +1,107 @@
+import type { Point } from "@tscircuit/math-utils"
+import type { LShape } from "./findAllLShapedTurns"
+import type { Rectangle } from "./generateRectangleCandidates"
+
+const EPS = 1e-6
+
+/**
+ * Checks if a segment defined by two points is vertical.
+ * It considers a segment vertical if the absolute difference between their x-coordinates is less than a small epsilon.
+ */
+const isVertical = (a: Point, b: Point, eps = EPS) => Math.abs(a.x - b.x) < eps
+
+/**
+ * Generates candidate reroutes for an L-shaped turn within a given rectangular area.
+ * This function calculates a new path that attempts to smooth out the L-shape by routing around the corner
+ * through the provided rectangle, adding padding to avoid immediate collisions.
+ * It considers different orientations of the L-shape relative to the rectangle to determine the appropriate rerouting points.
+ */
+export const generateLShapeRerouteCandidates = ({
+  lShape,
+  rectangle,
+  padding = 0.5,
+  interactionPoint1,
+  interactionPoint2,
+}: {
+  lShape: LShape
+  rectangle: Rectangle
+  padding: number
+  interactionPoint1: Point
+  interactionPoint2: Point
+}): Point[][] => {
+  const { p1, p2, p3 } = lShape
+  const { x, y, width, height } = rectangle
+
+  let c2: Point
+  let i1_padded: Point = interactionPoint1
+  let i2_padded: Point = interactionPoint2
+
+  if (Math.abs(p2.x - x) < EPS && Math.abs(p2.y - (y + height)) < EPS) {
+    c2 = { x: x + width + padding, y: y - padding }
+
+    if (isVertical(p1, p2)) {
+      i1_padded = { x: interactionPoint1.x, y: interactionPoint1.y - padding }
+    } else {
+      // isHorizontal(p1, p2)
+      i1_padded = { x: interactionPoint1.x + padding, y: interactionPoint1.y }
+    }
+    if (isVertical(p2, p3)) {
+      i2_padded = { x: interactionPoint2.x, y: interactionPoint2.y - padding }
+    } else {
+      // isHorizontal(p2, p3)
+      i2_padded = { x: interactionPoint2.x + padding, y: interactionPoint2.y }
+    }
+  } else if (
+    Math.abs(p2.x - (x + width)) < EPS &&
+    Math.abs(p2.y - (y + height)) < EPS
+  ) {
+    c2 = { x: x - padding, y: y - padding }
+
+    if (isVertical(p1, p2)) {
+      i1_padded = { x: interactionPoint1.x, y: interactionPoint1.y - padding }
+    } else {
+      // isHorizontal(p1, p2)
+      i1_padded = { x: interactionPoint1.x - padding, y: interactionPoint1.y }
+    }
+    if (isVertical(p2, p3)) {
+      i2_padded = { x: interactionPoint2.x, y: interactionPoint2.y - padding }
+    } else {
+      // isHorizontal(p2, p3)
+      i2_padded = { x: interactionPoint2.x - padding, y: interactionPoint2.y }
+    }
+  } else if (Math.abs(p2.x - x) < EPS && Math.abs(p2.y - y) < EPS) {
+    c2 = { x: x + width + padding, y: y + height + padding }
+
+    if (isVertical(p1, p2)) {
+      i1_padded = { x: interactionPoint1.x, y: interactionPoint1.y + padding }
+    } else {
+      // isHorizontal(p1, p2)
+      i1_padded = { x: interactionPoint1.x + padding, y: interactionPoint1.y }
+    }
+    if (isVertical(p2, p3)) {
+      i2_padded = { x: interactionPoint2.x, y: interactionPoint2.y + padding }
+    } else {
+      // isHorizontal(p2, p3)
+      i2_padded = { x: interactionPoint2.x + padding, y: interactionPoint2.y }
+    }
+  } else if (Math.abs(p2.x - (x + width)) < EPS && Math.abs(p2.y - y) < EPS) {
+    c2 = { x: x - padding, y: y + height + padding }
+
+    if (isVertical(p1, p2)) {
+      i1_padded = { x: interactionPoint1.x, y: interactionPoint1.y + padding }
+    } else {
+      // isHorizontal(p1, p2)
+      i1_padded = { x: interactionPoint1.x - padding, y: interactionPoint1.y }
+    }
+    if (isVertical(p2, p3)) {
+      i2_padded = { x: interactionPoint2.x, y: interactionPoint2.y + padding }
+    } else {
+      // isHorizontal(p2, p3)
+      i2_padded = { x: interactionPoint2.x - padding, y: interactionPoint2.y }
+    }
+  } else {
+    return []
+  }
+
+  return [[i1_padded, c2, i2_padded]]
+}

package/lib/solvers/TraceCleanupSolver/sub-solver/generateRectangleCandidates.ts

@@ -0,0 +1,55 @@
+import type { Point } from "@tscircuit/math-utils"
+
+export interface Rectangle {
+  x: number
+  y: number
+  width: number
+  height: number
+}
+
+export interface RectangleCandidate {
+  rect: Rectangle
+  i1: Point
+  i2: Point
+}
+
+/**
+ * Generates potential rectangular areas from two sets of intersection points.
+ * This function takes two arrays of points, typically representing intersections along two segments of an L-shape.
+ * It pairs up points from each array to form diagonals of potential rectangles.
+ * Only rectangles with a non-zero area are considered valid candidates.
+ */
+export const generateRectangleCandidates = (
+  intersections1: Point[],
+  intersections2: Point[],
+): RectangleCandidate[] => {
+  const rectangleCandidates: RectangleCandidate[] = []
+
+  for (const p1 of intersections1) {
+    for (const p2 of intersections2) {
+      const minX = Math.min(p1.x, p2.x)
+      const minY = Math.min(p1.y, p2.y)
+      const maxX = Math.max(p1.x, p2.x)
+      const maxY = Math.max(p1.y, p2.y)
+
+      const width = maxX - minX
+      const height = maxY - minY
+
+      // Ensure the rectangle has a non-zero area
+      if (width > 1e-6 && height > 1e-6) {
+        rectangleCandidates.push({
+          rect: {
+            x: minX,
+            y: minY,
+            width,
+            height,
+          },
+          i1: p1,
+          i2: p2,
+        })
+      }
+    }
+  }
+
+  return rectangleCandidates
+}

package/lib/solvers/TraceCleanupSolver/sub-solver/getTraceObstacles.ts

@@ -0,0 +1,25 @@
+import type { SolvedTracePath } from "../../SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+
+export interface TraceObstacle {
+  points: Array<{ x: number; y: number }>
+}
+
+/**
+ * Extracts obstacles from a list of solved trace paths, excluding a specific trace.
+ * This function is used to treat other traces as obstacles when rerouting or cleaning up a particular trace.
+ * It returns an array of TraceObstacle objects, where each obstacle is represented by the points of a trace path.
+ */
+export const getTraceObstacles = (
+  allTraces: SolvedTracePath[],
+  excludeTraceId: string,
+): TraceObstacle[] => {
+  const obstacles: TraceObstacle[] = []
+
+  for (const trace of allTraces) {
+    if (trace.mspPairId !== excludeTraceId) {
+      obstacles.push({ points: trace.tracePath })
+    }
+  }
+
+  return obstacles
+}

package/lib/solvers/TraceCleanupSolver/sub-solver/isPathColliding.ts

@@ -0,0 +1,58 @@
+import type { Point } from "@tscircuit/math-utils"
+import type { SolvedTracePath } from "../../SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import { getSegmentIntersection } from "@tscircuit/math-utils/line-intersections"
+
+export type CollisionInfo = {
+  isColliding: boolean
+  collidingTraceId?: string
+  collisionPoint?: Point
+}
+
+/**
+ * Checks if a given path collides with any other traces in a list of solved trace paths.
+ * It iterates through each segment of the input path and compares it against every segment
+ * of all other traces (excluding a specified trace to avoid self-collision checks).
+ * If an intersection is found between any segments, it indicates a collision.
+ */
+export const isPathColliding = (
+  path: Point[],
+  allTraces: SolvedTracePath[],
+  traceIdToExclude?: string,
+): CollisionInfo => {
+  if (path.length < 2) {
+    return { isColliding: false }
+  }
+
+  for (let i = 0; i < path.length - 1; i++) {
+    const pathSegP1 = path[i]
+    const pathSegQ1 = path[i + 1]
+
+    for (const existingTrace of allTraces) {
+      if (existingTrace.mspPairId === traceIdToExclude) {
+        continue // Skip self-collision check
+      }
+
+      for (let j = 0; j < existingTrace.tracePath.length - 1; j++) {
+        const existingSegP2 = existingTrace.tracePath[j]
+        const existingSegQ2 = existingTrace.tracePath[j + 1]
+
+        const intersectionPoint = getSegmentIntersection(
+          pathSegP1,
+          pathSegQ1,
+          existingSegP2,
+          existingSegQ2,
+        )
+
+        if (intersectionPoint) {
+          return {
+            isColliding: true,
+            collidingTraceId: existingTrace.mspPairId as string,
+            collisionPoint: intersectionPoint,
+          }
+        }
+      }
+    }
+  }
+
+  return { isColliding: false } // No collision found
+}