@tscircuit/schematic-trace-solver 0.0.51 → 0.0.52

package/lib/solvers/TraceAnchoredNetLabelOverlapSolver/candidates.ts

@@ -0,0 +1,429 @@
+import type { Point } from "@tscircuit/math-utils"
+import {
+  getCenterFromAnchor,
+  getDimsForOrientation,
+} from "lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/geometry"
+import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
+import type { InputProblem } from "lib/types/InputProblem"
+import type { FacingDirection } from "lib/utils/dir"
+import {
+  EPS,
+  getManhattanDistance,
+  getPointAtTraceDistance,
+  getTraceDistanceCompatibleOrientations,
+  getTraceLength,
+  getTraceVertexDistances,
+} from "./geometry"
+import type { Bounds, LabelCandidate, TraceLocation } from "./types"
+
+const CANDIDATE_STEP = 0.1
+
+export const generateCandidatesAlongTrace = (params: {
+  inputProblem: InputProblem
+  label: NetLabelPlacement
+  traceLocation: TraceLocation
+}) => {
+  const { inputProblem, label, traceLocation } = params
+  const traceLength = getTraceLength(traceLocation.trace)
+  const orientationConstraint = getOrientationConstraint(inputProblem, label)
+  const candidateDistances = getCandidateDistances(
+    traceLocation,
+    traceLength,
+    getTraceVertexDistances(traceLocation.trace),
+    orientationConstraint,
+  )
+  const netLabelWidth = getNetLabelWidth(inputProblem, label)
+  const candidates: LabelCandidate[] = []
+  const seenCandidateKeys = new Set<string>()
+
+  for (const pathDistance of candidateDistances) {
+    const point = getPointAtTraceDistance(traceLocation.trace, pathDistance)
+    const compatibleOrientations = getTraceDistanceCompatibleOrientations(
+      traceLocation.trace,
+      pathDistance,
+    )
+    const orientations = getOrientationsForPoint({
+      inputProblem,
+      label,
+      point,
+      compatibleOrientations,
+      orientationConstraint,
+    })
+
+    for (const orientation of orientations) {
+      if (isSamePlacement(label, point, orientation)) continue
+      const key = [point.x.toFixed(6), point.y.toFixed(6), orientation].join(
+        ":",
+      )
+      if (seenCandidateKeys.has(key)) continue
+      seenCandidateKeys.add(key)
+
+      candidates.push(
+        createCandidate({
+          point,
+          orientation,
+          netLabelWidth,
+          traceLocation,
+          pathDistance,
+          label,
+        }),
+      )
+    }
+  }
+
+  return candidates.sort(
+    (a, b) =>
+      a.distanceFromOriginal - b.distanceFromOriginal ||
+      a.pathDistance - b.pathDistance,
+  )
+}
+
+const getCandidateDistances = (
+  traceLocation: TraceLocation,
+  traceLength: number,
+  vertexDistances: number[],
+  orientationConstraint: FacingDirection[] | null,
+) => {
+  const distances = new Set<number>()
+  const maxSteps = Math.ceil(traceLength / CANDIDATE_STEP)
+
+  for (let i = 0; i <= maxSteps; i++) {
+    const distance = Math.min(traceLength, i * CANDIDATE_STEP)
+    distances.add(roundDistance(distance))
+  }
+  for (const distance of vertexDistances) {
+    distances.add(roundDistance(distance))
+  }
+  distances.add(roundDistance(traceLocation.distance))
+
+  return [...distances]
+    .filter((distance) => distance >= -EPS && distance <= traceLength + EPS)
+    .filter((distance) =>
+      isDistanceAllowedByOrientationConstraint(
+        traceLocation,
+        distance,
+        orientationConstraint,
+      ),
+    )
+    .sort(
+      (a, b) =>
+        Math.abs(a - traceLocation.distance) -
+          Math.abs(b - traceLocation.distance) || a - b,
+    )
+}
+
+const getOrientationsForPoint = (params: {
+  inputProblem: InputProblem
+  label: NetLabelPlacement
+  point: Point
+  compatibleOrientations: Set<FacingDirection>
+  orientationConstraint: FacingDirection[] | null
+}) => {
+  const {
+    inputProblem,
+    label,
+    point,
+    compatibleOrientations,
+    orientationConstraint,
+  } = params
+
+  if (orientationConstraint) {
+    return orientationConstraint.filter((orientation) =>
+      compatibleOrientations.has(orientation),
+    )
+  }
+
+  return getUnconstrainedOrientations({
+    label,
+    inputProblem,
+    point,
+    compatibleOrientations,
+  })
+}
+
+const createCandidate = (params: {
+  point: Point
+  orientation: FacingDirection
+  netLabelWidth: number
+  traceLocation: TraceLocation
+  pathDistance: number
+  label: NetLabelPlacement
+}): LabelCandidate => {
+  const {
+    point,
+    orientation,
+    netLabelWidth,
+    traceLocation,
+    pathDistance,
+    label,
+  } = params
+  const { width, height } = getDimsForOrientation({
+    orientation,
+    netLabelWidth,
+  })
+
+  return {
+    anchorPoint: point,
+    center: getCenterFromAnchor(point, orientation, width, height),
+    width,
+    height,
+    orientation,
+    traceId: traceLocation.trace.mspPairId,
+    pathDistance,
+    distanceFromOriginal: getManhattanDistance(point, label.anchorPoint),
+    status: "valid",
+    selected: false,
+  }
+}
+
+const getOrientationConstraint = (
+  inputProblem: InputProblem,
+  label: NetLabelPlacement,
+): FacingDirection[] | null => {
+  for (const netId of getOrientationConstraintKeys(inputProblem, label)) {
+    if (Object.hasOwn(inputProblem.availableNetLabelOrientations, netId)) {
+      return inputProblem.availableNetLabelOrientations[netId] ?? []
+    }
+  }
+
+  return null
+}
+
+const isDistanceAllowedByOrientationConstraint = (
+  traceLocation: TraceLocation,
+  distance: number,
+  constrainedOrientations: FacingDirection[] | null,
+) => {
+  if (!constrainedOrientations) return true
+
+  const compatibleOrientations = getTraceDistanceCompatibleOrientations(
+    traceLocation.trace,
+    distance,
+  )
+  return constrainedOrientations.some((orientation) =>
+    compatibleOrientations.has(orientation),
+  )
+}
+
+const getOrientationConstraintKeys = (
+  inputProblem: InputProblem,
+  label: NetLabelPlacement,
+) =>
+  dedupeStrings([
+    label.netId,
+    label.globalConnNetId,
+    ...inputProblem.netConnections
+      .filter((connection) =>
+        label.pinIds.some((pinId) => connection.pinIds.includes(pinId)),
+      )
+      .map((connection) => connection.netId),
+  ])
+
+const getUnconstrainedOrientations = (params: {
+  label: NetLabelPlacement
+  inputProblem: InputProblem
+  point: Point
+  compatibleOrientations: Set<FacingDirection>
+}) => {
+  const { label, inputProblem, point, compatibleOrientations } = params
+  return dedupeOrientations([
+    ...getInitialOrientations(label, compatibleOrientations),
+    ...getOutwardOrientations({
+      inputProblem,
+      point,
+      compatibleOrientations,
+    }),
+    ...ALL_ORIENTATIONS.filter((orientation) =>
+      compatibleOrientations.has(orientation),
+    ),
+  ])
+}
+
+const getInitialOrientations = (
+  label: NetLabelPlacement,
+  compatibleOrientations: Set<FacingDirection>,
+) =>
+  [label.orientation, getFlippedOrientation(label.orientation)].filter(
+    (orientation) => compatibleOrientations.has(orientation),
+  )
+
+const getOutwardOrientations = (params: {
+  inputProblem: InputProblem
+  point: Point
+  compatibleOrientations: Set<FacingDirection>
+}) => {
+  const { inputProblem, point, compatibleOrientations } = params
+  const chipBounds = getChipBounds(inputProblem)
+
+  return dedupeOrientations(
+    getOutwardOrientationOptions(point, chipBounds, compatibleOrientations)
+      .filter(({ orientation }) => compatibleOrientations.has(orientation))
+      .sort((a, b) => b.outwardScore - a.outwardScore)
+      .map(({ orientation }) => orientation),
+  )
+}
+
+const getOutwardOrientationOptions = (
+  point: Point,
+  chipBounds: ChipBounds,
+  compatibleOrientations: Set<FacingDirection>,
+) => {
+  const options: OutwardOrientationOption[] = []
+
+  if (compatibleOrientations.has("y+") || compatibleOrientations.has("y-")) {
+    options.push(
+      getOutwardAxisOption({
+        value: point.y,
+        min: chipBounds.minY,
+        max: chipBounds.maxY,
+        center: chipBounds.centerY,
+        positiveOrientation: "y+",
+        negativeOrientation: "y-",
+      }),
+    )
+  }
+  if (compatibleOrientations.has("x+") || compatibleOrientations.has("x-")) {
+    options.push(
+      getOutwardAxisOption({
+        value: point.x,
+        min: chipBounds.minX,
+        max: chipBounds.maxX,
+        center: chipBounds.centerX,
+        positiveOrientation: "x+",
+        negativeOrientation: "x-",
+      }),
+    )
+  }
+
+  return options
+}
+
+type OutwardOrientationOption = {
+  orientation: FacingDirection
+  outwardScore: number
+}
+
+const getOutwardAxisOption = (params: {
+  value: number
+  min: number
+  max: number
+  center: number
+  positiveOrientation: FacingDirection
+  negativeOrientation: FacingDirection
+}): OutwardOrientationOption => {
+  const { value, min, max, center, positiveOrientation, negativeOrientation } =
+    params
+
+  if (value > max + EPS) {
+    return {
+      orientation: positiveOrientation,
+      outwardScore: 1 + value - max,
+    }
+  }
+  if (value < min - EPS) {
+    return {
+      orientation: negativeOrientation,
+      outwardScore: 1 + min - value,
+    }
+  }
+
+  return {
+    orientation: value >= center ? positiveOrientation : negativeOrientation,
+    outwardScore: getNormalizedCenterDistance(value, center, max - min),
+  }
+}
+
+const getNormalizedCenterDistance = (
+  value: number,
+  center: number,
+  span: number,
+) => Math.abs(value - center) / Math.max(EPS, span / 2)
+
+const ALL_ORIENTATIONS: FacingDirection[] = ["x+", "x-", "y+", "y-"]
+
+const getFlippedOrientation = (
+  orientation: FacingDirection,
+): FacingDirection => {
+  switch (orientation) {
+    case "x+":
+      return "x-"
+    case "x-":
+      return "x+"
+    case "y+":
+      return "y-"
+    case "y-":
+      return "y+"
+  }
+}
+
+type ChipBounds = Bounds & {
+  centerX: number
+  centerY: number
+}
+
+const getChipBounds = (inputProblem: InputProblem): ChipBounds => {
+  if (inputProblem.chips.length === 0) {
+    return {
+      minX: 0,
+      minY: 0,
+      maxX: 0,
+      maxY: 0,
+      centerX: 0,
+      centerY: 0,
+    }
+  }
+
+  const bounds = inputProblem.chips.reduce<Bounds>(
+    (acc, chip) => ({
+      minX: Math.min(acc.minX, chip.center.x - chip.width / 2),
+      minY: Math.min(acc.minY, chip.center.y - chip.height / 2),
+      maxX: Math.max(acc.maxX, chip.center.x + chip.width / 2),
+      maxY: Math.max(acc.maxY, chip.center.y + chip.height / 2),
+    }),
+    {
+      minX: Number.POSITIVE_INFINITY,
+      minY: Number.POSITIVE_INFINITY,
+      maxX: Number.NEGATIVE_INFINITY,
+      maxY: Number.NEGATIVE_INFINITY,
+    },
+  )
+
+  return {
+    ...bounds,
+    centerX: (bounds.minX + bounds.maxX) / 2,
+    centerY: (bounds.minY + bounds.maxY) / 2,
+  }
+}
+
+const getNetLabelWidth = (
+  inputProblem: InputProblem,
+  label: NetLabelPlacement,
+) => {
+  const configuredWidth = inputProblem.netConnections.find(
+    (connection) => connection.netId === label.netId,
+  )?.netLabelWidth
+  if (configuredWidth !== undefined) return configuredWidth
+
+  return label.orientation === "y+" || label.orientation === "y-"
+    ? label.height
+    : label.width
+}
+
+const roundDistance = (distance: number) => Number(distance.toFixed(6))
+
+const dedupeOrientations = (orientations: FacingDirection[]) => [
+  ...new Set(orientations),
+]
+
+const dedupeStrings = (values: Array<string | undefined>) => [
+  ...new Set(values.filter((value): value is string => value !== undefined)),
+]
+
+const isSamePlacement = (
+  label: NetLabelPlacement,
+  point: Point,
+  orientation: FacingDirection,
+) =>
+  Math.abs(point.x - label.anchorPoint.x) <= EPS &&
+  Math.abs(point.y - label.anchorPoint.y) <= EPS &&
+  orientation === label.orientation

