@tscircuit/schematic-trace-solver 0.0.44 → 0.0.46

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

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

@@ -6,14 +6,17 @@ import { visualizeInputProblem } from "lib/solvers/SchematicTracePipelineSolver/
 import type { InputProblem } from "lib/types/InputProblem"
 import { detectTraceLabelOverlap } from "../../detectTraceLabelOverlap"
 import { SingleOverlapSolver } from "../SingleOverlapSolver/SingleOverlapSolver"
+import { isPointInsideLabel } from "./isPointInsideLabel"
+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>>
 }
 
@@ -23,7 +26,8 @@ interface OverlapCollectionSolverInput {
  */
 export class OverlapAvoidanceStepSolver extends BaseSolver {
   inputProblem: InputProblem
-  netLabelPlacements: NetLabelPlacement[]
+  initialNetLabelPlacements: NetLabelPlacement[]
+  mergedNetLabelPlacements: NetLabelPlacement[]
   mergedLabelNetIdMap: Record<string, Set<string>>
 
   allTraces: SolvedTracePath[]
@@ -36,15 +40,21 @@ export class OverlapAvoidanceStepSolver extends BaseSolver {
   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]
   }
 
   override _step() {
+    this.currentlyProcessingOverlap = null
+    this.decomposedChildLabels = null
     if (this.activeSubSolver) {
       this.activeSubSolver.step()
 
@@ -65,19 +75,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 +90,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 +104,104 @@ 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 traceStartPoint = traceToFix.tracePath[0]
+
+      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 labelId = actualOverlapLabel.globalConnNetId
+          const detourCount = this.detourCountByLabel[labelId] || 0
+          this.detourCountByLabel[labelId] = detourCount + 1
+          this.activeSubSolver = new SingleOverlapSolver({
+            trace: traceToFix,
+            label: actualOverlapLabel,
+            problem: this.inputProblem,
+            paddingBuffer: this.PADDING_BUFFER,
+            detourCount,
+          })
+        } else {
+          const overlapId = `${traceToFix.mspPairId}-${labelToAvoid.globalConnNetId}`
+          this.recentlyFailed.add(overlapId)
+        }
+        return
+      }
+
+      if (
+        originalNetIds &&
+        isPointInsideLabel({ point: traceStartPoint, 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 labelId = actualOverlapLabel.globalConnNetId
+          const detourCount = this.detourCountByLabel[labelId] || 0
+          this.detourCountByLabel[labelId] = detourCount + 1
+          this.activeSubSolver = new SingleOverlapSolver({
+            trace: traceToFix,
+            label: actualOverlapLabel,
+            problem: this.inputProblem,
+            paddingBuffer: this.PADDING_BUFFER,
+            detourCount,
+          })
+        } else {
+          const overlapId = `${traceToFix.mspPairId}-${labelToAvoid.globalConnNetId}`
+          this.recentlyFailed.add(overlapId)
+        }
+        return
       }
+
+      const labelId = labelToAvoid.globalConnNetId
+      const detourCount = this.detourCountByLabel[labelId] || 0
+      this.detourCountByLabel[labelId] = detourCount + 1
+      this.activeSubSolver = new SingleOverlapSolver({
+        trace: traceToFix,
+        label: labelToAvoid,
+        problem: this.inputProblem,
+        paddingBuffer: this.PADDING_BUFFER,
+        detourCount,
+      })
     }
   }
 
@@ -130,7 +216,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 +225,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/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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tscircuit/schematic-trace-solver",
   "main": "dist/index.js",
