@tscircuit/schematic-trace-solver 0.0.48 → 0.0.50

package/lib/solvers/Example28Solver/geometry.ts

@@ -0,0 +1,246 @@
+import type { Point } from "@tscircuit/math-utils"
+import { segmentIntersectsRect } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions"
+import type { ChipObstacle, PathSegment, SegmentOrientation } from "./types"
+import { EPS } from "./types"
+
+export const getPathKey = (path: Point[]) =>
+  path.map((point) => `${point.x},${point.y}`).join(";")
+
+export const getPathLength = (path: Point[]) => {
+  let length = 0
+  for (let i = 0; i < path.length - 1; i++) {
+    length +=
+      Math.abs(path[i + 1]!.x - path[i]!.x) +
+      Math.abs(path[i + 1]!.y - path[i]!.y)
+  }
+  return length
+}
+
+export const getDistance = (a: Point, b: Point) =>
+  Math.abs(a.x - b.x) + Math.abs(a.y - b.y)
+
+export const isAxisAlignedSegment = (start: Point, end: Point) =>
+  Math.abs(start.x - end.x) < EPS || Math.abs(start.y - end.y) < EPS
+
+export const getSegmentOrientation = (
+  start: Point,
+  end: Point,
+): SegmentOrientation =>
+  Math.abs(start.y - end.y) < EPS ? "horizontal" : "vertical"
+
+export const projectPointToSegment = (
+  point: Point,
+  start: Point,
+  end: Point,
+): Point => {
+  if (Math.abs(start.x - end.x) < EPS) {
+    return {
+      x: start.x,
+      y: Math.min(
+        Math.max(point.y, Math.min(start.y, end.y)),
+        Math.max(start.y, end.y),
+      ),
+    }
+  }
+
+  if (Math.abs(start.y - end.y) < EPS) {
+    return {
+      x: Math.min(
+        Math.max(point.x, Math.min(start.x, end.x)),
+        Math.max(start.x, end.x),
+      ),
+      y: start.y,
+    }
+  }
+
+  return start
+}
+
+export const getPointToSegmentDistance = (
+  point: Point,
+  start: Point,
+  end: Point,
+) => getDistance(point, projectPointToSegment(point, start, end))
+
+export const getSegments = (path: Point[]) => {
+  const segments: PathSegment[] = []
+
+  for (let i = 0; i < path.length - 1; i++) {
+    const start = path[i]!
+    const end = path[i + 1]!
+    if (!isAxisAlignedSegment(start, end)) continue
+    segments.push({
+      start,
+      end,
+      orientation: getSegmentOrientation(start, end),
+    })
+  }
+
+  return segments
+}
+
+export const findSegmentContainingPoint = (path: Point[], point: Point) => {
+  for (let i = 0; i < path.length - 1; i++) {
+    const start = path[i]!
+    const end = path[i + 1]!
+    if (!isAxisAlignedSegment(start, end)) continue
+    if (getPointToSegmentDistance(point, start, end) > 1e-6) continue
+
+    return {
+      index: i,
+      start,
+      end,
+      orientation: getSegmentOrientation(start, end),
+    }
+  }
+
+  return null
+}
+
+export const isPointWithinSegmentPrimaryRange = (
+  point: Point,
+  segment: PathSegment,
+) => {
+  if (segment.orientation === "horizontal") {
+    return (
+      point.x >= Math.min(segment.start.x, segment.end.x) - EPS &&
+      point.x <= Math.max(segment.start.x, segment.end.x) + EPS
+    )
+  }
+
+  return (
+    point.y >= Math.min(segment.start.y, segment.end.y) - EPS &&
+    point.y <= Math.max(segment.start.y, segment.end.y) + EPS
+  )
+}
+
+export const findPreferredReroutedSegment = (
+  path: Point[],
+  originalSegmentIndex: number,
+  originalSegmentCount: number,
+  orientation: SegmentOrientation,
+  anchorPoint: Point,
+) => {
+  const matchingSegments = getSegments(path).filter(
+    (segment) => segment.orientation === orientation,
+  )
+  if (matchingSegments.length === 0) return null
+
+  const containingSegments = matchingSegments.filter((segment) =>
+    isPointWithinSegmentPrimaryRange(anchorPoint, segment),
+  )
+  const candidateSegments =
+    containingSegments.length > 0 ? containingSegments : matchingSegments
+
+  const isNearStart = originalSegmentIndex < originalSegmentCount / 2
+  return isNearStart
+    ? candidateSegments[0]!
+    : candidateSegments[candidateSegments.length - 1]!
+}
+
+export const projectPointToPath = (point: Point, path: Point[]) => {
+  let bestPoint: Point | null = null
+  let bestDistance = Number.POSITIVE_INFINITY
+
+  for (let i = 0; i < path.length - 1; i++) {
+    const projectedPoint = projectPointToSegment(point, path[i]!, path[i + 1]!)
+    const distance = getDistance(point, projectedPoint)
+    if (distance < bestDistance) {
+      bestPoint = projectedPoint
+      bestDistance = distance
+    }
+  }
+
+  return bestPoint
+}
+
+export const segmentsIntersect = (
+  a1: Point,
+  a2: Point,
+  b1: Point,
+  b2: Point,
+) => {
+  const aVertical = Math.abs(a1.x - a2.x) < EPS
+  const bVertical = Math.abs(b1.x - b2.x) < EPS
+  const between = (value: number, p1: number, p2: number) =>
+    value >= Math.min(p1, p2) - EPS && value <= Math.max(p1, p2) + EPS
+
+  if (aVertical && bVertical) {
+    if (Math.abs(a1.x - b1.x) > EPS) return false
+    const overlap =
+      Math.min(Math.max(a1.y, a2.y), Math.max(b1.y, b2.y)) -
+      Math.max(Math.min(a1.y, a2.y), Math.min(b1.y, b2.y))
+    return overlap > EPS
+  }
+
+  if (!aVertical && !bVertical) {
+    if (Math.abs(a1.y - b1.y) > EPS) return false
+    const overlap =
+      Math.min(Math.max(a1.x, a2.x), Math.max(b1.x, b2.x)) -
+      Math.max(Math.min(a1.x, a2.x), Math.min(b1.x, b2.x))
+    return overlap > EPS
+  }
+
+  const verticalA = aVertical ? a1 : b1
+  const verticalB = aVertical ? a2 : b2
+  const horizontalA = aVertical ? b1 : a1
+  const horizontalB = aVertical ? b2 : a2
+
+  return (
+    between(verticalA.x, horizontalA.x, horizontalB.x) &&
+    between(horizontalA.y, verticalA.y, verticalB.y)
+  )
+}
+
+export const countPathIntersections = (pathA: Point[], pathB: Point[]) => {
+  let count = 0
+  for (let i = 0; i < pathA.length - 1; i++) {
+    for (let j = 0; j < pathB.length - 1; j++) {
+      if (
+        segmentsIntersect(pathA[i]!, pathA[i + 1]!, pathB[j]!, pathB[j + 1]!)
+      ) {
+        count++
+      }
+    }
+  }
+  return count
+}
+
+export const isPathCollidingWithChipInterior = (
+  path: Point[],
+  chipObstacles: ChipObstacle[],
+) => {
+  for (let i = 0; i < path.length - 1; i++) {
+    const start = path[i]!
+    const end = path[i + 1]!
+    for (const obstacle of chipObstacles) {
+      if (!segmentIntersectsRect(start, end, obstacle)) continue
+      if (segmentRunsAlongRectBoundary(start, end, obstacle)) continue
+      return true
+    }
+  }
+  return false
+}
+
+const segmentRunsAlongRectBoundary = (
+  start: Point,
+  end: Point,
+  rect: ChipObstacle,
+) => {
+  const isVertical = Math.abs(start.x - end.x) < EPS
+  const isHorizontal = Math.abs(start.y - end.y) < EPS
+
+  if (isVertical) {
+    return (
+      Math.abs(start.x - rect.minX) < EPS || Math.abs(start.x - rect.maxX) < EPS
+    )
+  }
+
+  if (isHorizontal) {
+    return (
+      Math.abs(start.y - rect.minY) < EPS || Math.abs(start.y - rect.maxY) < EPS
+    )
+  }
+
+  return false
+}

