@tscircuit/schematic-trace-solver 0.0.38 → 0.0.40

package/dist/index.d.ts

@@ -392,14 +392,13 @@ declare class TraceLabelOverlapAvoidanceSolver extends BaseSolver {
     private netTempLabelPlacements;
     private netLabelPlacements;
     private updatedTraces;
-    private updatedTracesMap;
     private mergedLabelNetIdMap;
     private detourCountByLabel;
     private readonly PADDING_BUFFER;
     constructor(solverInput: TraceLabelOverlapAvoidanceSolverInput);
     _step(): void;
     getOutput(): {
-        traceMap: Map<string, SolvedTracePath>;
+        traces: SolvedTracePath[];
         netLabelPlacements: NetLabelPlacement[];
     };
     visualize(): GraphicsObject;

package/dist/index.js

@@ -1015,12 +1015,12 @@ var applyJogToTerminalSegment = ({
   if (si !== 0 && si !== pts.length - 2) return;
   const start = pts[si];
   const end = pts[si + 1];
-  const isVertical3 = Math.abs(start.x - end.x) < EPS4;
-  const isHorizontal3 = Math.abs(start.y - end.y) < EPS4;
-  if (!isVertical3 && !isHorizontal3) return;
-  const segDir = isVertical3 ? end.y > start.y ? 1 : -1 : end.x > start.x ? 1 : -1;
+  const isVertical2 = Math.abs(start.x - end.x) < EPS4;
+  const isHorizontal2 = Math.abs(start.y - end.y) < EPS4;
+  if (!isVertical2 && !isHorizontal2) return;
+  const segDir = isVertical2 ? end.y > start.y ? 1 : -1 : end.x > start.x ? 1 : -1;
   if (si === 0) {
-    if (isVertical3) {
+    if (isVertical2) {
       const jogY = start.y + segDir * JOG_SIZE;
       pts.splice(
         1,
@@ -1040,7 +1040,7 @@ var applyJogToTerminalSegment = ({
       );
     }
   } else {
-    if (isVertical3) {
+    if (isVertical2) {
       const jogY = end.y - segDir * JOG_SIZE;
       pts.splice(
         si,
@@ -1120,10 +1120,10 @@ var TraceOverlapIssueSolver = class extends BaseSolver {
           } else {
             const start = pts[si];
             const end = pts[si + 1];
-            const isVertical3 = Math.abs(start.x - end.x) < EPS4;
-            const isHorizontal3 = Math.abs(start.y - end.y) < EPS4;
-            if (!isVertical3 && !isHorizontal3) continue;
-            if (isVertical3) {
+            const isVertical2 = Math.abs(start.x - end.x) < EPS4;
+            const isHorizontal2 = Math.abs(start.y - end.y) < EPS4;
+            if (!isVertical2 && !isHorizontal2) continue;
+            if (isVertical2) {
               start.x += offset;
               end.x += offset;
             } else {
@@ -2508,6 +2508,32 @@ var countTurns = (points) => {
   return turns;
 };
 
+// lib/solvers/TraceLabelOverlapAvoidanceSolver/tryConnectPoints.ts
+var tryConnectPoints = (start, end) => {
+  const candidates = [];
+  if (start.x === end.x || start.y === end.y) {
+    candidates.push([start, end]);
+  } else {
+    candidates.push([start, { x: end.x, y: start.y }, end]);
+    candidates.push([start, { x: start.x, y: end.y }, end]);
+  }
+  return candidates;
+};
+
+// lib/solvers/TraceLabelOverlapAvoidanceSolver/hasCollisionsWithLabels.ts
+var hasCollisionsWithLabels = (pathSegments, labels) => {
+  for (let i = 0; i < pathSegments.length - 1; i++) {
+    const p1 = pathSegments[i];
+    const p2 = pathSegments[i + 1];
+    for (const label of labels) {
+      if (segmentIntersectsRect(p1, p2, label)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+
 // lib/solvers/TraceLabelOverlapAvoidanceSolver/turnMinimization.ts
 var minimizeTurns = ({
   path,
@@ -2517,28 +2543,6 @@ var minimizeTurns = ({
   if (path.length <= 2) {
     return path;
   }
-  const hasCollisionsWithLabels = (pathSegments, labels) => {
-    for (let i = 0; i < pathSegments.length - 1; i++) {
-      const p1 = pathSegments[i];
-      const p2 = pathSegments[i + 1];
-      for (const label of labels) {
-        if (segmentIntersectsRect(p1, p2, label)) {
-          return true;
-        }
-      }
-    }
-    return false;
-  };
-  const tryConnectPoints = (start, end) => {
-    const candidates = [];
-    if (start.x === end.x || start.y === end.y) {
-      candidates.push([start, end]);
-    } else {
-      candidates.push([start, { x: end.x, y: start.y }, end]);
-      candidates.push([start, { x: start.x, y: end.y }, end]);
-    }
-    return candidates;
-  };
   const recognizeStairStepPattern = (pathToCheck, startIdx) => {
     if (startIdx >= pathToCheck.length - 3) return -1;
     let endIdx = startIdx;
@@ -2672,6 +2676,8 @@ var minimizeTurns = ({
   const finalSimplifiedPath = simplifyPath(optimizedPath);
   return finalSimplifiedPath;
 };
+
+// lib/solvers/TraceLabelOverlapAvoidanceSolver/minimizeTurnsWithFilteredLabels.ts
 var minimizeTurnsWithFilteredLabels = ({
   traces,
   problem,
@@ -2684,7 +2690,7 @@ var minimizeTurnsWithFilteredLabels = ({
   const newTraces = traces.map((trace) => {
     const originalPath = trace.tracePath;
     const filteredLabels = allLabelPlacements.filter((label) => {
-      const originalNetIds = mergedLabelNetIdMap.get(label.globalConnNetId);
+      const originalNetIds = mergedLabelNetIdMap[label.globalConnNetId];
       if (originalNetIds) {
         return !originalNetIds.has(trace.globalConnNetId);
       }
@@ -2865,7 +2871,6 @@ var TraceLabelOverlapAvoidanceSolver = class extends BaseSolver {
   netTempLabelPlacements;
   netLabelPlacements;
   updatedTraces;
-  updatedTracesMap;
   mergedLabelNetIdMap;
   detourCountByLabel;
   PADDING_BUFFER = 0.1;
@@ -2874,28 +2879,27 @@ var TraceLabelOverlapAvoidanceSolver = class extends BaseSolver {
     this.problem = solverInput.inputProblem;
     this.traces = solverInput.traces;
     this.updatedTraces = [...solverInput.traces];
-    this.updatedTracesMap = /* @__PURE__ */ new Map();
-    this.mergedLabelNetIdMap = /* @__PURE__ */ new Map();
-    this.detourCountByLabel = /* @__PURE__ */ new Map();
+    this.mergedLabelNetIdMap = {};
+    this.detourCountByLabel = {};
     const originalLabels = solverInput.netLabelPlacements;
     this.netLabelPlacements = originalLabels;
     if (!originalLabels || originalLabels.length === 0) {
       this.netTempLabelPlacements = [];
       return;
     }
-    const labelGroups = /* @__PURE__ */ new Map();
+    const labelGroups = {};
     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 (!labelGroups.has(key)) {
-        labelGroups.set(key, []);
+      if (!(key in labelGroups)) {
+        labelGroups[key] = [];
       }
-      labelGroups.get(key).push(p);
+      labelGroups[key].push(p);
     }
     const finalPlacements = [];
-    for (const [key, group] of labelGroups.entries()) {
+    for (const [key, group] of Object.entries(labelGroups)) {
       if (group.length <= 1) {
         finalPlacements.push(...group);
         continue;
@@ -2913,7 +2917,7 @@ var TraceLabelOverlapAvoidanceSolver = class extends BaseSolver {
       const template = group[0];
       const syntheticId = `merged-group-${key}`;
       const originalNetIds = new Set(group.map((p) => p.globalConnNetId));
-      this.mergedLabelNetIdMap.set(syntheticId, originalNetIds);
+      this.mergedLabelNetIdMap[syntheticId] = originalNetIds;
       finalPlacements.push({
         ...template,
         globalConnNetId: syntheticId,
@@ -2933,7 +2937,7 @@ var TraceLabelOverlapAvoidanceSolver = class extends BaseSolver {
       this.solved = true;
       return;
     }
-    this.detourCountByLabel.clear();
+    this.detourCountByLabel = {};
     const overlaps = detectTraceLabelOverlap(
       this.traces,
       this.netTempLabelPlacements
@@ -2943,9 +2947,7 @@ var TraceLabelOverlapAvoidanceSolver = class extends BaseSolver {
       return;
     }
     const unfriendlyOverlaps = overlaps.filter((o) => {
-      const originalNetIds = this.mergedLabelNetIdMap.get(
-        o.label.globalConnNetId
-      );
+      const originalNetIds = this.mergedLabelNetIdMap[o.label.globalConnNetId];
       if (originalNetIds) {
         return !originalNetIds.has(o.trace.globalConnNetId);
       }
@@ -2955,18 +2957,18 @@ var TraceLabelOverlapAvoidanceSolver = class extends BaseSolver {
       this.solved = true;
       return;
     }
-    const updatedTracesMap = /* @__PURE__ */ new Map();
+    const updatedTracesMap = {};
     for (const trace of this.traces) {
-      updatedTracesMap.set(trace.mspPairId, trace);
+      updatedTracesMap[trace.mspPairId] = trace;
     }
     const processedTraceIds = /* @__PURE__ */ new Set();
     for (const overlap of unfriendlyOverlaps) {
       if (processedTraceIds.has(overlap.trace.mspPairId)) {
         continue;
       }
-      const currentTraceState = updatedTracesMap.get(overlap.trace.mspPairId);
+      const currentTraceState = updatedTracesMap[overlap.trace.mspPairId];
       const labelId = overlap.label.globalConnNetId;
-      const detourCount = this.detourCountByLabel.get(labelId) || 0;
+      const detourCount = this.detourCountByLabel[labelId] || 0;
       const newTrace = rerouteCollidingTrace({
         trace: currentTraceState,
         label: overlap.label,
@@ -2975,12 +2977,12 @@ var TraceLabelOverlapAvoidanceSolver = class extends BaseSolver {
         detourCount
       });
       if (newTrace.tracePath !== currentTraceState.tracePath) {
-        this.detourCountByLabel.set(labelId, detourCount + 1);
+        this.detourCountByLabel[labelId] = detourCount + 1;
       }
-      updatedTracesMap.set(currentTraceState.mspPairId, newTrace);
+      updatedTracesMap[currentTraceState.mspPairId] = newTrace;
       processedTraceIds.add(currentTraceState.mspPairId);
     }
-    this.updatedTraces = Array.from(updatedTracesMap.values());
+    this.updatedTraces = Object.values(updatedTracesMap);
     const minimizedTraces = minimizeTurnsWithFilteredLabels({
       traces: this.updatedTraces,
       problem: this.problem,
@@ -3000,21 +3002,21 @@ var TraceLabelOverlapAvoidanceSolver = class extends BaseSolver {
     if (balancedTraces) {
       this.updatedTraces = balancedTraces;
     }
-    this.updatedTracesMap.clear();
-    for (const trace of this.updatedTraces) {
-      this.updatedTracesMap.set(trace.mspPairId, trace);
-    }
     const finalLabelPlacementSolver = new NetLabelPlacementSolver({
       inputProblem: this.problem,
-      inputTraceMap: Object.fromEntries(this.updatedTracesMap)
+      inputTraceMap: Object.fromEntries(
+        this.updatedTraces.map((trace) => [trace.mspPairId, trace])
+      )
     });
     finalLabelPlacementSolver.solve();
-    this.netLabelPlacements = finalLabelPlacementSolver.netLabelPlacements;
+    if (!finalLabelPlacementSolver.failed) {
+      this.netLabelPlacements = finalLabelPlacementSolver.netLabelPlacements;
+    }
     this.solved = true;
   }
   getOutput() {
     return {
-      traceMap: this.updatedTracesMap,
+      traces: this.updatedTraces,
       netLabelPlacements: this.netLabelPlacements
     };
   }
@@ -3024,7 +3026,7 @@ var TraceLabelOverlapAvoidanceSolver = class extends BaseSolver {
     if (!graphics.circles) graphics.circles = [];
     if (!graphics.texts) graphics.texts = [];
     if (!graphics.rects) graphics.rects = [];
-    for (const trace of Object.values(this.updatedTraces)) {
+    for (const trace of this.updatedTraces) {
       graphics.lines.push({
         points: trace.tracePath,
         strokeColor: "purple"

package/lib/solvers/TraceLabelOverlapAvoidanceSolver/TraceLabelOverlapAvoidanceSolver.ts

@@ -8,7 +8,7 @@ import { visualizeInputProblem } from "../SchematicTracePipelineSolver/visualize
 import { getRectBounds } from "../NetLabelPlacementSolver/SingleNetLabelPlacementSolver/geometry"
 import { getColorFromString } from "lib/utils/getColorFromString"
 import type { InputProblem } from "lib/types/InputProblem"
-import { minimizeTurnsWithFilteredLabels } from "./turnMinimization"
+import { minimizeTurnsWithFilteredLabels } from "./minimizeTurnsWithFilteredLabels"
 import { balanceLShapes } from "./balanceLShapes"
 import { NetLabelPlacementSolver } from "../NetLabelPlacementSolver/NetLabelPlacementSolver"
 
@@ -24,9 +24,8 @@ export class TraceLabelOverlapAvoidanceSolver extends BaseSolver {
   private netTempLabelPlacements: NetLabelPlacement[]
   private netLabelPlacements: NetLabelPlacement[]
   private updatedTraces: SolvedTracePath[]
-  private updatedTracesMap: Map<string, SolvedTracePath>
-  private mergedLabelNetIdMap: Map<string, Set<string>>
-  private detourCountByLabel: Map<string, number>
+  private mergedLabelNetIdMap: Record<string, Set<string>>
+  private detourCountByLabel: Record<string, number>
   private readonly PADDING_BUFFER = 0.1
 
   constructor(solverInput: TraceLabelOverlapAvoidanceSolverInput) {
@@ -34,9 +33,8 @@ export class TraceLabelOverlapAvoidanceSolver extends BaseSolver {
     this.problem = solverInput.inputProblem
     this.traces = solverInput.traces
     this.updatedTraces = [...solverInput.traces]
-    this.updatedTracesMap = new Map()
-    this.mergedLabelNetIdMap = new Map()
-    this.detourCountByLabel = new Map()
+    this.mergedLabelNetIdMap = {}
+    this.detourCountByLabel = {}
 
     const originalLabels = solverInput.netLabelPlacements
     this.netLabelPlacements = originalLabels
@@ -45,21 +43,21 @@ export class TraceLabelOverlapAvoidanceSolver extends BaseSolver {
       return
     }
 
-    const labelGroups = new Map<string, NetLabelPlacement[]>()
+    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 (!labelGroups.has(key)) {
-        labelGroups.set(key, [])
+      if (!(key in labelGroups)) {
+        labelGroups[key] = []
       }
-      labelGroups.get(key)!.push(p)
+      labelGroups[key]!.push(p)
     }
 
     const finalPlacements: NetLabelPlacement[] = []
-    for (const [key, group] of labelGroups.entries()) {
+    for (const [key, group] of Object.entries(labelGroups)) {
       if (group.length <= 1) {
         finalPlacements.push(...group)
         continue
@@ -82,7 +80,7 @@ export class TraceLabelOverlapAvoidanceSolver extends BaseSolver {
       const template = group[0]!
       const syntheticId = `merged-group-${key}`
       const originalNetIds = new Set(group.map((p) => p.globalConnNetId))
-      this.mergedLabelNetIdMap.set(syntheticId, originalNetIds)
+      this.mergedLabelNetIdMap[syntheticId] = originalNetIds
 
       finalPlacements.push({
         ...template,
@@ -111,7 +109,7 @@ export class TraceLabelOverlapAvoidanceSolver extends BaseSolver {
       return
     }
 
-    this.detourCountByLabel.clear()
+    this.detourCountByLabel = {}
 
     const overlaps = detectTraceLabelOverlap(
       this.traces,
@@ -124,9 +122,7 @@ export class TraceLabelOverlapAvoidanceSolver extends BaseSolver {
     }
 
     const unfriendlyOverlaps = overlaps.filter((o) => {
-      const originalNetIds = this.mergedLabelNetIdMap.get(
-        o.label.globalConnNetId,
-      )
+      const originalNetIds = this.mergedLabelNetIdMap[o.label.globalConnNetId]
       if (originalNetIds) {
         return !originalNetIds.has(o.trace.globalConnNetId)
       }
@@ -138,9 +134,9 @@ export class TraceLabelOverlapAvoidanceSolver extends BaseSolver {
       return
     }
 
-    const updatedTracesMap = new Map<string, SolvedTracePath>()
+    const updatedTracesMap: Record<string, SolvedTracePath> = {}
     for (const trace of this.traces) {
-      updatedTracesMap.set(trace.mspPairId, trace)
+      updatedTracesMap[trace.mspPairId] = trace
     }
 
     const processedTraceIds = new Set<string>()
@@ -150,9 +146,9 @@ export class TraceLabelOverlapAvoidanceSolver extends BaseSolver {
         continue
       }
 
-      const currentTraceState = updatedTracesMap.get(overlap.trace.mspPairId)!
+      const currentTraceState = updatedTracesMap[overlap.trace.mspPairId]!
       const labelId = overlap.label.globalConnNetId
-      const detourCount = this.detourCountByLabel.get(labelId) || 0
+      const detourCount = this.detourCountByLabel[labelId] || 0
 
       const newTrace = rerouteCollidingTrace({
         trace: currentTraceState,
@@ -163,14 +159,14 @@ export class TraceLabelOverlapAvoidanceSolver extends BaseSolver {
       })
 
       if (newTrace.tracePath !== currentTraceState.tracePath) {
-        this.detourCountByLabel.set(labelId, detourCount + 1)
+        this.detourCountByLabel[labelId] = detourCount + 1
       }
 
-      updatedTracesMap.set(currentTraceState.mspPairId, newTrace)
+      updatedTracesMap[currentTraceState.mspPairId] = newTrace
       processedTraceIds.add(currentTraceState.mspPairId)
     }
 
-    this.updatedTraces = Array.from(updatedTracesMap.values())
+    this.updatedTraces = Object.values(updatedTracesMap)
 
     const minimizedTraces = minimizeTurnsWithFilteredLabels({
       traces: this.updatedTraces,
@@ -191,24 +187,23 @@ export class TraceLabelOverlapAvoidanceSolver extends BaseSolver {
       this.updatedTraces = balancedTraces
     }
 
-    this.updatedTracesMap.clear()
-    for (const trace of this.updatedTraces) {
-      this.updatedTracesMap.set(trace.mspPairId, trace)
-    }
-
     const finalLabelPlacementSolver = new NetLabelPlacementSolver({
       inputProblem: this.problem,
-      inputTraceMap: Object.fromEntries(this.updatedTracesMap),
+      inputTraceMap: Object.fromEntries(
+        this.updatedTraces.map((trace) => [trace.mspPairId, trace]),
+      ),
     })
     finalLabelPlacementSolver.solve()
-    this.netLabelPlacements = finalLabelPlacementSolver.netLabelPlacements
+    if (!finalLabelPlacementSolver.failed) {
+      this.netLabelPlacements = finalLabelPlacementSolver.netLabelPlacements
+    }
 
     this.solved = true
   }
 
   getOutput() {
     return {
-      traceMap: this.updatedTracesMap,
+      traces: this.updatedTraces,
       netLabelPlacements: this.netLabelPlacements,
     }
   }
@@ -221,7 +216,7 @@ export class TraceLabelOverlapAvoidanceSolver extends BaseSolver {
     if (!graphics.texts) graphics.texts = []
     if (!graphics.rects) graphics.rects = []
 
-    for (const trace of Object.values(this.updatedTraces)) {
+    for (const trace of this.updatedTraces) {
       graphics.lines!.push({
         points: trace.tracePath,
         strokeColor: "purple",

package/lib/solvers/TraceLabelOverlapAvoidanceSolver/hasCollisions.ts

@@ -1,9 +1,5 @@
 import type { Point } from "graphics-debug"
-import {
-  isVertical,
-  isHorizontal,
-  segmentIntersectsRect,
-} from "../SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions"
+import { segmentIntersectsRect } from "../SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions"
 
 export const hasCollisions = (
   pathSegments: Point[],

package/lib/solvers/TraceLabelOverlapAvoidanceSolver/hasCollisionsWithLabels.ts

@@ -0,0 +1,19 @@
+import type { Point } from "@tscircuit/math-utils"
+import { segmentIntersectsRect } from "../SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions"
+
+export const hasCollisionsWithLabels = (
+  pathSegments: Point[],
+  labels: any[],
+): boolean => {
+  for (let i = 0; i < pathSegments.length - 1; i++) {
+    const p1 = pathSegments[i]
+    const p2 = pathSegments[i + 1]
+
+    for (const label of labels) {
+      if (segmentIntersectsRect(p1, p2, label)) {
+        return true
+      }
+    }
+  }
+  return false
+}

package/lib/solvers/TraceLabelOverlapAvoidanceSolver/minimizeTurnsWithFilteredLabels.ts

@@ -0,0 +1,66 @@
+import type { InputProblem } from "lib/types/InputProblem"
+import type { NetLabelPlacement } from "../NetLabelPlacementSolver/NetLabelPlacementSolver"
+import type { SolvedTracePath } from "../SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import { getObstacleRects } from "../SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/rect"
+import { minimizeTurns } from "./turnMinimization"
+
+export const minimizeTurnsWithFilteredLabels = ({
+  traces,
+  problem,
+  allLabelPlacements,
+  mergedLabelNetIdMap,
+  paddingBuffer,
+}: {
+  traces: SolvedTracePath[]
+  problem: InputProblem
+  allLabelPlacements: NetLabelPlacement[]
+  mergedLabelNetIdMap: Record<string, Set<string>>
+  paddingBuffer: number
+}): SolvedTracePath[] | null => {
+  let changesMade = false
+  const obstacles = getObstacleRects(problem)
+
+  const newTraces = traces.map((trace) => {
+    const originalPath = trace.tracePath
+    const filteredLabels = allLabelPlacements.filter((label) => {
+      const originalNetIds = mergedLabelNetIdMap[label.globalConnNetId]
+      if (originalNetIds) {
+        return !originalNetIds.has(trace.globalConnNetId)
+      }
+      return label.globalConnNetId !== trace.globalConnNetId
+    })
+
+    const labelBounds = filteredLabels.map((nl) => ({
+      minX: nl.center.x - nl.width / 2 - paddingBuffer,
+      maxX: nl.center.x + nl.width / 2 + paddingBuffer,
+      minY: nl.center.y - nl.height / 2 - paddingBuffer,
+      maxY: nl.center.y + nl.height / 2 + paddingBuffer,
+    }))
+
+    const newPath = minimizeTurns({
+      path: originalPath,
+      obstacles,
+      labelBounds,
+    })
+
+    if (
+      newPath.length !== originalPath.length ||
+      newPath.some(
+        (p, i) => p.x !== originalPath[i].x || p.y !== originalPath[i].y,
+      )
+    ) {
+      changesMade = true
+    }
+
+    return {
+      ...trace,
+      tracePath: newPath,
+    }
+  })
+
+  if (changesMade) {
+    return newTraces
+  } else {
+    return null
+  }
+}

package/lib/solvers/TraceLabelOverlapAvoidanceSolver/tryConnectPoints.ts

@@ -0,0 +1,14 @@
+import type { Point } from "@tscircuit/math-utils"
+
+export const tryConnectPoints = (start: Point, end: Point): Point[][] => {
+  const candidates: Point[][] = []
+
+  if (start.x === end.x || start.y === end.y) {
+    candidates.push([start, end])
+  } else {
+    candidates.push([start, { x: end.x, y: start.y }, end])
+    candidates.push([start, { x: start.x, y: end.y }, end])
+  }
+
+  return candidates
+}

package/lib/solvers/TraceLabelOverlapAvoidanceSolver/turnMinimization.ts

@@ -1,14 +1,11 @@
 import type { Point } from "graphics-debug"
-import type { InputProblem } from "lib/types/InputProblem"
-import type { NetLabelPlacement } from "../NetLabelPlacementSolver/NetLabelPlacementSolver"
-import { getObstacleRects } from "../SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/rect"
-import type { SolvedTracePath } from "../SchematicTraceLinesSolver/SchematicTraceLinesSolver"
-import { segmentIntersectsRect } from "../SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions"
 import { hasCollisions } from "./hasCollisions"
 import { countTurns } from "./countTurns"
 import { simplifyPath } from "./simplifyPath"
+import { tryConnectPoints } from "./tryConnectPoints"
+import { hasCollisionsWithLabels } from "./hasCollisionsWithLabels"
 
-const minimizeTurns = ({
+export const minimizeTurns = ({
   path,
   obstacles,
   labelBounds,
@@ -21,36 +18,6 @@ const minimizeTurns = ({
     return path
   }
 
-  const hasCollisionsWithLabels = (
-    pathSegments: Point[],
-    labels: any[],
-  ): boolean => {
-    for (let i = 0; i < pathSegments.length - 1; i++) {
-      const p1 = pathSegments[i]
-      const p2 = pathSegments[i + 1]
-
-      for (const label of labels) {
-        if (segmentIntersectsRect(p1, p2, label)) {
-          return true
-        }
-      }
-    }
-    return false
-  }
-
-  const tryConnectPoints = (start: Point, end: Point): Point[][] => {
-    const candidates: Point[][] = []
-
-    if (start.x === end.x || start.y === end.y) {
-      candidates.push([start, end])
-    } else {
-      candidates.push([start, { x: end.x, y: start.y }, end])
-      candidates.push([start, { x: start.x, y: end.y }, end])
-    }
-
-    return candidates
-  }
-
   const recognizeStairStepPattern = (
     pathToCheck: Point[],
     startIdx: number,
@@ -242,64 +209,3 @@ const minimizeTurns = ({
   const finalSimplifiedPath = simplifyPath(optimizedPath)
   return finalSimplifiedPath
 }
-
-export const minimizeTurnsWithFilteredLabels = ({
-  traces,
-  problem,
-  allLabelPlacements,
-  mergedLabelNetIdMap,
-  paddingBuffer,
-}: {
-  traces: SolvedTracePath[]
-  problem: InputProblem
-  allLabelPlacements: NetLabelPlacement[]
-  mergedLabelNetIdMap: Map<string, Set<string>>
-  paddingBuffer: number
-}): SolvedTracePath[] | null => {
-  let changesMade = false
-  const obstacles = getObstacleRects(problem)
-
-  const newTraces = traces.map((trace) => {
-    const originalPath = trace.tracePath
-    const filteredLabels = allLabelPlacements.filter((label) => {
-      const originalNetIds = mergedLabelNetIdMap.get(label.globalConnNetId)
-      if (originalNetIds) {
-        return !originalNetIds.has(trace.globalConnNetId)
-      }
-      return label.globalConnNetId !== trace.globalConnNetId
-    })
-
-    const labelBounds = filteredLabels.map((nl) => ({
-      minX: nl.center.x - nl.width / 2 - paddingBuffer,
-      maxX: nl.center.x + nl.width / 2 + paddingBuffer,
-      minY: nl.center.y - nl.height / 2 - paddingBuffer,
-      maxY: nl.center.y + nl.height / 2 + paddingBuffer,
-    }))
-
-    const newPath = minimizeTurns({
-      path: originalPath,
-      obstacles,
-      labelBounds,
-    })
-
-    if (
-      newPath.length !== originalPath.length ||
-      newPath.some(
-        (p, i) => p.x !== originalPath[i].x || p.y !== originalPath[i].y,
-      )
-    ) {
-      changesMade = true
-    }
-
-    return {
-      ...trace,
-      tracePath: newPath,
-    }
-  })
-
-  if (changesMade) {
-    return newTraces
-  } else {
-    return null
-  }
-}

package/package.json

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

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

@@ -0,0 +1,281 @@
+<svg width="640" height="640" viewBox="0 0 640 640" xmlns="http://www.w3.org/2000/svg">
+  <rect width="100%" height="100%" fill="white" />
+  <g>
+    <circle data-type="point" data-label="U1.1
+y+" data-x="-0.2" data-y="1.4" cx="307.82608695652175" cy="228.69565217391306" r="3" fill="hsl(319, 100%, 50%, 0.8)" />
+  </g>
+  <g>
+    <circle data-type="point" data-label="U1.2
+x-" data-x="-1.3" data-y="0.09999999999999998" cx="240.8695652173913" cy="307.82608695652175" r="3" fill="hsl(320, 100%, 50%, 0.8)" />
+  </g>
+  <g>
+    <circle data-type="point" data-label="U1.3
+x-" data-x="-1.3" data-y="-0.10000000000000009" cx="240.8695652173913" cy="320" r="3" fill="hsl(321, 100%, 50%, 0.8)" />
+  </g>
+  <g>
+    <circle data-type="point" data-label="U1.4
+x-" data-x="-1.3" data-y="-0.30000000000000004" cx="240.8695652173913" cy="332.17391304347825" r="3" fill="hsl(322, 100%, 50%, 0.8)" />
+  </g>
+  <g>
+    <circle data-type="point" data-label="U1.5
+x-" data-x="-1.3" data-y="-0.5" cx="240.8695652173913" cy="344.3478260869565" r="3" fill="hsl(323, 100%, 50%, 0.8)" />
+  </g>
+  <g>
+    <circle data-type="point" data-label="U1.7
+y-" data-x="0" data-y="-1.4" cx="320" cy="399.1304347826087" r="3" fill="hsl(325, 100%, 50%, 0.8)" />
+  </g>
+  <g>
+    <circle data-type="point" data-label="U1.8
+x-" data-x="-1.3" data-y="0.5" cx="240.8695652173913" cy="283.47826086956525" r="3" fill="hsl(326, 100%, 50%, 0.8)" />
+  </g>
+  <g>
+    <circle data-type="point" data-label="U1.10
+x+" data-x="1.3" data-y="-0.5" cx="399.1304347826087" cy="344.3478260869565" r="3" fill="hsl(217, 100%, 50%, 0.8)" />
+  </g>
+  <g>
+    <circle data-type="point" data-label="U1.11
+x+" data-x="1.3" data-y="-0.3" cx="399.1304347826087" cy="332.17391304347825" r="3" fill="hsl(218, 100%, 50%, 0.8)" />
+  </g>
+  <g>
+    <circle data-type="point" data-label="U1.12
+x+" data-x="1.3" data-y="-0.09999999999999998" cx="399.1304347826087" cy="320" r="3" fill="hsl(219, 100%, 50%, 0.8)" />
+  </g>
+  <g>
+    <circle data-type="point" data-label="U1.13
+x+" data-x="1.3" data-y="0.10000000000000009" cx="399.1304347826087" cy="307.82608695652175" r="3" fill="hsl(220, 100%, 50%, 0.8)" />
+  </g>
+  <g>
+    <circle data-type="point" data-label="U1.14
+y+" data-x="0.2" data-y="1.4" cx="332.17391304347825" cy="228.69565217391306" r="3" fill="hsl(221, 100%, 50%, 0.8)" />
+  </g>
+  <g>
+    <circle data-type="point" data-label="JP1.1
+x+" data-x="-3.4" data-y="-0.8999999999999999" cx="113.04347826086953" cy="368.69565217391306" r="3" fill="hsl(358, 100%, 50%, 0.8)" />
+  </g>
+  <g>
+    <circle data-type="point" data-label="JP1.2
+x+" data-x="-3.4" data-y="-0.7" cx="113.04347826086953" cy="356.5217391304348" r="3" fill="hsl(359, 100%, 50%, 0.8)" />
+  </g>
+  <g>
+    <circle data-type="point" data-label="JP1.3
+x+" data-x="-3.4" data-y="-0.49999999999999994" cx="113.04347826086953" cy="344.3478260869565" r="3" fill="hsl(0, 100%, 50%, 0.8)" />
+  </g>
+  <g>
+    <circle data-type="point" data-label="JP1.4
+x+" data-x="-3.4" data-y="-0.2999999999999999" cx="113.04347826086953" cy="332.17391304347825" r="3" fill="hsl(1, 100%, 50%, 0.8)" />
+  </g>
+  <g>
+    <circle data-type="point" data-label="JP1.5
+x+" data-x="-3.4" data-y="-0.09999999999999992" cx="113.04347826086953" cy="320" r="3" fill="hsl(2, 100%, 50%, 0.8)" />
+  </g>
+  <g>
+    <circle data-type="point" data-label="JP1.6
+x+" data-x="-3.4" data-y="0.10000000000000003" cx="113.04347826086953" cy="307.82608695652175" r="3" fill="hsl(3, 100%, 50%, 0.8)" />
+  </g>
+  <g>
+    <circle data-type="point" data-label="JP1.7
+x+" data-x="-3.4" data-y="0.3" cx="113.04347826086953" cy="295.6521739130435" r="3" fill="hsl(4, 100%, 50%, 0.8)" />
+  </g>
+  <g>
+    <circle data-type="point" data-label="JP2.1
+x-" data-x="3.4" data-y="-0.8999999999999999" cx="526.9565217391305" cy="368.69565217391306" r="3" fill="hsl(239, 100%, 50%, 0.8)" />
+  </g>
+  <g>
+    <circle data-type="point" data-label="JP2.2
+x-" data-x="3.4" data-y="-0.7" cx="526.9565217391305" cy="356.5217391304348" r="3" fill="hsl(240, 100%, 50%, 0.8)" />
+  </g>
+  <g>
+    <circle data-type="point" data-label="JP2.3
+x-" data-x="3.4" data-y="-0.5" cx="526.9565217391305" cy="344.3478260869565" r="3" fill="hsl(241, 100%, 50%, 0.8)" />
+  </g>
+  <g>
+    <circle data-type="point" data-label="JP2.4
+x-" data-x="3.4" data-y="-0.3000000000000001" cx="526.9565217391305" cy="332.17391304347825" r="3" fill="hsl(242, 100%, 50%, 0.8)" />
+  </g>
+  <g>
+    <circle data-type="point" data-label="JP2.5
+x-" data-x="3.4" data-y="-0.10000000000000003" cx="526.9565217391305" cy="320" r="3" fill="hsl(243, 100%, 50%, 0.8)" />
+  </g>
+  <g>
+    <circle data-type="point" data-label="JP2.6
+x-" data-x="3.4" data-y="0.09999999999999998" cx="526.9565217391305" cy="307.82608695652175" r="3" fill="hsl(244, 100%, 50%, 0.8)" />
+  </g>
+  <g>
+    <circle data-type="point" data-label="JP2.7
+x-" data-x="3.4" data-y="0.3" cx="526.9565217391305" cy="295.6521739130435" r="3" fill="hsl(245, 100%, 50%, 0.8)" />
+  </g>
+  <g>
+    <circle data-type="point" data-label="" data-x="-3.4" data-y="-0.09999999999999992" cx="113.04347826086953" cy="320" r="3" fill="red" />
+  </g>
+  <g>
+    <circle data-type="point" data-label="" data-x="-3.4" data-y="-0.09999999999999992" cx="113.04347826086953" cy="320" r="3" fill="red" />
+  </g>
+  <g>
+    <circle data-type="point" data-label="" data-x="-2.35" data-y="-0.1" cx="176.9565217391304" cy="320" r="3" fill="orange" />
+  </g>
+  <g>
+    <circle data-type="point" data-label="" data-x="-2.35" data-y="-0.1" cx="176.9565217391304" cy="320" r="3" fill="orange" />
+  </g>
+  <g>
+    <circle data-type="point" data-label="" data-x="-1.3" data-y="-0.10000000000000009" cx="240.8695652173913" cy="320" r="3" fill="red" />
+  </g>
+  <g>
+    <circle data-type="point" data-label="" data-x="-1.3" data-y="-0.10000000000000009" cx="240.8695652173913" cy="320" r="3" fill="red" />
+  </g>
+  <g>
+    <polyline data-points="-3.4,-0.8999999999999999 0,-1.4" data-type="line" data-label="" points="113.04347826086953,368.69565217391306 320,399.1304347826087" fill="none" stroke="hsl(336, 100%, 50%, 0.8)" stroke-width="1" />
+  </g>
+  <g>
+    <polyline data-points="-3.4,-0.49999999999999994 -1.3,-0.5" data-type="line" data-label="" points="113.04347826086953,344.3478260869565 240.8695652173913,344.3478260869565" fill="none" stroke="hsl(336, 100%, 50%, 0.8)" stroke-width="1" />
+  </g>
+  <g>
+    <polyline data-points="-3.4,-0.2999999999999999 -1.3,-0.30000000000000004" data-type="line" data-label="" points="113.04347826086953,332.17391304347825 240.8695652173913,332.17391304347825" fill="none" stroke="hsl(336, 100%, 50%, 0.8)" stroke-width="1" />
+  </g>
+  <g>
+    <polyline data-points="-3.4,-0.09999999999999992 -1.3,-0.10000000000000009" data-type="line" data-label="" points="113.04347826086953,320 240.8695652173913,320" fill="none" stroke="hsl(336, 100%, 50%, 0.8)" stroke-width="1" />
+  </g>
+  <g>
+    <polyline data-points="-3.4,0.10000000000000003 -1.3,0.09999999999999998" data-type="line" data-label="" points="113.04347826086953,307.82608695652175 240.8695652173913,307.82608695652175" fill="none" stroke="hsl(336, 100%, 50%, 0.8)" stroke-width="1" />
+  </g>
+  <g>
+    <polyline data-points="3.4,-0.5 1.3,-0.5" data-type="line" data-label="" points="526.9565217391305,344.3478260869565 399.1304347826087,344.3478260869565" fill="none" stroke="hsl(24, 100%, 50%, 0.8)" stroke-width="1" />
+  </g>
+  <g>
+    <polyline data-points="3.4,-0.3000000000000001 1.3,-0.3" data-type="line" data-label="" points="526.9565217391305,332.17391304347825 399.1304347826087,332.17391304347825" fill="none" stroke="hsl(24, 100%, 50%, 0.8)" stroke-width="1" />
+  </g>
+  <g>
+    <polyline data-points="3.4,-0.10000000000000003 1.3,-0.09999999999999998" data-type="line" data-label="" points="526.9565217391305,320 399.1304347826087,320" fill="none" stroke="hsl(24, 100%, 50%, 0.8)" stroke-width="1" />
+  </g>
+  <g>
+    <polyline data-points="3.4,0.09999999999999998 1.3,0.10000000000000009" data-type="line" data-label="" points="526.9565217391305,307.82608695652175 399.1304347826087,307.82608695652175" fill="none" stroke="hsl(24, 100%, 50%, 0.8)" stroke-width="1" />
+  </g>
+  <g>
+    <polyline data-points="-0.2,1.4 -3.4,-0.7" data-type="line" data-label="" points="307.82608695652175,228.69565217391306 113.04347826086953,356.5217391304348" fill="none" stroke="hsl(73, 100%, 50%, 0.8)" stroke-width="1" stroke-dasharray="4 2" />
+  </g>
+  <g>
+    <polyline data-points="0,-1.4 -3.4,-0.8999999999999999" data-type="line" data-label="" points="320,399.1304347826087 113.04347826086953,368.69565217391306" fill="none" stroke="hsl(157, 100%, 50%, 0.8)" stroke-width="1" stroke-dasharray="4 2" />
+  </g>
+  <g>
+    <polyline data-points="0,-1.4 3.4,-0.8999999999999999" data-type="line" data-label="" points="320,399.1304347826087 526.9565217391305,368.69565217391306" fill="none" stroke="hsl(157, 100%, 50%, 0.8)" stroke-width="1" stroke-dasharray="4 2" />
+  </g>
+  <g>
+    <polyline data-points="-3.4,-0.8999999999999999 3.4,-0.8999999999999999" data-type="line" data-label="" points="113.04347826086953,368.69565217391306 526.9565217391305,368.69565217391306" fill="none" stroke="hsl(157, 100%, 50%, 0.8)" stroke-width="1" stroke-dasharray="4 2" />
+  </g>
+  <g>
+    <polyline data-points="0.2,1.4 3.4,-0.7" data-type="line" data-label="" points="332.17391304347825,228.69565217391306 526.9565217391305,356.5217391304348" fill="none" stroke="hsl(199, 100%, 50%, 0.8)" stroke-width="1" stroke-dasharray="4 2" />
+  </g>
+  <g>
+    <polyline data-points="0,-1.4 0,-1.5999999999999999 -1.7,-1.5999999999999999 -1.7,-0.8999999999999999 -3.4,-0.8999999999999999" data-type="line" data-label="" points="320,399.1304347826087 320,411.304347826087 216.52173913043475,411.304347826087 216.52173913043475,368.69565217391306 113.04347826086953,368.69565217391306" fill="none" stroke="black" stroke-width="1" />
+  </g>
+  <g>
+    <polyline data-points="3.4,-0.8999999999999999 1.6999999999999997,-0.8999999999999999 1.6999999999999997,-1.5999999999999999 0,-1.5999999999999999 0,-1.4" data-type="line" data-label="" points="526.9565217391305,368.69565217391306 423.47826086956525,368.69565217391306 423.47826086956525,411.304347826087 320,411.304347826087 320,399.1304347826087" fill="none" stroke="black" stroke-width="1" />
+  </g>
+  <g>
+    <polyline data-points="-3.4,-0.49999999999999994 -1.3,-0.5" data-type="line" data-label="" points="113.04347826086953,344.3478260869565 240.8695652173913,344.3478260869565" fill="none" stroke="black" stroke-width="1" />
+  </g>
+  <g>
+    <polyline data-points="-3.4,-0.2999999999999999 -1.3,-0.30000000000000004" data-type="line" data-label="" points="113.04347826086953,332.17391304347825 240.8695652173913,332.17391304347825" fill="none" stroke="black" stroke-width="1" />
+  </g>
+  <g>
+    <polyline data-points="-3.4,-0.09999999999999992 -1.3,-0.10000000000000009" data-type="line" data-label="" points="113.04347826086953,320 240.8695652173913,320" fill="none" stroke="black" stroke-width="1" />
+  </g>
+  <g>
+    <polyline data-points="-3.4,0.10000000000000003 -1.3,0.09999999999999998" data-type="line" data-label="" points="113.04347826086953,307.82608695652175 240.8695652173913,307.82608695652175" fill="none" stroke="black" stroke-width="1" />
+  </g>
+  <g>
+    <polyline data-points="3.4,-0.5 1.3,-0.5" data-type="line" data-label="" points="526.9565217391305,344.3478260869565 399.1304347826087,344.3478260869565" fill="none" stroke="black" stroke-width="1" />
+  </g>
+  <g>
+    <polyline data-points="3.4,-0.3000000000000001 1.3,-0.3" data-type="line" data-label="" points="526.9565217391305,332.17391304347825 399.1304347826087,332.17391304347825" fill="none" stroke="black" stroke-width="1" />
+  </g>
+  <g>
+    <polyline data-points="3.4,-0.10000000000000003 1.3,-0.09999999999999998" data-type="line" data-label="" points="526.9565217391305,320 399.1304347826087,320" fill="none" stroke="black" stroke-width="1" />
+  </g>
+  <g>
+    <polyline data-points="3.4,0.09999999999999998 1.3,0.10000000000000009" data-type="line" data-label="" points="526.9565217391305,307.82608695652175 399.1304347826087,307.82608695652175" fill="none" stroke="black" stroke-width="1" />
+  </g>
+  <g>
+    <rect data-type="rect" data-label="schematic_component_0" data-x="0" data-y="0" x="240.8695652173913" y="228.69565217391306" width="158.26086956521738" height="170.43478260869563" fill="hsl(24, 100%, 50%, 0.8)" stroke="black" stroke-width="0.016428571428571428" />
+  </g>
+  <g>
+    <rect data-type="rect" data-label="schematic_component_1" data-x="-4" data-y="-0.3" x="40" y="283.47826086956525" width="73.04347826086953" height="97.39130434782606" fill="hsl(24, 100%, 50%, 0.8)" stroke="black" stroke-width="0.016428571428571428" />
+  </g>
+  <g>
+    <rect data-type="rect" data-label="schematic_component_2" data-x="4" data-y="-0.3" x="526.9565217391305" y="283.47826086956525" width="73.0434782608695" height="97.39130434782606" fill="hsl(24, 100%, 50%, 0.8)" stroke="black" stroke-width="0.016428571428571428" />
+  </g>
+  <g>
+    <rect data-type="rect" data-label="" data-x="-3.4" data-y="0.12510000000000007" x="106.95652173913041" y="292.6026086956522" width="12.17391304347828" height="27.391304347826065" fill="rgba(220, 0, 0, 0.25)" stroke="black" stroke-width="0.016428571428571428" />
+  </g>
+  <g>
+    <rect data-type="rect" data-label="" data-x="-3.4" data-y="-0.32509999999999994" x="106.95652173913041" y="320.00608695652176" width="12.17391304347828" height="27.391304347826065" fill="rgba(220, 0, 0, 0.25)" stroke="black" stroke-width="0.016428571428571428" />
+  </g>
+  <g>
+    <rect data-type="rect" data-label="" data-x="-2.35" data-y="0.1251" x="170.86956521739128" y="292.6026086956522" width="12.17391304347828" height="27.391304347826065" fill="rgba(220, 140, 0, 0.25)" stroke="black" stroke-width="0.016428571428571428" />
+  </g>
+  <g>
+    <rect data-type="rect" data-label="" data-x="-2.35" data-y="-0.3251" x="170.86956521739128" y="320.00608695652176" width="12.17391304347828" height="27.391304347826065" fill="rgba(220, 140, 0, 0.25)" stroke="black" stroke-width="0.016428571428571428" />
+  </g>
+  <g>
+    <rect data-type="rect" data-label="" data-x="-1.3" data-y="0.1250999999999999" x="234.78260869565216" y="292.6026086956522" width="12.17391304347828" height="27.39130434782612" fill="rgba(220, 0, 0, 0.25)" stroke="black" stroke-width="0.016428571428571428" />
+  </g>
+  <g>
+    <rect data-type="rect" data-label="" data-x="-1.3" data-y="-0.32510000000000006" x="234.78260869565216" y="320.00608695652176" width="12.17391304347828" height="27.391304347826065" fill="rgba(220, 0, 0, 0.25)" stroke="black" stroke-width="0.016428571428571428" />
+  </g>
+  <g id="crosshair" style="display: none">
+    <line id="crosshair-h" y1="0" y2="640" stroke="#666" stroke-width="0.5" />
+    <line id="crosshair-v" x1="0" x2="640" stroke="#666" stroke-width="0.5" /><text id="coordinates" font-family="monospace" font-size="12" fill="#666"></text>
+  </g>
+  <script>
+    <![CDATA[
+    document.currentScript.parentElement.addEventListener('mousemove', (e) => {
+      const svg = e.currentTarget;
+      const rect = svg.getBoundingClientRect();
+      const x = e.clientX - rect.left;
+      const y = e.clientY - rect.top;
+      const crosshair = svg.getElementById('crosshair');
+      const h = svg.getElementById('crosshair-h');
+      const v = svg.getElementById('crosshair-v');
+      const coords = svg.getElementById('coordinates');
+
+      crosshair.style.display = 'block';
+      h.setAttribute('x1', '0');
+      h.setAttribute('x2', '640');
+      h.setAttribute('y1', y);
+      h.setAttribute('y2', y);
+      v.setAttribute('x1', x);
+      v.setAttribute('x2', x);
+      v.setAttribute('y1', '0');
+      v.setAttribute('y2', '640');
+
+      // Calculate real coordinates using inverse transformation
+      const matrix = {
+        "a": 60.86956521739131,
+        "c": 0,
+        "e": 320,
+        "b": 0,
+        "d": -60.86956521739131,
+        "f": 313.9130434782609
+      };
+      // Manually invert and apply the affine transform
+      // Since we only use translate and scale, we can directly compute:
+      // x' = (x - tx) / sx
+      // y' = (y - ty) / sy
+      const sx = matrix.a;
+      const sy = matrix.d;
+      const tx = matrix.e;
+      const ty = matrix.f;
+      const realPoint = {
+        x: (x - tx) / sx,
+        y: (y - ty) / sy // Flip y back since we used negative scale
+      }
+
+      coords.textContent = `(${realPoint.x.toFixed(2)}, ${realPoint.y.toFixed(2)})`;
+      coords.setAttribute('x', (x + 5).toString());
+      coords.setAttribute('y', (y - 5).toString());
+    });
+    document.currentScript.parentElement.addEventListener('mouseleave', () => {
+      document.currentScript.parentElement.getElementById('crosshair').style.display = 'none';
+    });
+    ]]>
+  </script>
+</svg>

package/tests/examples/example27.test.ts

@@ -0,0 +1,241 @@
+import { test, expect } from "bun:test"
+import type { InputProblem } from "lib/index"
+import { SchematicTracePipelineSolver } from "lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver"
+import "tests/fixtures/matcher"
+
+const inputProblem: InputProblem = {
+  chips: [
+    {
+      chipId: "schematic_component_0",
+      center: {
+        x: 0,
+        y: 0,
+      },
+      width: 1.8,
+      height: 2,
+      pins: [
+        {
+          pinId: "U1.1",
+          x: -0.2,
+          y: 1.4,
+        },
+        {
+          pinId: "U1.2",
+          x: -1.3,
+          y: 0.09999999999999998,
+        },
+        {
+          pinId: "U1.3",
+          x: -1.3,
+          y: -0.10000000000000009,
+        },
+        {
+          pinId: "U1.4",
+          x: -1.3,
+          y: -0.30000000000000004,
+        },
+        {
+          pinId: "U1.5",
+          x: -1.3,
+          y: -0.5,
+        },
+        {
+          pinId: "U1.7",
+          x: 0,
+          y: -1.4,
+        },
+        {
+          pinId: "U1.8",
+          x: -1.3,
+          y: 0.5,
+        },
+        {
+          pinId: "U1.10",
+          x: 1.3,
+          y: -0.5,
+        },
+        {
+          pinId: "U1.11",
+          x: 1.3,
+          y: -0.3,
+        },
+        {
+          pinId: "U1.12",
+          x: 1.3,
+          y: -0.09999999999999998,
+        },
+        {
+          pinId: "U1.13",
+          x: 1.3,
+          y: 0.10000000000000009,
+        },
+        {
+          pinId: "U1.14",
+          x: 0.2,
+          y: 1.4,
+        },
+      ],
+    },
+    {
+      chipId: "schematic_component_1",
+      center: {
+        x: -4,
+        y: -0.3,
+      },
+      width: 0.4,
+      height: 1.6,
+      pins: [
+        {
+          pinId: "JP1.1",
+          x: -3.4,
+          y: -0.8999999999999999,
+        },
+        {
+          pinId: "JP1.2",
+          x: -3.4,
+          y: -0.7,
+        },
+        {
+          pinId: "JP1.3",
+          x: -3.4,
+          y: -0.49999999999999994,
+        },
+        {
+          pinId: "JP1.4",
+          x: -3.4,
+          y: -0.2999999999999999,
+        },
+        {
+          pinId: "JP1.5",
+          x: -3.4,
+          y: -0.09999999999999992,
+        },
+        {
+          pinId: "JP1.6",
+          x: -3.4,
+          y: 0.10000000000000003,
+        },
+        {
+          pinId: "JP1.7",
+          x: -3.4,
+          y: 0.3,
+        },
+      ],
+    },
+    {
+      chipId: "schematic_component_2",
+      center: {
+        x: 4,
+        y: -0.3,
+      },
+      width: 0.4,
+      height: 1.6,
+      pins: [
+        {
+          pinId: "JP2.1",
+          x: 3.4,
+          y: -0.8999999999999999,
+        },
+        {
+          pinId: "JP2.2",
+          x: 3.4,
+          y: -0.7,
+        },
+        {
+          pinId: "JP2.3",
+          x: 3.4,
+          y: -0.5,
+        },
+        {
+          pinId: "JP2.4",
+          x: 3.4,
+          y: -0.3000000000000001,
+        },
+        {
+          pinId: "JP2.5",
+          x: 3.4,
+          y: -0.10000000000000003,
+        },
+        {
+          pinId: "JP2.6",
+          x: 3.4,
+          y: 0.09999999999999998,
+        },
+        {
+          pinId: "JP2.7",
+          x: 3.4,
+          y: 0.3,
+        },
+      ],
+    },
+  ],
+  directConnections: [
+    {
+      pinIds: ["JP1.1", "U1.7"],
+      netId: "pinheader.JP1 > port.pin1 to .U1 > .pin7",
+    },
+    {
+      pinIds: ["JP1.3", "U1.5"],
+      netId: "pinheader.JP1 > port.pin3 to .U1 > .pin5",
+    },
+    {
+      pinIds: ["JP1.4", "U1.4"],
+      netId: "pinheader.JP1 > port.pin4 to .U1 > .pin4",
+    },
+    {
+      pinIds: ["JP1.5", "U1.3"],
+      netId: "pinheader.JP1 > port.pin5 to .U1 > .pin3",
+    },
+    {
+      pinIds: ["JP1.6", "U1.2"],
+      netId: "pinheader.JP1 > port.pin6 to .U1 > .pin2",
+    },
+    {
+      pinIds: ["JP2.3", "U1.10"],
+      netId: "pinheader.JP2 > port.pin3 to .U1 > .pin10",
+    },
+    {
+      pinIds: ["JP2.4", "U1.11"],
+      netId: "pinheader.JP2 > port.pin4 to .U1 > .pin11",
+    },
+    {
+      pinIds: ["JP2.5", "U1.12"],
+      netId: "pinheader.JP2 > port.pin5 to .U1 > .pin12",
+    },
+    {
+      pinIds: ["JP2.6", "U1.13"],
+      netId: "pinheader.JP2 > port.pin6 to .U1 > .pin13",
+    },
+  ],
+  netConnections: [
+    {
+      netId: "V3_3",
+      pinIds: ["U1.1", "JP1.2"],
+      netLabelWidth: 0.4,
+    },
+    {
+      netId: "GND",
+      pinIds: ["U1.7", "JP1.1", "JP2.1"],
+      netLabelWidth: 0.3,
+    },
+    {
+      netId: "V5",
+      pinIds: ["U1.14", "JP2.2"],
+      netLabelWidth: 0.2,
+    },
+  ],
+  availableNetLabelOrientations: {
+    V3_3: ["y+"],
+    V5: ["y+"],
+    GND: ["y-"],
+  },
+  maxMspPairDistance: 5,
+}
+
+test("example01", () => {
+  const solver = new SchematicTracePipelineSolver(inputProblem)
+
+  solver.solve()
+
+  expect(solver).toMatchSolverSnapshot(import.meta.path)
+})