package/lib/solvers/TraceAnchoredNetLabelOverlapSolver/geometry.ts

@@ -0,0 +1,250 @@
+import type { Point } from "@tscircuit/math-utils"
+import { getRectBounds } from "lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/geometry"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import type { FacingDirection } from "lib/utils/dir"
+import type { Bounds, TraceLocation } from "./types"
+
+export const EPS = 1e-6
+export const TRACE_BOUNDARY_TOLERANCE = 1e-6
+
+export const getLabelBounds = (label: {
+  center: Point
+  width: number
+  height: number
+}) => getRectBounds(label.center, label.width, label.height)
+
+export const rectsOverlap = (a: Bounds, b: Bounds) =>
+  Math.min(a.maxX, b.maxX) - Math.max(a.minX, b.minX) > EPS &&
+  Math.min(a.maxY, b.maxY) - Math.max(a.minY, b.minY) > EPS
+
+export const traceCrossesBoundsInterior = (
+  bounds: Bounds,
+  traces: SolvedTracePath[],
+) => {
+  for (const trace of traces) {
+    const points = trace.tracePath
+    for (let i = 0; i < points.length - 1; i++) {
+      if (segmentCrossesBoundsInterior(points[i]!, points[i + 1]!, bounds)) {
+        return true
+      }
+    }
+  }
+
+  return false
+}
+
+export const getTraceLocationsForPoint = (
+  point: Point,
+  traces: SolvedTracePath[],
+) => {
+  const locations: TraceLocation[] = []
+
+  for (const trace of traces) {
+    if (getUniquePinCount(trace.pinIds) < 2) continue
+
+    let pathDistance = 0
+    for (let i = 0; i < trace.tracePath.length - 1; i++) {
+      const start = trace.tracePath[i]!
+      const end = trace.tracePath[i + 1]!
+      const segmentLength = getManhattanDistance(start, end)
+
+      if (isPointOnSegment(point, start, end)) {
+        locations.push({
+          trace,
+          distance: pathDistance + getManhattanDistance(start, point),
+        })
+      }
+
+      pathDistance += segmentLength
+    }
+  }
+
+  return locations
+}
+
+export const getTraceLength = (trace: SolvedTracePath) => {
+  let length = 0
+  for (let i = 0; i < trace.tracePath.length - 1; i++) {
+    length += getManhattanDistance(trace.tracePath[i]!, trace.tracePath[i + 1]!)
+  }
+  return length
+}
+
+export const getPointAtTraceDistance = (
+  trace: SolvedTracePath,
+  distance: number,
+) => {
+  let pathDistance = 0
+
+  for (let i = 0; i < trace.tracePath.length - 1; i++) {
+    const start = trace.tracePath[i]!
+    const end = trace.tracePath[i + 1]!
+    const segmentLength = getManhattanDistance(start, end)
+    const nextDistance = pathDistance + segmentLength
+
+    if (distance <= nextDistance + EPS) {
+      const offset = Math.max(
+        0,
+        Math.min(segmentLength, distance - pathDistance),
+      )
+      const direction = getSegmentDirection(start, end)
+      return {
+        x: start.x + direction.x * offset,
+        y: start.y + direction.y * offset,
+      }
+    }
+
+    pathDistance = nextDistance
+  }
+
+  return trace.tracePath[trace.tracePath.length - 1]!
+}
+
+export const getTraceVertexDistances = (trace: SolvedTracePath) => {
+  const distances: number[] = []
+  let pathDistance = 0
+
+  for (let i = 0; i < trace.tracePath.length; i++) {
+    distances.push(pathDistance)
+    const nextPoint = trace.tracePath[i + 1]
+    if (nextPoint) {
+      pathDistance += getManhattanDistance(trace.tracePath[i]!, nextPoint)
+    }
+  }
+
+  return distances
+}
+
+export const getTraceDistanceCompatibleOrientations = (
+  trace: SolvedTracePath,
+  distance: number,
+) => {
+  const orientations = new Set<FacingDirection>()
+  let pathDistance = 0
+
+  for (let i = 0; i < trace.tracePath.length - 1; i++) {
+    const start = trace.tracePath[i]!
+    const end = trace.tracePath[i + 1]!
+    const segmentLength = getManhattanDistance(start, end)
+    const nextDistance = pathDistance + segmentLength
+
+    if (distance >= pathDistance - EPS && distance <= nextDistance + EPS) {
+      addSegmentCompatibleOrientations(orientations, trace, i)
+      if (Math.abs(distance - pathDistance) <= EPS) {
+        addSegmentCompatibleOrientations(orientations, trace, i - 1)
+      }
+      if (Math.abs(distance - nextDistance) <= EPS) {
+        addSegmentCompatibleOrientations(orientations, trace, i + 1)
+      }
+      return orientations
+    }
+
+    pathDistance = nextDistance
+  }
+
+  return orientations
+}
+
+export const getManhattanDistance = (a: Point, b: Point) =>
+  Math.abs(a.x - b.x) + Math.abs(a.y - b.y)
+
+const addSegmentCompatibleOrientations = (
+  orientations: Set<FacingDirection>,
+  trace: SolvedTracePath,
+  segmentIndex: number,
+) => {
+  const start = trace.tracePath[segmentIndex]
+  const end = trace.tracePath[segmentIndex + 1]
+  if (!start || !end) return
+
+  if (isHorizontal(start, end)) {
+    orientations.add("y+")
+    orientations.add("y-")
+  } else if (isVertical(start, end)) {
+    orientations.add("x+")
+    orientations.add("x-")
+  }
+}
+
+const segmentCrossesBoundsInterior = (
+  start: Point,
+  end: Point,
+  bounds: Bounds,
+) => {
+  const interior = {
+    minX: bounds.minX + TRACE_BOUNDARY_TOLERANCE,
+    minY: bounds.minY + TRACE_BOUNDARY_TOLERANCE,
+    maxX: bounds.maxX - TRACE_BOUNDARY_TOLERANCE,
+    maxY: bounds.maxY - TRACE_BOUNDARY_TOLERANCE,
+  }
+
+  if (interior.minX >= interior.maxX || interior.minY >= interior.maxY) {
+    return false
+  }
+
+  if (isVertical(start, end)) {
+    if (start.x <= interior.minX + EPS || start.x >= interior.maxX - EPS) {
+      return false
+    }
+    return rangesOverlap(
+      Math.min(start.y, end.y),
+      Math.max(start.y, end.y),
+      interior.minY,
+      interior.maxY,
+    )
+  }
+
+  if (isHorizontal(start, end)) {
+    if (start.y <= interior.minY + EPS || start.y >= interior.maxY - EPS) {
+      return false
+    }
+    return rangesOverlap(
+      Math.min(start.x, end.x),
+      Math.max(start.x, end.x),
+      interior.minX,
+      interior.maxX,
+    )
+  }
+
+  return false
+}
+
+const isPointOnSegment = (point: Point, start: Point, end: Point) => {
+  if (isHorizontal(start, end)) {
+    return (
+      Math.abs(point.y - start.y) <= EPS &&
+      point.x >= Math.min(start.x, end.x) - EPS &&
+      point.x <= Math.max(start.x, end.x) + EPS
+    )
+  }
+
+  if (isVertical(start, end)) {
+    return (
+      Math.abs(point.x - start.x) <= EPS &&
+      point.y >= Math.min(start.y, end.y) - EPS &&
+      point.y <= Math.max(start.y, end.y) + EPS
+    )
+  }
+
+  return false
+}
+
+const getSegmentDirection = (start: Point, end: Point) => ({
+  x: isVertical(start, end) ? 0 : Math.sign(end.x - start.x),
+  y: isHorizontal(start, end) ? 0 : Math.sign(end.y - start.y),
+})
+
+const isHorizontal = (start: Point, end: Point) =>
+  Math.abs(start.y - end.y) <= EPS
+
+const isVertical = (start: Point, end: Point) =>
+  Math.abs(start.x - end.x) <= EPS
+
+const rangesOverlap = (
+  minA: number,
+  maxA: number,
+  minB: number,
+  maxB: number,
+) => Math.min(maxA, maxB) - Math.max(minA, minB) > EPS
+
+const getUniquePinCount = (pinIds: string[]) => new Set(pinIds).size

package/lib/solvers/TraceAnchoredNetLabelOverlapSolver/types.ts

@@ -0,0 +1,47 @@
+import type { Point } from "@tscircuit/math-utils"
+import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import type { InputProblem } from "lib/types/InputProblem"
+import type { FacingDirection } from "lib/utils/dir"
+
+export interface TraceAnchoredNetLabelOverlapSolverParams {
+  inputProblem: InputProblem
+  traces: SolvedTracePath[]
+  netLabelPlacements: NetLabelPlacement[]
+}
+
+export type Bounds = {
+  minX: number
+  minY: number
+  maxX: number
+  maxY: number
+}
+
+export type LabelOverlap = {
+  firstLabelIndex: number
+  secondLabelIndex: number
+}
+
+export type TraceLocation = {
+  trace: SolvedTracePath
+  distance: number
+}
+
+export type CandidateStatus =
+  | "valid"
+  | "chip-collision"
+  | "trace-collision"
+  | "netlabel-collision"
+
+export type LabelCandidate = {
+  anchorPoint: Point
+  center: Point
+  width: number
+  height: number
+  orientation: FacingDirection
+  traceId: string
+  pathDistance: number
+  distanceFromOriginal: number
+  status: CandidateStatus
+  selected: boolean
+}