@tscircuit/schematic-trace-solver 0.0.45 → 0.0.47

package/lib/solvers/TraceLabelOverlapAvoidanceSolver/sub-solvers/LabelMergingSolver/mergeLabelGroup.ts

@@ -0,0 +1,71 @@
+import type { NetLabelPlacement } from "../../../NetLabelPlacementSolver/NetLabelPlacementSolver"
+import { getRectBounds } from "../../../NetLabelPlacementSolver/SingleNetLabelPlacementSolver/geometry"
+import type { Point } from "graphics-debug" // Assuming Point is from graphics-debug or similar
+
+/**
+ * Merges a group of NetLabelPlacement objects into a single, larger NetLabelPlacement.
+ * It calculates a new bounding box that encompasses all labels in the group,
+ * aggregates unique pin and MSP connection pair IDs, and creates a synthetic
+ * merged label.
+ *
+ * @param group An array of NetLabelPlacement objects to be merged. Assumes the group is not empty.
+ * @param groupKey A string key representing the group (e.g., "chip1-left"), used for generating the merged label's globalConnNetId.
+ * @returns An object containing the newly created merged NetLabelPlacement and a Set of the original globalConnNetIds that were merged.
+ * @throws Error if the input group is empty.
+ */
+export const mergeLabelGroup = (
+  group: NetLabelPlacement[],
+  groupKey: string,
+): {
+  mergedLabel: NetLabelPlacement
+  originalNetIds: Set<string>
+} => {
+  if (group.length === 0) {
+    throw new Error("Cannot merge an empty group of labels.")
+  }
+
+  let minX = Infinity
+  let minY = Infinity
+  let maxX = -Infinity
+  let maxY = -Infinity
+
+  const allPinIds = new Set<string>()
+  const allMspConnectionPairIds = new Set<string>()
+  const originalNetIds = new Set<string>()
+
+  for (const label of group) {
+    const bounds = getRectBounds(label.center, label.width, label.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)
+
+    label.pinIds.forEach((id) => allPinIds.add(id))
+    label.mspConnectionPairIds.forEach((id) => allMspConnectionPairIds.add(id))
+    originalNetIds.add(label.globalConnNetId)
+  }
+
+  const newWidth = maxX - minX
+  const newHeight = maxY - minY
+  const newCenter: Point = { x: minX + newWidth / 2, y: minY + newHeight / 2 }
+
+  // Use the first label as a template for properties that are consistent across the group
+  // like orientation.
+  const template = group[0]!
+  const syntheticId = `merged-group-${groupKey}`
+
+  const mergedLabel: NetLabelPlacement = {
+    ...template, // Copy common properties
+    globalConnNetId: syntheticId,
+    center: newCenter,
+    width: newWidth,
+    height: newHeight,
+    pinIds: Array.from(allPinIds),
+    mspConnectionPairIds: Array.from(allMspConnectionPairIds),
+  }
+
+  return {
+    mergedLabel,
+    originalNetIds,
+  }
+}

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

@@ -6,15 +6,19 @@ import { visualizeInputProblem } from "lib/solvers/SchematicTracePipelineSolver/
 import type { InputProblem } from "lib/types/InputProblem"
 import { detectTraceLabelOverlap } from "../../detectTraceLabelOverlap"
 import { SingleOverlapSolver } from "../SingleOverlapSolver/SingleOverlapSolver"
+import { doesTraceStartOrEndInLabel } from "./doesTraceStartOrEndInLabel"
+import { visualizeDecomposition } from "./visualizeDecomposition"
 
 type Overlap = ReturnType<typeof detectTraceLabelOverlap>[0]
 
 // Define a type for the input of the internal overlap solver to avoid conflicts
