@tscircuit/schematic-trace-solver 0.0.41 → 0.0.42

package/lib/solvers/TraceLabelOverlapAvoidanceSolver/{minimizeTurnsWithFilteredLabels.ts → sub-solvers/TraceCleanupSolver/minimizeTurnsWithFilteredLabels.ts}

@@ -1,24 +1,24 @@
 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 type { NetLabelPlacement } from "../../../NetLabelPlacementSolver/NetLabelPlacementSolver"
 import { minimizeTurns } from "./turnMinimization"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import { getObstacleRects } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/rect"
 
 export const minimizeTurnsWithFilteredLabels = ({
   traces,
-  problem,
+  inputProblem,
   allLabelPlacements,
   mergedLabelNetIdMap,
   paddingBuffer,
 }: {
   traces: SolvedTracePath[]
-  problem: InputProblem
+  inputProblem: InputProblem
   allLabelPlacements: NetLabelPlacement[]
   mergedLabelNetIdMap: Record<string, Set<string>>
   paddingBuffer: number
 }): SolvedTracePath[] | null => {
   let changesMade = false
-  const obstacles = getObstacleRects(problem)
+  const obstacles = getObstacleRects(inputProblem)
 
   const newTraces = traces.map((trace) => {
     const originalPath = trace.tracePath

package/lib/solvers/TraceLabelOverlapAvoidanceSolver/{simplifyPath.ts → sub-solvers/TraceCleanupSolver/simplifyPath.ts}

@@ -2,7 +2,7 @@ import type { Point } from "graphics-debug"
 import {
   isHorizontal,
   isVertical,
-} from "../SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions"
+} from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions"
 
 export const simplifyPath = (path: Point[]): Point[] => {
   if (path.length < 3) return path

package/lib/solvers/TraceLabelOverlapAvoidanceSolver/{turnMinimization.ts → sub-solvers/TraceCleanupSolver/turnMinimization.ts}

@@ -105,8 +105,6 @@ export const minimizeTurns = ({
 
           if (!collidesWithObstacles && !collidesWithLabels) {
             const newTurns = countTurns(testPath)
-            const turnsRemoved = stairEndIdx - startIdx - 1
-
             optimizedPath = testPath
             currentTurns = newTurns
             improved = true

package/lib/solvers/TraceLabelOverlapAvoidanceSolver/tryFourPointDetour.ts

@@ -0,0 +1,104 @@
+import type { Point } from "graphics-debug"
+import type { NetLabelPlacement } from "../NetLabelPlacementSolver/NetLabelPlacementSolver"
+import { getRectBounds } from "../NetLabelPlacementSolver/SingleNetLabelPlacementSolver/geometry"
+import type { SolvedTracePath } from "../SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import {
+  segmentIntersectsRect,
+  isVertical,
+} from "../SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions"
+
+export const generateFourPointDetourCandidates = ({
+  initialTrace,
+  label,
+  labelBounds,
+  paddingBuffer,
+  detourCount,
+}: {
+  initialTrace: SolvedTracePath
+  label: NetLabelPlacement
+  labelBounds: any
+  paddingBuffer: number
+  detourCount: number
+}): Point[][] => {
+  let collidingSegIndex = -1
+  for (let i = 0; i < initialTrace.tracePath.length - 1; i++) {
+    if (
+      segmentIntersectsRect(
+        initialTrace.tracePath[i],
+        initialTrace.tracePath[i + 1],
+        labelBounds,
+      )
+    ) {
+      collidingSegIndex = i
+      break
+    }
+  }
+
+  if (collidingSegIndex === -1) return []
+
+  const pA = initialTrace.tracePath[collidingSegIndex]
+  const pB = initialTrace.tracePath[collidingSegIndex + 1]
+
+  if (!pA || !pB) return []
+
+  const candidateDetours: Point[][] = []
+  const paddedLabelBounds = getRectBounds(
+    label.center,
+    label.width,
+    label.height,
+  )
+
+  const effectivePadding = paddingBuffer + detourCount * paddingBuffer
+
+  if (isVertical(pA, pB)) {
+    const xCandidates = [
+      paddedLabelBounds.maxX + effectivePadding,
+      paddedLabelBounds.minX - effectivePadding,
+    ]
+    for (const newX of xCandidates) {
+      candidateDetours.push(
+        pB.y > pA.y
+          ? [
+              { x: pA.x, y: paddedLabelBounds.minY - effectivePadding },
+              { x: newX, y: paddedLabelBounds.minY - effectivePadding },
+              { x: newX, y: paddedLabelBounds.maxY + effectivePadding },
+              { x: pB.x, y: paddedLabelBounds.maxY + effectivePadding },
+            ]
+          : [
+              { x: pA.x, y: paddedLabelBounds.maxY + effectivePadding },
+              { x: newX, y: paddedLabelBounds.maxY + effectivePadding },
+              { x: newX, y: paddedLabelBounds.minY - effectivePadding },
+              { x: pB.x, y: paddedLabelBounds.minY - effectivePadding },
+            ],
+      )
+    }
+  } else {
+    const yCandidates = [
+      paddedLabelBounds.maxY + effectivePadding,
+      paddedLabelBounds.minY - effectivePadding,
+    ]
+    for (const newY of yCandidates) {
+      candidateDetours.push(
+        pB.x > pA.x
+          ? [
+              { x: paddedLabelBounds.minX - effectivePadding, y: pA.y },
+              { x: paddedLabelBounds.minX - effectivePadding, y: newY },
+              { x: paddedLabelBounds.maxX + effectivePadding, y: newY },
+              { x: paddedLabelBounds.maxX + effectivePadding, y: pB.y },
+            ]
+          : [
+              { x: paddedLabelBounds.maxX + effectivePadding, y: pA.y },
+              { x: paddedLabelBounds.maxX + effectivePadding, y: newY },
+              { x: paddedLabelBounds.minX - effectivePadding, y: newY },
+              { x: paddedLabelBounds.minX - effectivePadding, y: pB.y },
+            ],
+      )
+    }
+  }
+
+  return candidateDetours.map((detourPoints) => [
+    ...initialTrace.tracePath.slice(0, collidingSegIndex + 1),
+    ...detourPoints,
+    ...initialTrace.tracePath.slice(collidingSegIndex + 1),
+  ])
+}

package/lib/solvers/TraceLabelOverlapAvoidanceSolver/trySnipAndReconnect.ts

@@ -1,32 +1,26 @@
 import type { Point } from "@tscircuit/math-utils"
-import { getRectBounds } from "../NetLabelPlacementSolver/SingleNetLabelPlacementSolver/geometry"
 import type { SolvedTracePath } from "../SchematicTraceLinesSolver/SchematicTraceLinesSolver"
-import {
-  isPathCollidingWithObstacles,
-  isVertical,
-  segmentIntersectsRect,
-} from "../SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions"
-import type { NetLabelPlacement } from "../NetLabelPlacementSolver/NetLabelPlacementSolver"
-import { simplifyPath } from "./simplifyPath"
 
-export const trySnipAndReconnect = ({
+export const generateSnipAndReconnectCandidates = ({
   initialTrace,
   firstInsideIndex,
   lastInsideIndex,
   labelBounds,
-  obstacles,
+  paddingBuffer,
+  detourCount,
 }: {
   initialTrace: SolvedTracePath
   firstInsideIndex: number
   lastInsideIndex: number
   labelBounds: any
-  obstacles: any[]
-}): SolvedTracePath | null => {
+  paddingBuffer: number
+  detourCount: number
+}): Point[][] => {
   if (
     firstInsideIndex <= 0 ||
     lastInsideIndex >= initialTrace.tracePath.length - 1
   ) {
-    return null
+    return []
   }
 
   const entryPoint = initialTrace.tracePath[firstInsideIndex - 1]
@@ -35,32 +29,19 @@ export const trySnipAndReconnect = ({
   const pathToEntry = initialTrace.tracePath.slice(0, firstInsideIndex)
   const pathFromExit = initialTrace.tracePath.slice(lastInsideIndex + 1)
 
-  const candidateDetours: Point[][] = []
+  const allCandidateDetours: Point[][] = []
 
+  // Candidate type 1: simple elbow
   if (entryPoint.x !== exitPoint.x && entryPoint.y !== exitPoint.y) {
-    candidateDetours.push([{ x: exitPoint.x, y: entryPoint.y }])
-    candidateDetours.push([{ x: entryPoint.x, y: exitPoint.y }])
+    allCandidateDetours.push([{ x: exitPoint.x, y: entryPoint.y }])
+    allCandidateDetours.push([{ x: entryPoint.x, y: exitPoint.y }])
   } else if (entryPoint.x === exitPoint.x || entryPoint.y === exitPoint.y) {
-    const newPath = [...pathToEntry, ...pathFromExit]
-    const simplified = simplifyPath(newPath)
-    if (!isPathCollidingWithObstacles(simplified, obstacles)) {
-      return { ...initialTrace, tracePath: simplified }
-    }
+    // Candidate type 2: direct connection (if points are aligned)
+    allCandidateDetours.push([]) // No detour points needed
   }
 
-  for (let i = 0; i < candidateDetours.length; i++) {
-    const detour = candidateDetours[i]
-    const newFullPath = [...pathToEntry, ...detour, ...pathFromExit]
-    const simplified = simplifyPath(newFullPath)
-
-    if (!isPathCollidingWithObstacles(simplified, obstacles)) {
-      return { ...initialTrace, tracePath: simplified }
-    }
-  }
-
-  candidateDetours.length = 0
-
-  const buffer = 0.1
+  // Candidate type 3: routing around the label bounds
+  const buffer = paddingBuffer + detourCount * paddingBuffer
   const leftX = labelBounds.minX - buffer
   const rightX = labelBounds.maxX + buffer
   const topY = labelBounds.maxY + buffer
@@ -71,7 +52,7 @@ export const trySnipAndReconnect = ({
     entryPoint.x < labelBounds.maxX &&
     exitPoint.x < labelBounds.maxX
   ) {
-    candidateDetours.push([
+    allCandidateDetours.push([
       { x: leftX, y: entryPoint.y },
       { x: leftX, y: exitPoint.y },
     ])
@@ -82,7 +63,7 @@ export const trySnipAndReconnect = ({
     entryPoint.x > labelBounds.minX &&
     exitPoint.x > labelBounds.minX
   ) {
-    candidateDetours.push([
+    allCandidateDetours.push([
       { x: rightX, y: entryPoint.y },
       { x: rightX, y: exitPoint.y },
     ])
@@ -93,7 +74,7 @@ export const trySnipAndReconnect = ({
     entryPoint.y > labelBounds.minY &&
     exitPoint.y > labelBounds.minY
   ) {
-    candidateDetours.push([
+    allCandidateDetours.push([
       { x: entryPoint.x, y: topY },
       { x: exitPoint.x, y: topY },
     ])
@@ -104,126 +85,15 @@ export const trySnipAndReconnect = ({
     entryPoint.y < labelBounds.maxY &&
     exitPoint.y < labelBounds.maxY
   ) {
-    candidateDetours.push([
+    allCandidateDetours.push([
       { x: entryPoint.x, y: bottomY },
       { x: exitPoint.x, y: bottomY },
     ])
   }
 
-  for (let i = 0; i < candidateDetours.length; i++) {
-    const detour = candidateDetours[i]
-    const newFullPath = [...pathToEntry, ...detour, ...pathFromExit]
-    const simplified = simplifyPath(newFullPath)
-
-    if (!isPathCollidingWithObstacles(simplified, obstacles)) {
-      return { ...initialTrace, tracePath: simplified }
-    }
-  }
-
-  return null
-}
-
-export const tryFourPointDetour = ({
-  initialTrace,
-  label,
-  labelBounds,
-  obstacles,
-  paddingBuffer,
-  detourCount,
-}: {
-  initialTrace: SolvedTracePath
-  label: NetLabelPlacement
-  labelBounds: any
-  obstacles: any[]
-  paddingBuffer: number
-  detourCount: number
-}): SolvedTracePath | null => {
-  let collidingSegIndex = -1
-  for (let i = 0; i < initialTrace.tracePath.length - 1; i++) {
-    if (
-      segmentIntersectsRect(
-        initialTrace.tracePath[i],
-        initialTrace.tracePath[i + 1],
-        labelBounds,
-      )
-    ) {
-      collidingSegIndex = i
-      break
-    }
-  }
-
-  if (collidingSegIndex === -1) return initialTrace
-
-  const pA = initialTrace.tracePath[collidingSegIndex]
-  const pB = initialTrace.tracePath[collidingSegIndex + 1]
-
-  if (!pA || !pB) return null
-
-  const candidateDetours: Point[][] = []
-  const paddedLabelBounds = getRectBounds(
-    label.center,
-    label.width,
-    label.height,
-  )
-
-  const effectivePadding = paddingBuffer + detourCount * paddingBuffer
-
-  if (isVertical(pA, pB)) {
-    const xCandidates = [
-      paddedLabelBounds.maxX + effectivePadding,
-      paddedLabelBounds.minX - effectivePadding,
-    ]
-    for (const newX of xCandidates) {
-      candidateDetours.push(
-        pB.y > pA.y
-          ? [
-              { x: pA.x, y: paddedLabelBounds.minY - effectivePadding },
-              { x: newX, y: paddedLabelBounds.minY - effectivePadding },
-              { x: newX, y: paddedLabelBounds.maxY + effectivePadding },
-              { x: pB.x, y: paddedLabelBounds.maxY + effectivePadding },
-            ]
-          : [
-              { x: pA.x, y: paddedLabelBounds.maxY + effectivePadding },
-              { x: newX, y: paddedLabelBounds.maxY + effectivePadding },
-              { x: newX, y: paddedLabelBounds.minY - effectivePadding },
-              { x: pB.x, y: paddedLabelBounds.minY - effectivePadding },
-            ],
-      )
-    }
-  } else {
-    const yCandidates = [
-      paddedLabelBounds.maxY + effectivePadding,
-      paddedLabelBounds.minY - effectivePadding,
-    ]
-    for (const newY of yCandidates) {
-      candidateDetours.push(
-        pB.x > pA.x
-          ? [
-              { x: paddedLabelBounds.minX - effectivePadding, y: pA.y },
-              { x: paddedLabelBounds.minX - effectivePadding, y: newY },
-              { x: paddedLabelBounds.maxX + effectivePadding, y: newY },
-              { x: paddedLabelBounds.maxX + effectivePadding, y: pB.y },
-            ]
-          : [
-              { x: paddedLabelBounds.maxX + effectivePadding, y: pA.y },
-              { x: paddedLabelBounds.maxX + effectivePadding, y: newY },
-              { x: paddedLabelBounds.minX - effectivePadding, y: newY },
-              { x: paddedLabelBounds.minX - effectivePadding, y: pB.y },
-            ],
-      )
-    }
-  }
-
-  for (const detourPoints of candidateDetours) {
-    const finalPath = [
-      ...initialTrace.tracePath.slice(0, collidingSegIndex + 1),
-      ...detourPoints,
-      ...initialTrace.tracePath.slice(collidingSegIndex + 1),
-    ]
-    const simplifiedFinalPath = simplifyPath(finalPath)
-    if (!isPathCollidingWithObstacles(simplifiedFinalPath, obstacles)) {
-      return { ...initialTrace, tracePath: simplifiedFinalPath }
-    }
-  }
-  return null
+  return allCandidateDetours.map((detour) => [
+    ...pathToEntry,
+    ...detour,
+    ...pathFromExit,
+  ])
 }

package/package.json

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