package/lib/solvers/Example28Solver/labelMovement.ts

@@ -0,0 +1,82 @@
+import type { Point } from "@tscircuit/math-utils"
+import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import {
+  findPreferredReroutedSegment,
+  findSegmentContainingPoint,
+  projectPointToPath,
+  projectPointToSegment,
+} from "./geometry"
+
+export const moveAttachedLabelsToReroutedTrace = ({
+  trace,
+  originalTracePath,
+  reroutedTracePath,
+  netLabelPlacements,
+}: {
+  trace: SolvedTracePath
+  originalTracePath: Point[]
+  reroutedTracePath: Point[]
+  netLabelPlacements: NetLabelPlacement[]
+}) =>
+  netLabelPlacements.map((label) => {
+    if (!isLabelAttachedToTrace(label, trace)) return label
+
+    const movedAnchorPoint = getMovedAnchorPointForReroute(
+      label.anchorPoint,
+      originalTracePath,
+      reroutedTracePath,
+    )
+    if (!movedAnchorPoint) return label
+
+    const delta = {
+      x: movedAnchorPoint.x - label.anchorPoint.x,
+      y: movedAnchorPoint.y - label.anchorPoint.y,
+    }
+
+    return {
+      ...label,
+      anchorPoint: movedAnchorPoint,
+      center: {
+        x: label.center.x + delta.x,
+        y: label.center.y + delta.y,
+      },
+    }
+  })
+
+const isLabelAttachedToTrace = (
+  label: NetLabelPlacement,
+  trace: SolvedTracePath,
+) =>
+  label.globalConnNetId === trace.globalConnNetId ||
+  label.mspConnectionPairIds.includes(trace.mspPairId)
+
+const getMovedAnchorPointForReroute = (
+  anchorPoint: Point,
+  originalTracePath: Point[],
+  reroutedTracePath: Point[],
+) => {
+  const originalSegment = findSegmentContainingPoint(
+    originalTracePath,
+    anchorPoint,
+  )
+  if (!originalSegment) return null
+
+  const preferredSegment = findPreferredReroutedSegment(
+    reroutedTracePath,
+    originalSegment.index,
+    originalTracePath.length - 1,
+    originalSegment.orientation,
+    anchorPoint,
+  )
+
+  if (!preferredSegment) {
+    return projectPointToPath(anchorPoint, reroutedTracePath)
+  }
+
+  return projectPointToSegment(
+    anchorPoint,
+    preferredSegment.start,
+    preferredSegment.end,
+  )
+}