-interface OverlapCollectionSolverInput {
+export interface OverlapCollectionSolverInput {
   inputProblem: InputProblem
   traces: SolvedTracePath[]
-  netLabelPlacements: NetLabelPlacement[]
+  initialNetLabelPlacements: NetLabelPlacement[]
+  mergedNetLabelPlacements: NetLabelPlacement[]
   mergedLabelNetIdMap: Record<string, Set<string>>
+  detourCounts: Map<string, number>
 }
 
 /**
@@ -23,28 +27,36 @@ interface OverlapCollectionSolverInput {
  */
 export class OverlapAvoidanceStepSolver extends BaseSolver {
   inputProblem: InputProblem
-  netLabelPlacements: NetLabelPlacement[]
+  initialNetLabelPlacements: NetLabelPlacement[]
+  mergedNetLabelPlacements: NetLabelPlacement[]
   mergedLabelNetIdMap: Record<string, Set<string>>
 
   allTraces: SolvedTracePath[]
   modifiedTraces: SolvedTracePath[] = []
 
-  private detourCountByLabel: Record<string, number> = {}
   private readonly PADDING_BUFFER = 0.1
+  private detourCounts: Map<string, number> = new Map()
 
   public override activeSubSolver: SingleOverlapSolver | null = null
   private overlapQueue: Overlap[] = []
   private recentlyFailed: Set<string> = new Set()
 
+  private currentlyProcessingOverlap: Overlap | null = null
+  private decomposedChildLabels: NetLabelPlacement[] | null = null
+
   constructor(solverInput: OverlapCollectionSolverInput) {
     super()
     this.inputProblem = solverInput.inputProblem
-    this.netLabelPlacements = solverInput.netLabelPlacements
+    this.initialNetLabelPlacements = solverInput.initialNetLabelPlacements
+    this.mergedNetLabelPlacements = solverInput.mergedNetLabelPlacements
     this.mergedLabelNetIdMap = solverInput.mergedLabelNetIdMap
     this.allTraces = [...solverInput.traces]
+    this.detourCounts = solverInput.detourCounts
   }
 
   override _step() {
+    this.currentlyProcessingOverlap = null
+    this.decomposedChildLabels = null
     if (this.activeSubSolver) {
       this.activeSubSolver.step()
 
@@ -65,19 +77,14 @@ export class OverlapAvoidanceStepSolver extends BaseSolver {
         const overlapId = `${this.activeSubSolver.initialTrace.mspPairId}-${this.activeSubSolver.label.globalConnNetId}`
         this.recentlyFailed.add(overlapId)
         this.activeSubSolver = null
+      } else {
       }
       return
     }
 
-    const overlaps = detectTraceLabelOverlap(
-      this.allTraces,
-      this.netLabelPlacements,
-    ).filter((o) => {
-      const originalNetIds = this.mergedLabelNetIdMap[o.label.globalConnNetId]
-      if (originalNetIds) {
-        return !originalNetIds.has(o.trace.globalConnNetId)
-      }
-      return o.trace.globalConnNetId !== o.label.globalConnNetId
+    const overlaps = detectTraceLabelOverlap({
+      traces: this.allTraces,
+      netLabels: this.mergedNetLabelPlacements,
     })
 
     if (overlaps.length === 0) {
@@ -85,6 +92,7 @@ export class OverlapAvoidanceStepSolver extends BaseSolver {
       return
     }
 
+    // Filter out overlaps that have recently failed to avoid infinite loops
     const nonFailedOverlaps = overlaps.filter((o) => {
       const overlapId = `${o.trace.mspPairId}-${o.label.globalConnNetId}`
       return !this.recentlyFailed.has(overlapId)
@@ -98,24 +106,112 @@ export class OverlapAvoidanceStepSolver extends BaseSolver {
     this.overlapQueue = nonFailedOverlaps
 
     const nextOverlap = this.overlapQueue.shift()
+    this.currentlyProcessingOverlap = nextOverlap ?? null
 
     if (nextOverlap) {
       const traceToFix = this.allTraces.find(
         (t) => t.mspPairId === nextOverlap.trace.mspPairId,
-      )
-      if (traceToFix) {
-        const labelId = nextOverlap.label.globalConnNetId
-        const detourCount = this.detourCountByLabel[labelId] || 0
-        this.detourCountByLabel[labelId] = detourCount + 1
-
-        this.activeSubSolver = new SingleOverlapSolver({
-          trace: traceToFix,
-          label: nextOverlap.label,
-          problem: this.inputProblem,
-          paddingBuffer: this.PADDING_BUFFER,
-          detourCount,
-        })
+      )!
+      const labelToAvoid = nextOverlap.label
+
+      const originalNetIds =
+        this.mergedLabelNetIdMap[labelToAvoid.globalConnNetId]
+      const isSelfOverlap = originalNetIds?.has(traceToFix.globalConnNetId)
+
+      if (isSelfOverlap) {
+        const childLabels = this.initialNetLabelPlacements.filter((l) =>
+          originalNetIds.has(l.globalConnNetId),
+        )
+        this.decomposedChildLabels = childLabels
+        let actualOverlapLabel: NetLabelPlacement | null = null
+
+        for (const childLabel of childLabels) {
+          const overlapsWithChild = detectTraceLabelOverlap({
+            traces: [traceToFix],
+            netLabels: [childLabel],
+          })
+          if (overlapsWithChild.length > 0) {
+            actualOverlapLabel = childLabel
+            break
+          }
+        }
+
+        if (actualOverlapLabel) {
+          const detourCount =
+            this.detourCounts.get(actualOverlapLabel.globalConnNetId) ?? 0
+          this.detourCounts.set(
+            actualOverlapLabel.globalConnNetId,
+            detourCount + 1,
+          )
+
+          this.activeSubSolver = new SingleOverlapSolver({
+            trace: traceToFix,
+            label: actualOverlapLabel,
+            problem: this.inputProblem,
+            paddingBuffer: this.PADDING_BUFFER,
+            detourCount: detourCount,
+          })
+        } else {
+          const overlapId = `${traceToFix.mspPairId}-${labelToAvoid.globalConnNetId}`
+          this.recentlyFailed.add(overlapId)
+        }
+        return
       }
+
+      if (
+        originalNetIds &&
+        doesTraceStartOrEndInLabel({ trace: traceToFix, label: labelToAvoid })
+      ) {
+        const childLabels = this.initialNetLabelPlacements.filter((l) =>
+          originalNetIds.has(l.globalConnNetId),
+        )
+        this.decomposedChildLabels = childLabels
+        let actualOverlapLabel: NetLabelPlacement | null = null
+
+        for (const childLabel of childLabels) {
+          const overlapsWithChild = detectTraceLabelOverlap({
+            traces: [traceToFix],
+            netLabels: [childLabel],
+          })
+          if (overlapsWithChild.length > 0) {
+            actualOverlapLabel = childLabel
+            break
+          }
+        }
+
+        if (actualOverlapLabel) {
+          const detourCount =
+            this.detourCounts.get(actualOverlapLabel.globalConnNetId) ?? 0
+          this.detourCounts.set(
+            actualOverlapLabel.globalConnNetId,
+            detourCount + 1,
+          )
+          this.activeSubSolver = new SingleOverlapSolver({
+            trace: traceToFix,
+            label: actualOverlapLabel,
+            problem: this.inputProblem,
+            paddingBuffer: this.PADDING_BUFFER,
+            detourCount: detourCount,
+          })
+        } else {
+          const overlapId = `${traceToFix.mspPairId}-${labelToAvoid.globalConnNetId}`
+          this.recentlyFailed.add(overlapId)
+        }
+        return
+      }
+
+      // STRATEGY 3: Real collision between different nets.
+      // We must reroute around the entire merged label.
+      const detourCount =
+        this.detourCounts.get(labelToAvoid.globalConnNetId) ?? 0
+      this.detourCounts.set(labelToAvoid.globalConnNetId, detourCount + 1)
+      this.activeSubSolver = new SingleOverlapSolver({
+        trace: traceToFix,
+        label: labelToAvoid,
+        problem: this.inputProblem,
+        paddingBuffer: this.PADDING_BUFFER,
+        detourCount: detourCount,
+      })
     }
   }
 
@@ -123,6 +219,7 @@ export class OverlapAvoidanceStepSolver extends BaseSolver {
     return {
       allTraces: this.allTraces,
       modifiedTraces: this.modifiedTraces,
+      detourCounts: this.detourCounts,
     }
   }
 
@@ -130,7 +227,7 @@ export class OverlapAvoidanceStepSolver extends BaseSolver {
     if (this.activeSubSolver) {
       return this.activeSubSolver.visualize()
     }
-    // When idle, show all the traces
+
     const graphics = visualizeInputProblem(this.inputProblem)
     if (!graphics.lines) graphics.lines = []
     for (const trace of this.allTraces) {
@@ -139,6 +236,43 @@ export class OverlapAvoidanceStepSolver extends BaseSolver {
         strokeColor: "purple",
       })
     }
+
+    if (this.currentlyProcessingOverlap) {
+      const { trace, label } = this.currentlyProcessingOverlap
+
+      // Highlight the colliding trace
+      graphics.lines!.push({
+        points: trace.tracePath,
+        strokeColor: "red",
+      })
+
+      if (this.decomposedChildLabels) {
+        visualizeDecomposition({
+          decomposedChildLabels: this.decomposedChildLabels,
+          collidingTrace: trace,
+          mergedLabel: label,
+          graphics,
+        })
+      } else {
+        // Standard case: highlight the entire label
+        if (!graphics.rects) graphics.rects = []
+        graphics.rects.push({
+          center: label.center,
+          width: label.width,
+          height: label.height,
+          fill: "yellow",
+        })
+        if (!graphics.texts) graphics.texts = []
+        graphics.texts.push({
+          x: label.center.x,
+          y: label.center.y + label.height / 2 + 0.5,
+          text: `COLLISION: Trace ${trace.mspPairId} vs Label ${label.globalConnNetId}`,
+          fontSize: 0.3,
+          color: "red",
+        })
+      }
+    }
+
     return graphics
   }
 }

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

@@ -0,0 +1,58 @@
+import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import { detectTraceLabelOverlap } from "../../detectTraceLabelOverlap"
+
+interface Props {
+  trace: SolvedTracePath
+  label: NetLabelPlacement
+}
+
+/**
+ * Checks if the first or last segment of a given trace overlaps with a specified net label.
+ * This is useful for determining if a trace begins or ends within an obstacle.
+ */
+export const doesTraceStartOrEndInLabel = ({ trace, label }: Props) => {
+  if (trace.tracePath.length < 2) {
+    return false // Not a valid trace with segments
+  }
+
+  // Create a mini-trace for the first segment
+  const firstSegmentTrace: SolvedTracePath = {
+    ...trace,
+    tracePath: [trace.tracePath[0], trace.tracePath[1]],
+  }
+
+  // Check for overlap with the first segment
+  const firstSegmentOverlap = detectTraceLabelOverlap({
+    traces: [firstSegmentTrace],
+    netLabels: [label],
+  })
+
+  if (firstSegmentOverlap.length > 0) {
+    return true
+  }
+
+  // If the trace has more than one segment, check the last one
+  if (trace.tracePath.length > 2) {
+    const lastPoint = trace.tracePath[trace.tracePath.length - 1]
+    const secondToLastPoint = trace.tracePath[trace.tracePath.length - 2]
+
+    // Create a mini-trace for the last segment
+    const lastSegmentTrace: SolvedTracePath = {
+      ...trace,
+      tracePath: [secondToLastPoint, lastPoint],
+    }
+
+    // Check for overlap with the last segment
+    const lastSegmentOverlap = detectTraceLabelOverlap({
+      traces: [lastSegmentTrace],
+      netLabels: [label],
+    })
+
+    if (lastSegmentOverlap.length > 0) {
+      return true
+    }
+  }
+
+  return false
+}

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

@@ -0,0 +1,23 @@
+import type { Point } from "graphics-debug"
+import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
+import { getRectBounds } from "lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/geometry"
+
+/**
+ * Checks if a point is inside the bounding box of a net label.
+ */
+export const isPointInsideLabel = ({
+  point,
+  label,
+}: {
+  point: Point
+  label: NetLabelPlacement
+}): boolean => {
+  const bounds = getRectBounds(label.center, label.width, label.height)
+
+  return (
+    point.x >= bounds.minX &&
+    point.x <= bounds.maxX &&
+    point.y >= bounds.minY &&
+    point.y <= bounds.maxY
+  )
+}

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

@@ -0,0 +1,54 @@
+import type { GraphicsObject } from "graphics-debug"
+import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+
+interface VisualizeDecompositionParams {
+  decomposedChildLabels: NetLabelPlacement[]
+  collidingTrace: SolvedTracePath
+  mergedLabel: NetLabelPlacement
+  graphics: GraphicsObject
+}
+
+/**
+ * Visualizes the decomposition of a merged label during overlap avoidance.
+ * It draws individual child labels with distinct colors based on their relation
+ * to the colliding trace and adds a textual report to the graphics.
+ *
+ * @param {VisualizeDecompositionParams} params - The parameters for visualization.
+ * @param {NetLabelPlacement[]} params.decomposedChildLabels - The individual labels that make up the merged group.
+ * @param {SolvedTracePath} params.collidingTrace - The trace that is currently colliding with the merged label.
+ * @param {NetLabelPlacement} params.mergedLabel - The original merged label that is being decomposed.
+ * @param {GraphicsObject} params.graphics - The graphics object to which the visualization elements will be added.
+ * @returns {GraphicsObject} The modified graphics object with decomposition visualization elements.
+ */
+export const visualizeDecomposition = (
+  params: VisualizeDecompositionParams,
+): GraphicsObject => {
+  const { decomposedChildLabels, collidingTrace, mergedLabel, graphics } =
+    params
+
+  if (!graphics.rects) graphics.rects = []
+  if (!graphics.texts) graphics.texts = []
+
+  for (const childLabel of decomposedChildLabels) {
+    const isOwnLabel =
+      childLabel.globalConnNetId === collidingTrace.globalConnNetId
+
+    graphics.rects.push({
+      center: childLabel.center,
+      width: childLabel.width,
+      height: childLabel.height,
+      fill: isOwnLabel ? "green" : "red", // Green for own label, red for others
+    })
+  }
+
+  graphics.texts.push({
+    x: mergedLabel.center.x,
+    y: mergedLabel.center.y + mergedLabel.height / 2 + 0.5,
+    text: `DECOMPOSITION: Trace ${collidingTrace.mspPairId} vs Merged Label ${mergedLabel.globalConnNetId}`,
+    fontSize: 0.3,
+    color: "blue",
+  })
+
+  return graphics
+}

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

@@ -18,6 +18,8 @@ interface SingleOverlapSolverInput {
   detourCount: number
 }
 
+const MAX_TRIES = 5
+
 /**
  * This solver attempts to find a valid rerouting for a single trace that is
  * overlapping with a net label. It tries various candidate paths until it
@@ -30,6 +32,7 @@ export class SingleOverlapSolver extends BaseSolver {
   problem: InputProblem
   obstacles: ReturnType<typeof getObstacleRects>
   label: NetLabelPlacement
+  _tried: number = 0
 
   constructor(solverInput: SingleOverlapSolverInput) {
     super()
@@ -37,8 +40,14 @@ export class SingleOverlapSolver extends BaseSolver {
     this.problem = solverInput.problem
     this.label = solverInput.label
 
+    // Calculate an effective padding for this specific run based on the detourCount.
+    const effectivePadding =
+      solverInput.paddingBuffer +
+      solverInput.detourCount * solverInput.paddingBuffer
+
     const candidates = generateRerouteCandidates({
       ...solverInput,
+      paddingBuffer: effectivePadding, // Use the calculated, larger padding
     })
 
     const getPathLength = (pts: Point[]) => {
@@ -58,11 +67,13 @@ export class SingleOverlapSolver extends BaseSolver {
   }
 
   override _step() {
-    if (this.queuedCandidatePaths.length === 0) {
+    // Failure conditions: no more candidates or exceeded max tries
+    if (this.queuedCandidatePaths.length === 0 || this._tried >= MAX_TRIES) {
       this.failed = true
       return
     }
 
+    this._tried++
     const nextCandidatePath = this.queuedCandidatePaths.shift()!
     const simplifiedPath = simplifyPath(nextCandidatePath)
 
@@ -70,6 +81,7 @@ export class SingleOverlapSolver extends BaseSolver {
       this.solvedTracePath = simplifiedPath
       this.solved = true
     }
+    // If the path collides, we simply do nothing and let the next step try another candidate.
   }
 
   override visualize(): GraphicsObject {