@tscircuit/schematic-trace-solver 0.0.44 → 0.0.46

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

@@ -0,0 +1,33 @@
+import type { GraphicsObject } from "graphics-debug"
+import type { Point } from "@tscircuit/math-utils"
+
+/**
+ * Visualizes a set of candidate paths and optional intersection points.
+ * It draws each candidate path as a line with a specified color and marks intersection points with green circles.
+ * This function is useful for debugging and understanding the rerouting process.
+ */
+export const visualizeCandidates = (
+  candidates: Point[][],
+  color = "gray",
+  intersectionPoints: Point[] = [],
+): GraphicsObject => {
+  const graphics: GraphicsObject = { lines: [], circles: [] }
+
+  for (const candidate of candidates) {
+    graphics.lines!.push({
+      points: candidate,
+      strokeColor: color,
+    })
+  }
+
+  // Draw intersection points
+  for (const point of intersectionPoints) {
+    graphics.circles!.push({
+      center: point,
+      radius: 0.01, // Larger radius for intersection points
+      fill: "green",
+    })
+  }
+
+  return graphics
+}

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

@@ -0,0 +1,20 @@
+import type { GraphicsObject } from "graphics-debug"
+import type { CollisionInfo } from "./isPathColliding"
+
+/**
+ * Visualizes a collision point if collision information is provided and a collision occurred.
+ * It draws a red circle at the collision point to highlight the location of the collision.
+ */
+export const visualizeCollision = (
+  collisionInfo: CollisionInfo | null,
+): GraphicsObject => {
+  const collisionGraphics: GraphicsObject = { circles: [] }
+  if (collisionInfo?.isColliding && collisionInfo.collisionPoint) {
+    collisionGraphics.circles!.push({
+      center: collisionInfo.collisionPoint,
+      radius: 0.01,
+      fill: "red",
+    })
+  }
+  return collisionGraphics
+}

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

@@ -0,0 +1,26 @@
+import type { Point } from "@tscircuit/math-utils"
+import type { GraphicsObject } from "graphics-debug"
+
+/**
+ * Visualizes a set of intersection points by drawing circles at their locations.
+ * This function is used to highlight where different trace segments or obstacles intersect.
+ */
+export const visualizeIntersectionPoints = (
+  points: Point[],
+  color = "red",
+): GraphicsObject => {
+  const graphics: GraphicsObject = { circles: [] }
+
+  for (const point of points) {
+    graphics.circles!.push({
+      center: {
+        x: point.x,
+        y: point.y,
+      },
+      radius: 0.01,
+      fill: color,
+    })
+  }
+
+  return graphics
+}

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

@@ -0,0 +1,33 @@
+import type { LShape } from "./findAllLShapedTurns"
+import type { GraphicsObject } from "graphics-debug"
+
+/**
+ * Visualizes L-shaped turns by drawing a blue circle at the corner point (p2)
+ * and light blue lines connecting p1, p2, and p3.
+ * This function can visualize a single L-shape or an array of L-shapes.
+ */
+export const visualizeLSapes = (lShapes: LShape[] | LShape): GraphicsObject => {
+  const graphics: GraphicsObject = { circles: [], lines: [] }
+
+  const lShapesArray = Array.isArray(lShapes) ? lShapes : [lShapes]
+
+  for (const lShape of lShapesArray) {
+    // Draw the center point as a blue ball
+    graphics.circles!.push({
+      center: {
+        x: lShape.p2.x,
+        y: lShape.p2.y,
+      },
+      radius: 0.01,
+      fill: "blue",
+    })
+
+    // Draw the two lines in a light blue color
+    graphics.lines!.push({
+      points: [lShape.p1, lShape.p2, lShape.p3],
+      strokeColor: "lightblue",
+    })
+  }
+
+  return graphics
+}

package/lib/solvers/TraceCleanupSolver/turnMinimization.ts

@@ -4,75 +4,32 @@ import { countTurns } from "./countTurns"
 import { simplifyPath } from "./simplifyPath"
 import { tryConnectPoints } from "./tryConnectPoints"
 import { hasCollisionsWithLabels } from "./hasCollisionsWithLabels"
