@tscircuit/schematic-trace-solver 0.0.37 → 0.0.39

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/index.ts

@@ -0,0 +1 @@
+export * from "./TraceLabelOverlapAvoidanceSolver"

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/rerouteCollidingTrace.ts

@@ -0,0 +1,73 @@
+import type { SolvedTracePath } from "../SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import type { NetLabelPlacement } from "../NetLabelPlacementSolver/NetLabelPlacementSolver"
+import { getRectBounds } from "../NetLabelPlacementSolver/SingleNetLabelPlacementSolver/geometry"
+import { getObstacleRects } from "../SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/rect"
+import type { InputProblem } from "lib/types/InputProblem"
+import { findTraceViolationZone } from "./violation"
+import { tryFourPointDetour, trySnipAndReconnect } from "./trySnipAndReconnect"
+import { simplifyPath } from "./simplifyPath"
+
+export const rerouteCollidingTrace = ({
+  trace,
+  label,
+  problem,
+  paddingBuffer,
+  detourCount,
+}: {
+  trace: SolvedTracePath
+  label: NetLabelPlacement
+  problem: InputProblem
+  paddingBuffer: number
+  detourCount: number
+}): SolvedTracePath => {
+  const initialTrace = { ...trace, tracePath: simplifyPath(trace.tracePath) }
+
+  if (trace.globalConnNetId === label.globalConnNetId) {
+    return initialTrace
+  }
+
+  const obstacles = getObstacleRects(problem)
+  const labelPadding = paddingBuffer
+  const labelBoundsRaw = getRectBounds(label.center, label.width, label.height)
+  const labelBounds = {
+    minX: labelBoundsRaw.minX - labelPadding,
+    minY: labelBoundsRaw.minY - labelPadding,
+    maxX: labelBoundsRaw.maxX + labelPadding,
+    maxY: labelBoundsRaw.maxY + labelPadding,
+    chipId: `netlabel-${label.netId}`,
+  }
+
+  const fourPointResult = tryFourPointDetour({
+    initialTrace,
+    label,
+    labelBounds,
+    obstacles,
+    paddingBuffer,
+    detourCount,
+  })
+  if (fourPointResult) {
+    initialTrace.tracePath = fourPointResult.tracePath
+  }
+  const { firstInsideIndex, lastInsideIndex } = findTraceViolationZone(
+    initialTrace.tracePath,
+    labelBounds,
+  )
+
+  const snipReconnectResult = trySnipAndReconnect({
+    initialTrace,
+    firstInsideIndex,
+    lastInsideIndex,
+    labelBounds,
+    obstacles,
+  })
+
+  if (snipReconnectResult) {
+    return snipReconnectResult
+  }
+
+  if (fourPointResult) {
+    return fourPointResult
+  }
+
+  return initialTrace
+}

package/lib/solvers/TraceLabelOverlapAvoidanceSolver/simplifyPath.ts

@@ -0,0 +1,41 @@
+import type { Point } from "graphics-debug"
+import {
+  isHorizontal,
+  isVertical,
+} from "../SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions"
+
+export const simplifyPath = (path: Point[]): Point[] => {
+  if (path.length < 3) return path
+  const newPath: Point[] = [path[0]]
+  for (let i = 1; i < path.length - 1; i++) {
+    const p1 = newPath[newPath.length - 1]
+    const p2 = path[i]
+    const p3 = path[i + 1]
+    if (
+      (isVertical(p1, p2) && isVertical(p2, p3)) ||
+      (isHorizontal(p1, p2) && isHorizontal(p2, p3))
+    ) {
+      continue
+    }
+    newPath.push(p2)
+  }
+  newPath.push(path[path.length - 1])
+
+  if (newPath.length < 3) return newPath
+  const finalPath: Point[] = [newPath[0]]
+  for (let i = 1; i < newPath.length - 1; i++) {
+    const p1 = finalPath[finalPath.length - 1]
+    const p2 = newPath[i]
+    const p3 = newPath[i + 1]
+    if (
+      (isVertical(p1, p2) && isVertical(p2, p3)) ||
+      (isHorizontal(p1, p2) && isHorizontal(p2, p3))
+    ) {
+      continue
+    }
+    finalPath.push(p2)
+  }
+  finalPath.push(newPath[newPath.length - 1])
+
+  return finalPath
+}

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/trySnipAndReconnect.ts