package/lib/solvers/Example28Solver/reroute.ts

@@ -0,0 +1,368 @@
+import type { Point } from "@tscircuit/math-utils"
+import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
+import { getRectBounds } from "lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/geometry"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import { simplifyPath } from "lib/solvers/TraceCleanupSolver/simplifyPath"
+import { detectTraceLabelOverlap } from "lib/solvers/TraceLabelOverlapAvoidanceSolver/detectTraceLabelOverlap"
+import { generateRerouteCandidates } from "lib/solvers/TraceLabelOverlapAvoidanceSolver/rerouteCollidingTrace"
+import type { InputProblem } from "lib/types/InputProblem"
+import { dir } from "lib/utils/dir"
+import {
+  countPathIntersections,
+  getPathKey,
+  getPathLength,
+  isPathCollidingWithChipInterior,
+} from "./geometry"
+import type {
+  ChipObstacle,
+  RerouteCandidateResult,
+  TracePathScore,
+} from "./types"
+
+const LABEL_SIDE_CLEARANCE = 0.1
+const LABEL_HUG_CLEARANCE = 0.001
+
+export const findBestReroutePath = ({
+  trace,
+  obstacleLabel,
+  inputProblem,
+  outputTraces,
+  outputNetLabelPlacements,
+  chipObstacles,
+}: {
+  trace: SolvedTracePath
+  obstacleLabel: NetLabelPlacement
+  inputProblem: InputProblem
+  outputTraces: SolvedTracePath[]
+  outputNetLabelPlacements: NetLabelPlacement[]
+  chipObstacles: ChipObstacle[]
+}) => {
+  const candidateResults = generateRerouteCandidateResults({
+    trace,
+    label: obstacleLabel,
+    inputProblem,
+    outputTraces,
+    outputNetLabelPlacements,
+    chipObstacles,
+  })
+  const bestPath = selectBestReroutePath({
+    trace,
+    obstacleLabel,
+    outputTraces,
+    outputNetLabelPlacements,
+    candidateResults,
+  })
+
+  markSelectedCandidate(candidateResults, bestPath)
+
+  return { bestPath, candidateResults }
+}
+
+export const generateRerouteCandidateResults = ({
+  trace,
+  label,
+  inputProblem,
+  outputTraces,
+  outputNetLabelPlacements,
+  chipObstacles,
+}: {
+  trace: SolvedTracePath
+  label: NetLabelPlacement
+  inputProblem: InputProblem
+  outputTraces: SolvedTracePath[]
+  outputNetLabelPlacements: NetLabelPlacement[]
+  chipObstacles: ChipObstacle[]
+}) => {
+  const rawCandidates = generateCandidatePaths(trace, label, inputProblem)
+  const seen = new Set<string>()
+  const candidateResults: RerouteCandidateResult[] = []
+
+  for (const rawCandidate of rawCandidates) {
+    candidateResults.push(
+      createCandidateResult({
+        trace,
+        obstacleLabel: label,
+        path: simplifyPath(rawCandidate),
+        seen,
+        outputTraces,
+        outputNetLabelPlacements,
+        chipObstacles,
+      }),
+    )
+  }
+
+  return candidateResults
+}
+
+const generateCandidatePaths = (
+  trace: SolvedTracePath,
+  label: NetLabelPlacement,
+  inputProblem: InputProblem,
+) => [
+  ...generateLabelHugCandidates(trace, label),
+  ...generateRerouteCandidates({
+    trace,
+    label,
+    problem: inputProblem,
+    paddingBuffer: LABEL_SIDE_CLEARANCE,
+    detourCount: 0,
+  }),
+  ...generateEndpointDetourCandidates(trace, label),
+]
+
+const createCandidateResult = ({
+  trace,
+  obstacleLabel,
+  path,
+  seen,
+  outputTraces,
+  outputNetLabelPlacements,
+  chipObstacles,
+}: {
+  trace: SolvedTracePath
+  obstacleLabel: NetLabelPlacement
+  path: Point[]
+  seen: Set<string>
+  outputTraces: SolvedTracePath[]
+  outputNetLabelPlacements: NetLabelPlacement[]
+  chipObstacles: ChipObstacle[]
+}): RerouteCandidateResult => {
+  const key = getPathKey(path)
+
+  if (seen.has(key)) {
+    return {
+      path,
+      status: "duplicate",
+      selected: false,
+    }
+  }
+
+  seen.add(key)
+
+  if (isPathCollidingWithChipInterior(path, chipObstacles)) {
+    return {
+      path,
+      status: "chip-collision",
+      selected: false,
+    }
+  }
+
+  return {
+    path,
+    score: scoreTracePath({
+      trace,
+      tracePath: path,
+      obstacleLabel,
+      outputTraces,
+      outputNetLabelPlacements,
+    }),
+    status: "valid",
+    selected: false,
+  }
+}
+
+const generateEndpointDetourCandidates = (
+  trace: SolvedTracePath,
+  label: NetLabelPlacement,
+): Point[][] => {
+  const start = trace.tracePath[0]
+  const end = trace.tracePath[trace.tracePath.length - 1]
+  if (!start || !end) return []
+
+  const bounds = getRectBounds(label.center, label.width, label.height)
+  const padding = LABEL_SIDE_CLEARANCE
+  const labelDirection = dir(label.orientation)
+  const labelSideX =
+    labelDirection.x < 0 ? bounds.minX - padding : bounds.maxX + padding
+  const oppositeSideX =
+    labelDirection.x < 0 ? bounds.maxX + padding : bounds.minX - padding
+  const topY = bounds.maxY + padding
+  const bottomY = bounds.minY - padding
+  const candidates: Point[][] = []
+
+  for (const sideX of [labelSideX, oppositeSideX]) {
+    candidates.push(
+      [
+        start,
+        { x: start.x, y: topY },
+        { x: sideX, y: topY },
+        { x: sideX, y: bottomY },
+        { x: end.x, y: bottomY },
+        end,
+      ],
+      [
+        start,
+        { x: start.x, y: bottomY },
+        { x: sideX, y: bottomY },
+        { x: sideX, y: topY },
+        { x: end.x, y: topY },
+        end,
+      ],
+    )
+  }
+
+  return candidates
+}
+
+const generateLabelHugCandidates = (
+  trace: SolvedTracePath,
+  label: NetLabelPlacement,
+): Point[][] => {
+  const start = trace.tracePath[0]
+  const end = trace.tracePath[trace.tracePath.length - 1]
+  if (!start || !end) return []
+
+  const labelDirection = dir(label.orientation)
+  if (labelDirection.x === 0) return []
+
+  const bounds = getRectBounds(label.center, label.width, label.height)
+  const sideX =
+    labelDirection.x < 0
+      ? bounds.minX - LABEL_SIDE_CLEARANCE
+      : bounds.maxX + LABEL_SIDE_CLEARANCE
+  const topY = bounds.maxY + LABEL_HUG_CLEARANCE
+  const bottomY = bounds.minY - LABEL_HUG_CLEARANCE
+  const startsAboveEnd = start.y >= end.y
+  const firstY = startsAboveEnd ? topY : bottomY
+  const secondY = startsAboveEnd ? bottomY : topY
+
+  return [
+    [
+      start,
+      { x: start.x, y: firstY },
+      { x: sideX, y: firstY },
+      { x: sideX, y: secondY },
+      { x: end.x, y: secondY },
+      end,
+    ],
+    [
+      start,
+      { x: start.x, y: secondY },
+      { x: sideX, y: secondY },
+      { x: sideX, y: firstY },
+      { x: end.x, y: firstY },
+      end,
+    ],
+  ]
+}
+
+const selectBestReroutePath = ({
+  trace,
+  obstacleLabel,
+  outputTraces,
+  outputNetLabelPlacements,
+  candidateResults,
+}: {
+  trace: SolvedTracePath
+  obstacleLabel: NetLabelPlacement
+  outputTraces: SolvedTracePath[]
+  outputNetLabelPlacements: NetLabelPlacement[]
+  candidateResults: RerouteCandidateResult[]
+}) => {
+  let bestPath: Point[] | null = null
+  let bestScore = scoreTracePath({
+    trace,
+    tracePath: trace.tracePath,
+    obstacleLabel,
+    outputTraces,
+    outputNetLabelPlacements,
+  })
+
+  for (const candidate of candidateResults) {
+    if (candidate.status !== "valid" || !candidate.score) continue
+    if (!isBetterScore(candidate.score, bestScore)) continue
+
+    bestScore = candidate.score
+    bestPath = candidate.path
+  }
+
+  return bestPath
+}
+
+const markSelectedCandidate = (
+  candidateResults: RerouteCandidateResult[],
+  bestPath: Point[] | null,
+) => {
+  if (!bestPath) return
+
+  for (const candidate of candidateResults) {
+    candidate.selected = candidate.path === bestPath
+  }
+}
+
+const scoreTracePath = ({
+  trace,
+  tracePath,
+  obstacleLabel,
+  outputTraces,
+  outputNetLabelPlacements,
+}: {
+  trace: SolvedTracePath
+  tracePath: Point[]
+  obstacleLabel: NetLabelPlacement
+  outputTraces: SolvedTracePath[]
+  outputNetLabelPlacements: NetLabelPlacement[]
+}): TracePathScore => {
+  const candidateTrace = { ...trace, tracePath }
+  return {
+    labelIntersections: detectTraceLabelOverlap({
+      traces: [candidateTrace],
+      netLabels: outputNetLabelPlacements,
+    }).length,
+    labelHugDistance: getLabelHugDistance(tracePath, obstacleLabel),
+    traceIntersections: countTraceIntersections(candidateTrace, outputTraces),
+    pathLength: getPathLength(tracePath),
+  }
+}
+
+const countTraceIntersections = (
+  trace: SolvedTracePath,
+  outputTraces: SolvedTracePath[],
+) => {
+  let count = 0
+  for (const otherTrace of outputTraces) {
+    if (otherTrace.mspPairId === trace.mspPairId) continue
+    count += countPathIntersections(trace.tracePath, otherTrace.tracePath)
+  }
+  return count
+}
+
+const isBetterScore = (score: TracePathScore, bestScore: TracePathScore) => {
+  if (score.labelIntersections !== bestScore.labelIntersections) {
+    return score.labelIntersections < bestScore.labelIntersections
+  }
+  if (score.labelHugDistance !== bestScore.labelHugDistance) {
+    return score.labelHugDistance < bestScore.labelHugDistance
+  }
+  if (score.traceIntersections !== bestScore.traceIntersections) {
+    return score.traceIntersections < bestScore.traceIntersections
+  }
+  return score.pathLength < bestScore.pathLength
+}
+
+const getLabelHugDistance = (
+  tracePath: Point[],
+  obstacleLabel: NetLabelPlacement,
+) => {
+  const bounds = getRectBounds(
+    obstacleLabel.center,
+    obstacleLabel.width,
+    obstacleLabel.height,
+  )
+  let distance = 0
+
+  for (const point of tracePath) {
+    distance += getPointDistanceFromRect(point, bounds)
+  }
+
+  return distance
+}
+
+const getPointDistanceFromRect = (
+  point: Point,
+  rect: { minX: number; minY: number; maxX: number; maxY: number },
+) => {
+  const dx = Math.max(rect.minX - point.x, 0, point.x - rect.maxX)
+  const dy = Math.max(rect.minY - point.y, 0, point.y - rect.maxY)
+  return dx + dy
+}