-
+import { recognizeStairStepPattern } from "./recognizeStairStepPattern"
+import { isSegmentAnEndpointSegment } from "./isSegmentAnEndpointSegment"
+
+/**
+ * Minimizes the number of turns in a given path while avoiding collisions with obstacles and labels.
+ * This function employs an iterative approach, attempting to simplify the path in several ways:
+ * 1. **Stair-step pattern recognition**: It first looks for and attempts to simplify stair-step patterns by connecting the start and end points of the pattern with a simpler path, if no collisions are introduced.
+ * 2. **Point removal and reconnection**: If no stair-step optimization is possible, it tries to remove intermediate points and reconnect the remaining segments with a simpler path, prioritizing solutions that reduce turns or path length.
+ * 3. **Collinear segment merging**: Finally, it attempts to merge collinear segments to further simplify the path.
+ * The process continues until no further improvements can be made without introducing collisions.
+ */
 export const minimizeTurns = ({
   path,
   obstacles,
   labelBounds,
+  originalPath,
 }: {
   path: Point[]
   obstacles: any[]
   labelBounds: any[]
+  originalPath: Point[]
 }): Point[] => {
   if (path.length <= 2) {
     return path
   }
 
-  const recognizeStairStepPattern = (
-    pathToCheck: Point[],
-    startIdx: number,
-  ): number => {
-    if (startIdx >= pathToCheck.length - 3) return -1
-
-    let endIdx = startIdx
-    let isStairStep = true
-
-    for (
-      let i = startIdx;
-      i < pathToCheck.length - 2 && i < startIdx + 10;
-      i++
-    ) {
-      if (i + 2 >= pathToCheck.length) break
-
-      const p1 = pathToCheck[i]
-      const p2 = pathToCheck[i + 1]
-      const p3 = pathToCheck[i + 2]
-
-      const seg1Vertical = p1.x === p2.x
-      const seg2Vertical = p2.x === p3.x
-
-      if (seg1Vertical === seg2Vertical) {
-        break
-      }
-
-      const seg1Direction = seg1Vertical
-        ? Math.sign(p2.y - p1.y)
-        : Math.sign(p2.x - p1.x)
-
-      if (i > startIdx) {
-        const prevP = pathToCheck[i - 1]
-        const prevSegVertical = prevP.x === p1.x
-        const prevDirection = prevSegVertical
-          ? Math.sign(p1.y - prevP.y)
-          : Math.sign(p1.x - prevP.x)
-
-        if (
-          (seg1Vertical &&
-            prevSegVertical &&
-            seg1Direction !== prevDirection) ||
-          (!seg1Vertical && !prevSegVertical && seg1Direction !== prevDirection)
-        ) {
-          isStairStep = false
-          break
-        }
-      }
-
-      endIdx = i + 2
-    }
-
-    return isStairStep && endIdx - startIdx >= 3 ? endIdx : -1
-  }
-
   let optimizedPath = [...path]
   let currentTurns = countTurns(optimizedPath)
   let improved = true
@@ -85,6 +42,21 @@ export const minimizeTurns = ({
       const stairEndIdx = recognizeStairStepPattern(optimizedPath, startIdx)
 
       if (stairEndIdx > 0) {
+        if (
+          isSegmentAnEndpointSegment(
+            optimizedPath[startIdx],
+            optimizedPath[startIdx + 1],
+            originalPath,
+          ) ||
+          isSegmentAnEndpointSegment(
+            optimizedPath[stairEndIdx - 1],
+            optimizedPath[stairEndIdx],
+            originalPath,
+          )
+        ) {
+          continue
+        }
+
         const startPoint = optimizedPath[startIdx]
         const endPoint = optimizedPath[stairEndIdx]
 
@@ -129,6 +101,21 @@ export const minimizeTurns = ({
 
           if (endIdx >= optimizedPath.length) continue
 
+          if (
+            isSegmentAnEndpointSegment(
+              optimizedPath[startIdx],
+              optimizedPath[startIdx + 1],
+              originalPath,
+            ) ||
+            isSegmentAnEndpointSegment(
+              optimizedPath[endIdx - 1],
+              optimizedPath[endIdx],
+              originalPath,
+            )
+          ) {
+            continue
+          }
+
           const startPoint = optimizedPath[startIdx]
           const endPoint = optimizedPath[endIdx]
 
@@ -179,6 +166,13 @@ export const minimizeTurns = ({
         const p2 = optimizedPath[i + 1]
         const p3 = optimizedPath[i + 2]
 
+        if (
+          isSegmentAnEndpointSegment(p1, p2, originalPath) ||
+          isSegmentAnEndpointSegment(p2, p3, originalPath)
+        ) {
+          continue
+        }
+
         const allVertical = p1.x === p2.x && p2.x === p3.x
         const allHorizontal = p1.y === p2.y && p2.y === p3.y
 

package/lib/solvers/TraceCleanupSolver/visualizeTightRectangle.ts

@@ -0,0 +1,24 @@
+import type { GraphicsObject } from "graphics-debug"
+import type { Rectangle } from "./sub-solver/generateRectangleCandidates"
+
+/**
+ * Visualizes a given rectangle by drawing it as a green-stroked rectangle.
+ * This function is useful for highlighting specific rectangular areas in a graphical representation.
+ */
+export const visualizeTightRectangle = (
+  rectangle: Rectangle,
+): GraphicsObject => {
+  const graphics: GraphicsObject = { rects: [] }
+
+  graphics.rects!.push({
+    center: {
+      x: rectangle.x + rectangle.width / 2,
+      y: rectangle.y + rectangle.height / 2,
+    },
+    width: rectangle.width,
+    height: rectangle.height,
+    stroke: "green",
+  })
+
+  return graphics
+}

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,