@@ -0,0 +1,229 @@
+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 = ({
+  initialTrace,
+  firstInsideIndex,
+  lastInsideIndex,
+  labelBounds,
+  obstacles,
+}: {
+  initialTrace: SolvedTracePath
+  firstInsideIndex: number
+  lastInsideIndex: number
+  labelBounds: any
+  obstacles: any[]
+}): SolvedTracePath | null => {
+  if (
+    firstInsideIndex <= 0 ||
+    lastInsideIndex >= initialTrace.tracePath.length - 1
+  ) {
+    return null
+  }
+
+  const entryPoint = initialTrace.tracePath[firstInsideIndex - 1]
+  const exitPoint = initialTrace.tracePath[lastInsideIndex + 1]
+
+  const pathToEntry = initialTrace.tracePath.slice(0, firstInsideIndex)
+  const pathFromExit = initialTrace.tracePath.slice(lastInsideIndex + 1)
+
+  const candidateDetours: Point[][] = []
+
+  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 }])
+  } 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 }
+    }
+  }
+
+  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
+  const leftX = labelBounds.minX - buffer
+  const rightX = labelBounds.maxX + buffer
+  const topY = labelBounds.maxY + buffer
+  const bottomY = labelBounds.minY - buffer
+
+  if (
+    (entryPoint.x <= labelBounds.minX || exitPoint.x <= labelBounds.minX) &&
+    entryPoint.x < labelBounds.maxX &&
+    exitPoint.x < labelBounds.maxX
+  ) {
+    candidateDetours.push([
+      { x: leftX, y: entryPoint.y },
+      { x: leftX, y: exitPoint.y },
+    ])
+  }
+
+  if (
+    (entryPoint.x >= labelBounds.maxX || exitPoint.x >= labelBounds.maxX) &&
+    entryPoint.x > labelBounds.minX &&
+    exitPoint.x > labelBounds.minX
+  ) {
+    candidateDetours.push([
+      { x: rightX, y: entryPoint.y },
+      { x: rightX, y: exitPoint.y },
+    ])
+  }
+
+  if (
+    (entryPoint.y >= labelBounds.maxY || exitPoint.y >= labelBounds.maxY) &&
+    entryPoint.y > labelBounds.minY &&
+    exitPoint.y > labelBounds.minY
+  ) {
+    candidateDetours.push([
+      { x: entryPoint.x, y: topY },
+      { x: exitPoint.x, y: topY },
+    ])
+  }
+
+  if (
+    (entryPoint.y <= labelBounds.minY || exitPoint.y <= labelBounds.minY) &&
+    entryPoint.y < labelBounds.maxY &&
+    exitPoint.y < labelBounds.maxY
+  ) {
+    candidateDetours.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
+}

package/lib/solvers/TraceLabelOverlapAvoidanceSolver/turnMinimization.ts