-  "version": "0.0.44",
+  "version": "0.0.46",
   "type": "module",
   "scripts": {
     "start": "cosmos",

package/tests/examples/__snapshots__/example29.snap.svg

@@ -543,7 +543,7 @@ x+" data-x="-8.4" data-y="-17" cx="198.31710258539454" cy="399.68032912258366" r
     <circle data-type="point" data-label="" data-x="3.5999999999999996" data-y="0.5000000000000013" cx="413.0516274346982" cy="86.52581371734914" r="3" fill="hsl(80, 100%, 50%, 0.9)" />
   </g>
   <g>
-    <circle data-type="point" data-label="" data-x="-6.262500000000001" data-y="-12" cx="236.56668982417676" cy="310.2076104353738" r="3" fill="hsl(80, 100%, 50%, 0.9)" />
+    <circle data-type="point" data-label="" data-x="-6.112500000000001" data-y="-12" cx="239.25087138479304" cy="310.2076104353738" r="3" fill="hsl(80, 100%, 50%, 0.9)" />
   </g>
   <g>
     <circle data-type="point" data-label="" data-x="-4" data-y="-14.225" cx="277.0530950301392" cy="350.0229702511822" r="3" fill="hsl(80, 100%, 50%, 0.9)" />
@@ -849,7 +849,7 @@ x+" data-x="-8.4" data-y="-17" cx="198.31710258539454" cy="399.68032912258366" r
     <polyline data-points="-4.449999999999999,-10 -4,-10 -4,-10.45" data-type="line" data-label="" points="269.00055034829035,274.4185229604899 277.0530950301392,274.4185229604899 277.0530950301392,282.47106764233877" fill="none" stroke="purple" stroke-width="1" />
   </g>
   <g>
-    <polyline data-points="-5.550000000000001,-10 -5.750000000000001,-10 -5.750000000000001,-10.1 -7.075,-10.1 -7.075,-5 -8.4,-5" data-type="line" data-label="" points="249.31655223710416,274.4185229604899 245.73764348961578,274.4185229604899 245.73764348961578,276.2079773342341 222.02737303750516,276.2079773342341 222.02737303750516,184.94580427328003 198.31710258539454,184.94580427328003" fill="none" stroke="purple" stroke-width="1" />
+    <polyline data-points="-5.550000000000001,-10 -5.750000000000001,-10 -5.750000000000001,-9 -8.200000000000001,-9 -8.200000000000001,-5 -8.4,-5" data-type="line" data-label="" points="249.31655223710416,274.4185229604899 245.73764348961578,274.4185229604899 245.73764348961578,256.52397922304795 201.89601133288292,256.52397922304795 201.89601133288292,184.94580427328003 198.31710258539454,184.94580427328003" fill="none" stroke="purple" stroke-width="1" />
   </g>
   <g>
     <polyline data-points="-4,-11.55 -4,-12 -3,-12 -3,-12.45" data-type="line" data-label="" points="277.0530950301392,302.1550657535249 277.0530950301392,310.2076104353738 294.9476387675812,310.2076104353738 294.9476387675812,318.2601551172227" fill="none" stroke="purple" stroke-width="1" />
@@ -858,7 +858,7 @@ x+" data-x="-8.4" data-y="-17" cx="198.31710258539454" cy="399.68032912258366" r
     <polyline data-points="-4.449999999999999,-12 -4,-12 -4,-11.55" data-type="line" data-label="" points="269.00055034829035,310.2076104353738 277.0530950301392,310.2076104353738 277.0530950301392,302.1550657535249" fill="none" stroke="purple" stroke-width="1" />
   </g>
   <g>
-    <polyline data-points="-5.550000000000001,-12 -6.9750000000000005,-12 -6.9750000000000005,-9.2 -8.4,-9.2" data-type="line" data-label="" points="249.31655223710416,310.2076104353738 223.81682741124934,310.2076104353738 223.81682741124934,260.1028879705363 198.31710258539454,260.1028879705363" fill="none" stroke="purple" stroke-width="1" />
+    <polyline data-points="-5.550000000000001,-12 -6.675000000000001,-12 -6.675000000000001,-9.2 -8.4,-9.2" data-type="line" data-label="" points="249.31655223710416,310.2076104353738 229.18519053248195,310.2076104353738 229.18519053248195,260.1028879705363 198.31710258539454,260.1028879705363" fill="none" stroke="purple" stroke-width="1" />
   </g>
   <g>
     <polyline data-points="-4,-14.45 -4,-14 -3,-14 -3,-13.55" data-type="line" data-label="" points="277.0530950301392,354.0492425921067 277.0530950301392,345.9966979102578 294.9476387675812,345.9966979102578 294.9476387675812,337.94415322840894" fill="none" stroke="purple" stroke-width="1" />
@@ -876,7 +876,7 @@ x+" data-x="-8.4" data-y="-17" cx="198.31710258539454" cy="399.68032912258366" r
     <polyline data-points="-3,-16.45 -3,-16 -4,-16 -4,-15.55" data-type="line" data-label="" points="294.9476387675812,389.8383300669906 294.9476387675812,381.7857853851417 277.0530950301392,381.7857853851417 277.0530950301392,373.73324070329284" fill="none" stroke="purple" stroke-width="1" />
   </g>
   <g>
-    <polyline data-points="-5.550000000000001,-16 -6.875000000000001,-16 -6.875000000000001,-9.9 -8.200000000000001,-9.9 -8.200000000000001,-10 -8.4,-10" data-type="line" data-label="" points="249.31655223710416,381.7857853851417 225.60628178499354,381.7857853851417 225.60628178499354,272.6290685867457 201.89601133288292,272.6290685867457 201.89601133288292,274.4185229604899 198.31710258539454,274.4185229604899" fill="none" stroke="purple" stroke-width="1" />
+    <polyline data-points="-5.550000000000001,-16 -6.875000000000001,-16 -6.875000000000001,-10 -8.4,-10" data-type="line" data-label="" points="249.31655223710416,381.7857853851417 225.60628178499354,381.7857853851417 225.60628178499354,274.4185229604899 198.31710258539454,274.4185229604899" fill="none" stroke="purple" stroke-width="1" />
   </g>
   <g>
     <polyline data-points="-4,-18.45 -4,-18 -3,-18 -3,-17.55" data-type="line" data-label="" points="277.0530950301392,425.6274175418746 277.0530950301392,417.5748728600257 294.9476387675812,417.5748728600257 294.9476387675812,409.52232817817685" fill="none" stroke="purple" stroke-width="1" />
@@ -1056,7 +1056,7 @@ x+" data-x="-8.4" data-y="-17" cx="198.31710258539454" cy="399.68032912258366" r
     <rect data-type="rect" data-label="" data-x="3.3739999999999997" data-y="0.7000000000000015" x="404.9811882091119" y="81.15745059611653" width="8.052544681848872" height="3.5789087474883985" fill="hsl(80, 100%, 50%, 0.35)" stroke="black" stroke-width="0.05588295598214286" />
   </g>
   <g>
-    <rect data-type="rect" data-label="" data-x="-5.750000000000001" data-y="-9.775" x="243.94818911587157" y="266.365978278641" width="3.5789087474883843" height="8.052544681848872" fill="hsl(80, 100%, 50%, 0.35)" stroke="black" stroke-width="0.05588295598214286" />
+    <rect data-type="rect" data-label="" data-x="-5.750000000000001" data-y="-10.225" x="243.94818911587157" y="274.4185229604899" width="3.5789087474883843" height="8.052544681848872" fill="hsl(80, 100%, 50%, 0.35)" stroke="black" stroke-width="0.05588295598214286" />
   </g>
   <g>
     <rect data-type="rect" data-label="" data-x="-3.775" data-y="-11.775" x="277.0530950301392" y="304.3918837207052" width="8.052544681848929" height="3.5789087474884127" fill="hsl(80, 100%, 50%, 0.35)" stroke="black" stroke-width="0.05588295598214286" />
@@ -1065,7 +1065,7 @@ x+" data-x="-8.4" data-y="-17" cx="198.31710258539454" cy="399.68032912258366" r
     <rect data-type="rect" data-label="" data-x="3.3739999999999997" data-y="0.5000000000000013" x="404.9811882091119" y="84.73635934360493" width="8.052544681848872" height="3.5789087474883985" fill="hsl(80, 100%, 50%, 0.35)" stroke="black" stroke-width="0.05588295598214286" />
   </g>
   <g>
-    <rect data-type="rect" data-label="" data-x="-6.262500000000001" data-y="-11.775" x="234.77723545043256" y="302.1550657535249" width="3.5789087474883843" height="8.052544681848872" fill="hsl(80, 100%, 50%, 0.35)" stroke="black" stroke-width="0.05588295598214286" />
+    <rect data-type="rect" data-label="" data-x="-6.112500000000001" data-y="-11.775" x="237.46141701104887" y="302.1550657535249" width="3.578908747488356" height="8.052544681848872" fill="hsl(80, 100%, 50%, 0.35)" stroke="black" stroke-width="0.05588295598214286" />
   </g>
   <g>
     <rect data-type="rect" data-label="" data-x="-3.775" data-y="-14.225" x="277.0530950301392" y="348.23351587743804" width="8.052544681848929" height="3.578908747488356" fill="hsl(80, 100%, 50%, 0.35)" stroke="black" stroke-width="0.05588295598214286" />

package/tests/solvers/TraceLabelOverlapAvoidanceSolver/__snapshots__/TraceLabelOverlapAvoidanceSolver.snap.svg

@@ -160,28 +160,28 @@ x-" data-x="-0.42" data-y="-0.1" cx="279.0224461302513" cy="382.68590086027035"
     <rect data-type="rect" data-label="schematic_component_6" data-x="0" data-y="0" x="277.802876074604" y="349.51359534666426" width="43.416693981043295" height="56.58805058203393" fill="hsl(24, 100%, 50%, 0.8)" stroke="black" stroke-width="0.020499027410714285" />
   </g>
   <g>
-    <rect data-type="rect" data-label="connectivity_net0" data-x="-4.78" data-y="2.7600000000000002" x="55.35329792453959" y="238.288806271632" width="21.95226100165104" height="9.75656044517828" fill="hsl(40, 100%, 50%, 0.3)" stroke="hsl(40, 100%, 50%, 1)" stroke-width="0.020499027410714285" />
+    <rect data-type="rect" data-label="connectivity_net2" data-x="6" data-y="0.776" x="587.3297561978845" y="328.976035609564" width="9.756560445178138" height="21.952261001651095" fill="hsl(40, 100%, 50%, 0.3)" stroke="hsl(40, 100%, 50%, 1)" stroke-width="0.020499027410714285" />
   </g>
   <g>
-    <rect data-type="rect" data-label="connectivity_net3" data-x="3" data-y="-0.93" x="440.9813495202105" y="415.85820637387644" width="9.756560445178309" height="14.634840667767435" fill="hsl(40, 100%, 50%, 0.3)" stroke="hsl(40, 100%, 50%, 1)" stroke-width="0.020499027410714285" />
+    <rect data-type="rect" data-label="connectivity_net2" data-x="3.7199999999999998" data-y="3.225" x="476.10496712285226" y="209.50695295835615" width="9.756560445178252" height="21.952261001651095" fill="hsl(40, 100%, 50%, 0.3)" stroke="hsl(40, 100%, 50%, 1)" stroke-width="0.020499027410714285" />
   </g>
   <g>
-    <rect data-type="rect" data-label="connectivity_net3" data-x="6" data-y="-0.7010000000000001" x="587.3297561978845" y="404.68694466414735" width="9.756560445178138" height="14.634840667767378" fill="hsl(40, 100%, 50%, 0.3)" stroke="hsl(40, 100%, 50%, 1)" stroke-width="0.020499027410714285" />
+    <rect data-type="rect" data-label="connectivity_net1" data-x="0.3" data-y="0.8059999999999999" x="309.2677835103039" y="327.51255154278726" width="9.756560445178309" height="21.952261001651095" fill="hsl(40, 100%, 50%, 0.3)" stroke="hsl(40, 100%, 50%, 1)" stroke-width="0.020499027410714285" />
   </g>
   <g>
-    <rect data-type="rect" data-label="connectivity_net3" data-x="-4.995" data-y="-0.7958008" x="50.96284572420936" y="409.31159334140364" width="9.756560445178224" height="14.634840667767378" fill="hsl(40, 100%, 50%, 0.3)" stroke="hsl(40, 100%, 50%, 1)" stroke-width="0.020499027410714285" />
+    <rect data-type="rect" data-label="connectivity_net1" data-x="0.78" data-y="3.1950000000000003" x="332.68352857873174" y="210.97043702513287" width="9.756560445178252" height="21.952261001651124" fill="hsl(40, 100%, 50%, 0.3)" stroke="hsl(40, 100%, 50%, 1)" stroke-width="0.020499027410714285" />
   </g>
   <g>
-    <rect data-type="rect" data-label="connectivity_net1" data-x="0.78" data-y="3.1950000000000003" x="332.68352857873174" y="210.97043702513287" width="9.756560445178252" height="21.952261001651124" fill="hsl(40, 100%, 50%, 0.3)" stroke="hsl(40, 100%, 50%, 1)" stroke-width="0.020499027410714285" />
+    <rect data-type="rect" data-label="connectivity_net3" data-x="6" data-y="-0.7010000000000001" x="587.3297561978845" y="404.68694466414735" width="9.756560445178138" height="14.634840667767378" fill="hsl(40, 100%, 50%, 0.3)" stroke="hsl(40, 100%, 50%, 1)" stroke-width="0.020499027410714285" />
   </g>
   <g>
-    <rect data-type="rect" data-label="merged-group-M1-y+" data-x="-0.39186722499999993" data-y="0.4655" x="241.7653395028014" y="327.51255154278726" width="77.25900445268081" height="55.17334931748309" fill="hsl(296, 100%, 50%, 0.3)" stroke="hsl(296, 100%, 50%, 1)" stroke-width="0.020499027410714285" />
+    <rect data-type="rect" data-label="connectivity_net3" data-x="3" data-y="-0.93" x="440.9813495202105" y="415.85820637387644" width="9.756560445178309" height="14.634840667767435" fill="hsl(40, 100%, 50%, 0.3)" stroke="hsl(40, 100%, 50%, 1)" stroke-width="0.020499027410714285" />
   </g>
   <g>
-    <rect data-type="rect" data-label="connectivity_net2" data-x="3.7199999999999998" data-y="3.225" x="476.10496712285226" y="209.50695295835615" width="9.756560445178252" height="21.952261001651095" fill="hsl(40, 100%, 50%, 0.3)" stroke="hsl(40, 100%, 50%, 1)" stroke-width="0.020499027410714285" />
+    <rect data-type="rect" data-label="connectivity_net0" data-x="-4.78" data-y="2.7600000000000002" x="55.35329792453959" y="238.288806271632" width="21.95226100165104" height="9.75656044517828" fill="hsl(40, 100%, 50%, 0.3)" stroke="hsl(40, 100%, 50%, 1)" stroke-width="0.020499027410714285" />
   </g>
   <g>
-    <rect data-type="rect" data-label="connectivity_net2" data-x="6" data-y="0.776" x="587.3297561978845" y="328.976035609564" width="9.756560445178138" height="21.952261001651095" fill="hsl(40, 100%, 50%, 0.3)" stroke="hsl(40, 100%, 50%, 1)" stroke-width="0.020499027410714285" />
+    <rect data-type="rect" data-label="connectivity_net4" data-x="-1.08373445" data-y="0.12500000000000014" x="241.7653395028014" y="360.73363985861926" width="9.75656044517828" height="21.952261001651095" fill="hsl(40, 100%, 50%, 0.3)" stroke="hsl(40, 100%, 50%, 1)" stroke-width="0.020499027410714285" />
   </g>
   <g id="crosshair" style="display: none">
     <line id="crosshair-h" y1="0" y2="640" stroke="#666" stroke-width="0.5" />