@tscircuit/schematic-trace-solver 0.0.45 → 0.0.46

package/lib/solvers/TraceLabelOverlapAvoidanceSolver/TraceLabelOverlapAvoidanceSolver.ts

@@ -15,8 +15,21 @@ interface TraceLabelOverlapAvoidanceSolverInput {
 }
 
 /**
- * This solver is a pipeline that runs a series of sub-solvers to resolve
- * trace-label overlaps and clean up the resulting traces.
+ * A pipeline solver responsible for resolving overlaps between schematic traces and net labels.
+ *
+ * This solver orchestrates a sequence of sub-solvers to achieve its goal:
+ * 1. **MergedNetLabelObstacleSolver**: This solver first merges labels that are
+ *    close to each other to form larger "obstacle" groups. This simplifies the
+ *    problem by reducing the number of individual obstacles the traces need to avoid.
+ * 2. **OverlapAvoidanceStepSolver**: This solver then takes the output of the merging
+ *    step and iteratively attempts to reroute traces to avoid the merged label obstacles.
+ *    It handles one overlap at a time, making it a step-by-step process.
+ *
+ * The final output is a set of modified traces that have been rerouted to avoid
+ * labels, and the set of merged labels that were used as obstacles.
+ *
+ * @param {TraceLabelOverlapAvoidanceSolverInput} solverInput - The input for the solver,
+ *   containing the initial traces, label placements, and the input problem definition.
  */
 export class TraceLabelOverlapAvoidanceSolver extends BaseSolver {
   inputProblem: InputProblem
@@ -65,7 +78,8 @@ export class TraceLabelOverlapAvoidanceSolver extends BaseSolver {
         this.overlapAvoidanceSolver = new OverlapAvoidanceStepSolver({
           inputProblem: this.inputProblem,
           traces: this.traces,
-          netLabelPlacements:
+          initialNetLabelPlacements: this.netLabelPlacements, // The original, unfiltered list
+          mergedNetLabelPlacements:
             this.labelMergingSolver!.getOutput().netLabelPlacements,
           mergedLabelNetIdMap:
             this.labelMergingSolver!.getOutput().mergedLabelNetIdMap,

package/lib/solvers/TraceLabelOverlapAvoidanceSolver/detectTraceLabelOverlap.ts

@@ -8,28 +8,43 @@ export interface TraceLabelOverlap {
   label: NetLabelPlacement
 }
 
-export const detectTraceLabelOverlap = (
-  traces: SolvedTracePath[],
-  netLabels: NetLabelPlacement[],
-): TraceLabelOverlap[] => {
+/**
+ * Detects overlaps between a set of traces and a set of net labels.
+ * It identifies instances where a trace segment intersects with a label's bounding box.
+ * Self-attachments (where a trace and label belong to the same net) are explicitly ignored
+ * as they are not considered true overlaps for avoidance purposes.
+ *
+ * @param traces - An array of SolvedTracePath objects to check for overlaps.
+ * @param netLabels - An array of NetLabelPlacement objects representing the labels.
+ * @returns An array of TraceLabelOverlap objects, each indicating an overlap
+ *          between a trace and a label.
+ */
+export const detectTraceLabelOverlap = ({
+  traces,
+  netLabels = [],
+}: {
+  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]
+      for (let j = 0; j < trace.tracePath.length - 1; j++) {
+        const p1 = trace.tracePath[j]
+        const p2 = trace.tracePath[j + 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 the trace and label belong to the same net, it's a legitimate connection, not an overlap to avoid.
+          // This check is now redundant with the new logic in OverlapAvoidanceStepSolver,
+          // but kept here for now as per instruction not to remove anything unnecessary.
           if (trace.globalConnNetId === label.globalConnNetId) {
-            break // Move to the next label
+            break // Break from the inner-most loop (segment loop)
           }
           overlaps.push({ trace, label })
-          break // Move to the next label
+          break // Break from the inner-most loop (segment loop)
         }
       }
     }

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

@@ -6,6 +6,9 @@ import type { GraphicsObject, Line } from "graphics-debug"
 import { getColorFromString } from "lib/utils/getColorFromString"
 import { visualizeInputProblem } from "lib/solvers/SchematicTracePipelineSolver/visualizeInputProblem"
 import type { InputProblem } from "lib/types/InputProblem"
+import { groupLabelsByChipAndOrientation } from "./groupLabelsByChipAndOrientation"
+import { mergeLabelGroup } from "./mergeLabelGroup"
+import { filterLabelsAtTraceEdges } from "./filterLabelsAtTraceEdges"
 
 interface LabelMergingSolverInput {
   netLabelPlacements: NetLabelPlacement[]
@@ -18,9 +21,15 @@ interface LabelMergingSolverOutput {
   mergedLabelNetIdMap: Record<string, Set<string>>
 }
 
+type PipelineStep =
+  | "filtering_labels"
+  | "grouping_labels"
+  | "merging_groups"
+  | "finalizing"
+
 /**
  * Merges multiple net labels into a single, larger label if they are on the
- * same side of the same chip, reducing schematic clutter.
+ * same side of the same chip and physically adjacent.
  */
 export class MergedNetLabelObstacleSolver extends BaseSolver {
   private input: LabelMergingSolverInput
@@ -28,15 +37,21 @@ export class MergedNetLabelObstacleSolver extends BaseSolver {
   private inputProblem: InputProblem
   private traces: SolvedTracePath[]
 
-  constructor(solverInput: LabelMergingSolverInput) {
-    // console.log(JSON.stringify(solverInput));
+  // State for the new pipeline
+  private pipelineStep: PipelineStep = "filtering_labels"
+  private filteredLabels: NetLabelPlacement[] = []
+  private labelGroups: Record<string, NetLabelPlacement[]> = {}
+  private groupKeysToProcess: string[] = []
+  private finalPlacements: NetLabelPlacement[] = []
+  private mergedLabelNetIdMap: Record<string, Set<string>> = {}
+  private activeMergingGroupKey: string | null = null
 
+  constructor(solverInput: LabelMergingSolverInput) {
     super()
     this.input = solverInput
     this.inputProblem = solverInput.inputProblem
     this.traces = solverInput.traces
 
-    // Initialize output to a default state to allow visualization before the first step
     this.output = {
       netLabelPlacements: solverInput.netLabelPlacements,
       mergedLabelNetIdMap: {},
@@ -44,75 +59,67 @@ export class MergedNetLabelObstacleSolver extends BaseSolver {
   }
 
   override _step() {
-    const originalLabels = this.input.netLabelPlacements
-    const mergedLabelNetIdMap: Record<string, Set<string>> = {}
-
-    if (!originalLabels || originalLabels.length === 0) {
-      this.output = {
-        netLabelPlacements: [],
-        mergedLabelNetIdMap: {},
-      }
-      this.solved = true
-      return
-    }
-
-    const labelGroups: Record<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 (!(key in labelGroups)) {
-        labelGroups[key] = []
-      }
-      labelGroups[key]!.push(p)
-    }
-
-    const finalPlacements: NetLabelPlacement[] = []
-    for (const [key, group] of Object.entries(labelGroups)) {
-      if (group.length <= 1) {
-        finalPlacements.push(...group)
-        continue
-      }
-
-      let minX = Infinity
-      let minY = Infinity
-      let maxX = -Infinity
-      let 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)
-      }
+    switch (this.pipelineStep) {
+      case "filtering_labels":
+        this.filteredLabels = filterLabelsAtTraceEdges({
+          labels: this.input.netLabelPlacements,
+          traces: this.traces,
+        })
+        this.pipelineStep = "grouping_labels"
+        break
 
-      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))
-      mergedLabelNetIdMap[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)),
-        ],
-      })
-    }
+      case "grouping_labels":
+        this.labelGroups = groupLabelsByChipAndOrientation({
+          labels: this.filteredLabels,
+          chips: this.inputProblem.chips,
+        })
+        this.groupKeysToProcess = Object.keys(this.labelGroups)
+        this.pipelineStep = "merging_groups"
+        break
+
+      case "merging_groups":
+        if (this.groupKeysToProcess.length === 0) {
+          this.pipelineStep = "finalizing"
+          this.activeMergingGroupKey = null
+          break
+        }
 
-    this.output = {
-      netLabelPlacements: finalPlacements,
-      mergedLabelNetIdMap,
+        const groupKey = this.groupKeysToProcess.pop()!
+        this.activeMergingGroupKey = groupKey
+        const group = this.labelGroups[groupKey]!
+
+        if (group.length > 1) {
+          const { mergedLabel, originalNetIds } = mergeLabelGroup(
+            group,
+            groupKey,
+          )
+          this.finalPlacements.push(mergedLabel)
+          this.mergedLabelNetIdMap[mergedLabel.globalConnNetId] = originalNetIds
+        } else {
+          this.finalPlacements.push(...group)
+        }
+        break
+
+      case "finalizing":
+        // Any labels that were filtered out and not part of any group should be added back
+        const processedOriginalIds = new Set(
+          this.finalPlacements.flatMap((p) =>
+            this.mergedLabelNetIdMap[p.globalConnNetId]
+              ? [...this.mergedLabelNetIdMap[p.globalConnNetId]!]
+              : [p.globalConnNetId],
+          ),
+        )
+        const unprocessedLabels = this.input.netLabelPlacements.filter(
+          (l) => !processedOriginalIds.has(l.globalConnNetId),
+        )
+
+        this.output = {
+          netLabelPlacements: [...this.finalPlacements, ...unprocessedLabels],
+          mergedLabelNetIdMap: this.mergedLabelNetIdMap,
+        }
+        this.solved = true
+        break
     }
-    this.solved = true
   }
 
   getOutput(): LabelMergingSolverOutput {
@@ -143,17 +150,33 @@ export class MergedNetLabelObstacleSolver extends BaseSolver {
       graphics.lines!.push(line)
     }
 
+    // Highlight the active sub-group being merged
+    if (
+      this.activeMergingGroupKey &&
+      this.labelGroups[this.activeMergingGroupKey]
+    ) {
+      const activeGroup = this.labelGroups[this.activeMergingGroupKey]!
+      for (const label of activeGroup) {
+        graphics.rects.push({
+          center: label.center,
+          width: label.width,
+          height: label.height,
+          fill: "rgba(255, 165, 0, 0.5)", // Orange highlight
+          stroke: "orange",
+        })
+      }
+    }
+
     for (const finalLabel of this.output.netLabelPlacements) {
       const isMerged = finalLabel.globalConnNetId.startsWith("merged-group-")
       const color = getColorFromString(finalLabel.globalConnNetId)
 
       if (isMerged) {
-        // Draw the new merged label
         graphics.rects.push({
           center: finalLabel.center,
           width: finalLabel.width,
           height: finalLabel.height,
-          fill: color.replace(/, 1\)/, ", 0.2)"), // semi-transparent
+          fill: color.replace(/, 1\)/, ", 0.2)"),
           stroke: color,
           label: finalLabel.globalConnNetId,
         })
@@ -164,7 +187,6 @@ export class MergedNetLabelObstacleSolver extends BaseSolver {
           for (const originalNetId of originalNetIds) {
             const originalLabel = originalLabelsById.get(originalNetId)
             if (originalLabel) {
-              // Draw the original label as a dashed box
               const bounds = getRectBounds(
                 originalLabel.center,
                 originalLabel.width,
@@ -179,7 +201,6 @@ export class MergedNetLabelObstacleSolver extends BaseSolver {
                 strokeColor: color,
                 strokeDash: "4 4",
               })
-              // Draw line from original to new center
               graphics.lines.push({
                 points: [originalLabel.center, finalLabel.center],
                 strokeColor: color,
@@ -189,7 +210,6 @@ export class MergedNetLabelObstacleSolver extends BaseSolver {
           }
         }
       } else {
-        // Draw un-merged labels
         graphics.rects.push({
           center: finalLabel.center,
           width: finalLabel.width,

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

@@ -0,0 +1,74 @@
+import type { NetLabelPlacement } from "../../../NetLabelPlacementSolver/NetLabelPlacementSolver"
+import type { SolvedTracePath } from "../../../SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import type { Point } from "graphics-debug"
+import { distance } from "@tscircuit/math-utils"
+
+/**
+ * Filters a list of labels, returning only those that are physically located
+ * near the start or end point of any trace.
+ *
+ * This is hack so we do not need to know the position of ports
+ * and using only the trace geometry. we find out which labels are
+ * at/near port of chips and only keep those for merging.
+ */
+export const filterLabelsAtTraceEdges = ({
+  labels,
+  traces,
+  distanceThreshold = 0.5, // Example threshold
+}: {
+  labels: NetLabelPlacement[]
+  traces: SolvedTracePath[]
+  distanceThreshold?: number
+}): NetLabelPlacement[] => {
+  // 1. Group traces by their net ID for efficient lookup
+  const tracesByNetId = new Map<string, SolvedTracePath[]>()
+  if (!traces) {
+    throw new Error("No traces provided to filterLabelsAtTraceEdges")
+  }
+  for (const trace of traces) {
+    if (!trace.globalConnNetId) continue
+    if (!tracesByNetId.has(trace.globalConnNetId)) {
+      tracesByNetId.set(trace.globalConnNetId, [])
+    }
+    tracesByNetId.get(trace.globalConnNetId)!.push(trace)
+  }
+
+  const filteredLabels: NetLabelPlacement[] = []
+
+  // 2. Iterate through labels and check proximity against only relevant traces
+  for (const label of labels) {
+    // Check if it's a port-only label (no associated MSP connection pairs)
+    if (label.mspConnectionPairIds.length === 0) {
+      filteredLabels.push(label)
+      continue // Skip trace-edge checks for port-only labels
+    }
+
+    const relevantTraces = tracesByNetId.get(label.globalConnNetId)
+    let isNearTraceEdge = false
+
+    if (!relevantTraces || relevantTraces.length === 0) {
+      continue
+    }
+
+    for (const trace of relevantTraces) {
+      if (trace.tracePath.length === 0) continue
+
+      const startPoint = trace.tracePath[0]
+      const endPoint = trace.tracePath[trace.tracePath.length - 1]
+
+      const startDist = distance(label.center, startPoint)
+      const endDist = distance(label.center, endPoint)
+
+      if (startDist <= distanceThreshold || endDist <= distanceThreshold) {
+        isNearTraceEdge = true
+        break // Found a nearby edge, no need to check other traces for this label
+      }
+    }
+
+    if (isNearTraceEdge) {
+      filteredLabels.push(label)
+    }
+  }
+
+  return filteredLabels
+}

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

@@ -0,0 +1,45 @@
+import type { NetLabelPlacement } from "../../../NetLabelPlacementSolver/NetLabelPlacementSolver"
+import type { InputProblem } from "lib/types/InputProblem"
+
+/**
+ * Groups NetLabelPlacement objects by their associated chip ID and orientation.
+ * Labels are grouped if they belong to the same chip and are positioned
+ * with the same orientation relative to that chip.
+ *
+ * @param labels An array of NetLabelPlacement objects to be grouped.
+ * @param chips An array of Chip objects from the InputProblem. (Currently not directly used for grouping logic, but part of the signature).
+ * @returns A record where keys are in the format "chipId-orientation" (e.g., "U1-left")
+ *          and values are arrays of NetLabelPlacement objects belonging to that group.
+ */
+export const groupLabelsByChipAndOrientation = ({
+  labels,
+  chips,
+}: {
+  labels: NetLabelPlacement[]
+  chips: InputProblem["chips"]
+}): Record<string, NetLabelPlacement[]> => {
+  const groupedLabels: Record<string, NetLabelPlacement[]> = {}
+
+  for (const label of labels) {
+    if (label.pinIds.length === 0) {
+      // Labels without pinIds cannot be associated with a chip and orientation for merging
+      continue
+    }
+
+    // Extract chipId from the first pinId (e.g., "U1.1" -> "U1")
+    const chipId = label.pinIds[0].split(".")[0]
+    if (!chipId) {
+      // Should not happen if pinIds are well-formed, but good to guard
+      continue
+    }
+
+    const key = `${chipId}-${label.orientation}`
+
+    if (!groupedLabels[key]) {
+      groupedLabels[key] = []
+    }
+    groupedLabels[key].push(label)
+  }
+
+  return groupedLabels
+}

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,
+  }
+}