@@ -0,0 +1,211 @@
+import type { Point } from "graphics-debug"
+import { hasCollisions } from "./hasCollisions"
+import { countTurns } from "./countTurns"
+import { simplifyPath } from "./simplifyPath"
+import { tryConnectPoints } from "./tryConnectPoints"
+import { hasCollisionsWithLabels } from "./hasCollisionsWithLabels"
+
+export const minimizeTurns = ({
+  path,
+  obstacles,
+  labelBounds,
+}: {
+  path: Point[]
+  obstacles: any[]
+  labelBounds: any[]
+}): Point[] => {
+  if (path.length <= 2) {
+    return path
+  }
+
+  const recognizeStairStepPattern = (
+    pathToCheck: Point[],
+    startIdx: number,
+  ): number => {
+    if (startIdx >= pathToCheck.length - 3) return -1
+
+    let endIdx = startIdx
+    let isStairStep = true
+
+    for (
+      let i = startIdx;
+      i < pathToCheck.length - 2 && i < startIdx + 10;
+      i++
+    ) {
+      if (i + 2 >= pathToCheck.length) break
+
+      const p1 = pathToCheck[i]
+      const p2 = pathToCheck[i + 1]
+      const p3 = pathToCheck[i + 2]
+
+      const seg1Vertical = p1.x === p2.x
+      const seg2Vertical = p2.x === p3.x
+
+      if (seg1Vertical === seg2Vertical) {
+        break
+      }
+
+      const seg1Direction = seg1Vertical
+        ? Math.sign(p2.y - p1.y)
+        : Math.sign(p2.x - p1.x)
+
+      if (i > startIdx) {
+        const prevP = pathToCheck[i - 1]
+        const prevSegVertical = prevP.x === p1.x
+        const prevDirection = prevSegVertical
+          ? Math.sign(p1.y - prevP.y)
+          : Math.sign(p1.x - prevP.x)
+
+        if (
+          (seg1Vertical &&
+            prevSegVertical &&
+            seg1Direction !== prevDirection) ||
+          (!seg1Vertical && !prevSegVertical && seg1Direction !== prevDirection)
+        ) {
+          isStairStep = false
+          break
+        }
+      }
+
+      endIdx = i + 2
+    }
+
+    return isStairStep && endIdx - startIdx >= 3 ? endIdx : -1
+  }
+
+  let optimizedPath = [...path]
+  let currentTurns = countTurns(optimizedPath)
+  let improved = true
+
+  while (improved) {
+    improved = false
+
+    // First try to identify and replace stair-step patterns
+    for (let startIdx = 0; startIdx < optimizedPath.length - 3; startIdx++) {
+      const stairEndIdx = recognizeStairStepPattern(optimizedPath, startIdx)
+
+      if (stairEndIdx > 0) {
+        const startPoint = optimizedPath[startIdx]
+        const endPoint = optimizedPath[stairEndIdx]
+
+        const connectionOptions = tryConnectPoints(startPoint, endPoint)
+
+        for (const connection of connectionOptions) {
+          const testPath = [
+            ...optimizedPath.slice(0, startIdx + 1),
+            ...connection.slice(1, -1),
+            ...optimizedPath.slice(stairEndIdx),
+          ]
+
+          const collidesWithObstacles = hasCollisions(connection, obstacles)
+          const collidesWithLabels = hasCollisionsWithLabels(
+            connection,
+            labelBounds,
+          )
+
+          if (!collidesWithObstacles && !collidesWithLabels) {
+            const newTurns = countTurns(testPath)
+            const turnsRemoved = stairEndIdx - startIdx - 1
+
+            optimizedPath = testPath
+            currentTurns = newTurns
+            improved = true
+            break
+          }
+        }
+
+        if (improved) break
+      }
+    }
+
+    // If no stair-step optimization worked, try regular point removal
+    if (!improved) {
+      for (let startIdx = 0; startIdx < optimizedPath.length - 2; startIdx++) {
+        const maxRemove = Math.min(
+          optimizedPath.length - startIdx - 2,
+          optimizedPath.length - 2,
+        )
+
+        for (let removeCount = 1; removeCount <= maxRemove; removeCount++) {
+          const endIdx = startIdx + removeCount + 1
+
+          if (endIdx >= optimizedPath.length) continue
+
+          const startPoint = optimizedPath[startIdx]
+          const endPoint = optimizedPath[endIdx]
+
+          const connectionOptions = tryConnectPoints(startPoint, endPoint)
+
+          for (const connection of connectionOptions) {
+            const testPath = [
+              ...optimizedPath.slice(0, startIdx + 1),
+              ...connection.slice(1, -1),
+              ...optimizedPath.slice(endIdx),
+            ]
+
+            const connectionSegments = connection
+            const collidesWithObstacles = hasCollisions(
+              connectionSegments,
+              obstacles,
+            )
+            const collidesWithLabels = hasCollisionsWithLabels(
+              connectionSegments,
+              labelBounds,
+            )
+
+            if (!collidesWithObstacles && !collidesWithLabels) {
+              const newTurns = countTurns(testPath)
+
+              if (
+                newTurns < currentTurns ||
+                (newTurns === currentTurns &&
+                  testPath.length < optimizedPath.length)
+              ) {
+                optimizedPath = testPath
+                currentTurns = newTurns
+                improved = true
+                break
+              }
+            }
+          }
+
+          if (improved) break
+        }
+        if (improved) break
+      }
+    }
+
+    if (!improved) {
+      for (let i = 0; i < optimizedPath.length - 2; i++) {
+        const p1 = optimizedPath[i]
+        const p2 = optimizedPath[i + 1]
+        const p3 = optimizedPath[i + 2]
+
+        const allVertical = p1.x === p2.x && p2.x === p3.x
+        const allHorizontal = p1.y === p2.y && p2.y === p3.y
+
+        if (allVertical || allHorizontal) {
+          const testPath = [
+            ...optimizedPath.slice(0, i + 1),
+            ...optimizedPath.slice(i + 2),
+          ]
+
+          const collidesWithObstacles = hasCollisions([p1, p3], obstacles)
+          const collidesWithLabels = hasCollisionsWithLabels(
+            [p1, p3],
+            labelBounds,
+          )
+
+          if (!collidesWithObstacles && !collidesWithLabels) {
+            optimizedPath = testPath
+            improved = true
+            break
+          }
+        }
+      }
+    }
+  }
+
+  const finalSimplifiedPath = simplifyPath(optimizedPath)
+  return finalSimplifiedPath
+}

package/lib/solvers/TraceLabelOverlapAvoidanceSolver/violation.ts

@@ -0,0 +1,25 @@
+import type { Point } from "@tscircuit/math-utils"
+
+export const findTraceViolationZone = (
+  path: Point[],
+  labelBounds: { minX: number; maxX: number; minY: number; maxY: number },
+) => {
+  const isPointInside = (p: Point) =>
+    p.x > labelBounds.minX &&
+    p.x < labelBounds.maxX &&
+    p.y > labelBounds.minY &&
+    p.y < labelBounds.maxY
+
+  let firstInsideIndex = -1
+  let lastInsideIndex = -1
+
+  for (let i = 0; i < path.length; i++) {
+    if (isPointInside(path[i])) {
+      if (firstInsideIndex === -1) {
+        firstInsideIndex = i
+      }
+      lastInsideIndex = i
+    }
+  }
+  return { firstInsideIndex, lastInsideIndex }
+}

package/package.json

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