@tscircuit/fanout-solver 0.0.10

package/lib/geometry.ts

@@ -0,0 +1,162 @@
+import type { Obstacle } from "@tscircuit/capacity-autorouter"
+import type { Point2D, RoutedSegment } from "./types"
+
+const EPSILON = 1e-9
+
+type ShapeAwareObstacle = Obstacle & { shape?: "circle" }
+
+function obstacleIsCircular(obstacle: Obstacle): boolean {
+  return (obstacle as ShapeAwareObstacle).shape === "circle"
+}
+
+export function distance(a: Point2D, b: Point2D): number {
+  return Math.hypot(a.x - b.x, a.y - b.y)
+}
+
+export function distancePointToSegment(
+  point: Point2D,
+  start: Point2D,
+  end: Point2D,
+): number {
+  const dx = end.x - start.x
+  const dy = end.y - start.y
+  const lengthSquared = dx * dx + dy * dy
+  const rawT =
+    lengthSquared < EPSILON
+      ? 0
+      : ((point.x - start.x) * dx + (point.y - start.y) * dy) / lengthSquared
+  const t = Math.max(0, Math.min(1, rawT))
+  return Math.hypot(point.x - (start.x + t * dx), point.y - (start.y + t * dy))
+}
+
+function cross(origin: Point2D, a: Point2D, b: Point2D): number {
+  return (
+    (a.x - origin.x) * (b.y - origin.y) - (a.y - origin.y) * (b.x - origin.x)
+  )
+}
+
+function segmentsProperlyCross(
+  a: Point2D,
+  b: Point2D,
+  c: Point2D,
+  d: Point2D,
+): boolean {
+  const d1 = cross(c, d, a)
+  const d2 = cross(c, d, b)
+  const d3 = cross(a, b, c)
+  const d4 = cross(a, b, d)
+  return (
+    ((d1 > 0 && d2 < 0) || (d1 < 0 && d2 > 0)) &&
+    ((d3 > 0 && d4 < 0) || (d3 < 0 && d4 > 0))
+  )
+}
+
+export function distanceSegmentToSegment(
+  firstStart: Point2D,
+  firstEnd: Point2D,
+  secondStart: Point2D,
+  secondEnd: Point2D,
+): number {
+  if (segmentsProperlyCross(firstStart, firstEnd, secondStart, secondEnd)) {
+    return 0
+  }
+  return Math.min(
+    distancePointToSegment(firstStart, secondStart, secondEnd),
+    distancePointToSegment(firstEnd, secondStart, secondEnd),
+    distancePointToSegment(secondStart, firstStart, firstEnd),
+    distancePointToSegment(secondEnd, firstStart, firstEnd),
+  )
+}
+
+export function pointIsInsideObstacle(
+  point: Point2D,
+  obstacle: Obstacle,
+  tolerance = EPSILON,
+): boolean {
+  if (obstacleIsCircular(obstacle)) {
+    return distance(point, obstacle.center) <= obstacle.width / 2 + tolerance
+  }
+  return (
+    Math.abs(point.x - obstacle.center.x) <= obstacle.width / 2 + tolerance &&
+    Math.abs(point.y - obstacle.center.y) <= obstacle.height / 2 + tolerance
+  )
+}
+
+export function distancePointToObstacle(
+  point: Point2D,
+  obstacle: Obstacle,
+): number {
+  if (obstacleIsCircular(obstacle)) {
+    return Math.max(0, distance(point, obstacle.center) - obstacle.width / 2)
+  }
+  const dx = Math.max(
+    Math.abs(point.x - obstacle.center.x) - obstacle.width / 2,
+    0,
+  )
+  const dy = Math.max(
+    Math.abs(point.y - obstacle.center.y) - obstacle.height / 2,
+    0,
+  )
+  return Math.hypot(dx, dy)
+}
+
+export function distanceSegmentToObstacle(
+  segment: RoutedSegment,
+  obstacle: Obstacle,
+): number {
+  if (obstacleIsCircular(obstacle)) {
+    return Math.max(
+      0,
+      distancePointToSegment(obstacle.center, segment.start, segment.end) -
+        obstacle.width / 2,
+    )
+  }
+  if (
+    pointIsInsideObstacle(segment.start, obstacle) ||
+    pointIsInsideObstacle(segment.end, obstacle)
+  ) {
+    return 0
+  }
+  const minX = obstacle.center.x - obstacle.width / 2
+  const maxX = obstacle.center.x + obstacle.width / 2
+  const minY = obstacle.center.y - obstacle.height / 2
+  const maxY = obstacle.center.y + obstacle.height / 2
+  const corners = [
+    { x: minX, y: minY },
+    { x: maxX, y: minY },
+    { x: maxX, y: maxY },
+    { x: minX, y: maxY },
+  ]
+
+  let minimumDistance = Number.POSITIVE_INFINITY
+  for (let index = 0; index < corners.length; index++) {
+    minimumDistance = Math.min(
+      minimumDistance,
+      distanceSegmentToSegment(
+        segment.start,
+        segment.end,
+        corners[index]!,
+        corners[(index + 1) % corners.length]!,
+      ),
+    )
+  }
+  return minimumDistance
+}
+
+export function segmentsAreClear(
+  first: RoutedSegment,
+  second: RoutedSegment,
+  clearance: number,
+): boolean {
+  if (first.layer !== second.layer) return true
+  const requiredDistance = (first.width + second.width) / 2 + clearance
+  return (
+    distanceSegmentToSegment(
+      first.start,
+      first.end,
+      second.start,
+      second.end,
+    ) >=
+    requiredDistance - EPSILON
+  )
+}

package/lib/index.ts

@@ -0,0 +1,20 @@
+export { FanoutSolver } from "./fanout-solver"
+export { getCopperLayerColor } from "./layer-colors"
+export { getCopperLayerNames } from "./layer-names"
+export type {
+  Bounds,
+  FanoutAttemptSummary,
+  FanoutAvailableCornerAndSide,
+  FanoutAvailableCornerAndSideAlias,
+  FanoutAvailableCornerAndSideInput,
+  FanoutBorderDistribution,
+  FanoutBorderTarget,
+  FanoutBusSpec,
+  FanoutBusTermination,
+  FanoutCorner,
+  FanoutDirection,
+  FanoutEdge,
+  FanoutPlaneTermination,
+  FanoutSolverOptions,
+  FanoutSolverOutput,
+} from "./types"

package/lib/layer-colors.ts

@@ -0,0 +1,21 @@
+const COPPER_LAYER_COLORS = [
+  "#ef4444",
+  "#2563eb",
+  "#16a34a",
+  "#9333ea",
+  "#f59e0b",
+  "#0891b2",
+  "#db2777",
+  "#65a30d",
+  "#4f46e5",
+  "#ea580c",
+] as const
+
+export function getCopperLayerColor(layerIndex: number): string {
+  if (!Number.isInteger(layerIndex) || layerIndex < 0) {
+    throw new Error(
+      `FanoutSolver: copper layer index must be a non-negative integer, received ${layerIndex}`,
+    )
+  }
+  return COPPER_LAYER_COLORS[layerIndex % COPPER_LAYER_COLORS.length]!
+}

package/lib/layer-names.ts

@@ -0,0 +1,137 @@
+export function getCopperLayerNames(layerCount: number): string[] {
+  if (!Number.isInteger(layerCount) || layerCount < 1) {
+    throw new Error(
+      `FanoutSolver: layerCount must be a positive integer, received ${layerCount}`,
+    )
+  }
+  if (layerCount === 1) return ["top"]
+  if (layerCount === 2) return ["top", "bottom"]
+
+  return [
+    "top",
+    ...Array.from(
+      { length: layerCount - 2 },
+      (_, index) => `inner${index + 1}`,
+    ),
+    "bottom",
+  ]
+}
+
+export function getLayerSpan(
+  fromLayer: string,
+  toLayer: string,
+  layerNames: string[],
+): string[] {
+  const fromIndex = layerNames.indexOf(fromLayer)
+  const toIndex = layerNames.indexOf(toLayer)
+  if (fromIndex < 0 || toIndex < 0) {
+    throw new Error(
+      `FanoutSolver: cannot build via span from "${fromLayer}" to "${toLayer}"`,
+    )
+  }
+  const firstIndex = Math.min(fromIndex, toIndex)
+  const lastIndex = Math.max(fromIndex, toIndex)
+  return layerNames.slice(firstIndex, lastIndex + 1)
+}
+
+export function generateLayerAssignments(params: {
+  busIds: string[]
+  layers: string[]
+  maxAssignments: number
+}): Array<Readonly<Record<string, string>>> {
+  const { busIds, layers, maxAssignments } = params
+  if (layers.length === 0) {
+    throw new Error("FanoutSolver: no escape layers are available")
+  }
+  if (!Number.isInteger(maxAssignments) || maxAssignments < 1) {
+    throw new Error(
+      `FanoutSolver: maxLayerCombinations must be positive, received ${maxAssignments}`,
+    )
+  }
+
+  const rawCombinationCount = layers.length ** busIds.length
+  const combinationCount = Math.min(
+    maxAssignments,
+    Number.isFinite(rawCombinationCount) ? rawCombinationCount : maxAssignments,
+  )
+  const assignments: Array<Readonly<Record<string, string>>> = []
+  const seenAssignments = new Set<string>()
+
+  function addAssignment(layerIndexes: number[]): void {
+    const assignment: Record<string, string> = {}
+    for (let busIndex = 0; busIndex < busIds.length; busIndex++) {
+      assignment[busIds[busIndex]!] = layers[layerIndexes[busIndex]!]!
+    }
+    const key = JSON.stringify(assignment)
+    if (seenAssignments.has(key)) return
+    seenAssignments.add(key)
+    assignments.push(assignment)
+  }
+
+  if (rawCombinationCount <= maxAssignments) {
+    for (let ordinal = 0; ordinal < combinationCount; ordinal++) {
+      const layerIndexes: number[] = []
+      let remaining = ordinal
+      for (let busIndex = 0; busIndex < busIds.length; busIndex++) {
+        const digit = remaining % layers.length
+        remaining = Math.floor(remaining / layers.length)
+        layerIndexes.push((digit + busIndex) % layers.length)
+      }
+      addAssignment(layerIndexes)
+    }
+    return assignments
+  }
+
+  function mix32(value: number): number {
+    let mixed = value | 0
+    mixed = Math.imul(mixed ^ (mixed >>> 16), 0x21f0aaad)
+    mixed = Math.imul(mixed ^ (mixed >>> 15), 0x735a2d97)
+    return (mixed ^ (mixed >>> 15)) >>> 0
+  }
+
+  const balancedLayerIndexes = busIds.map(
+    (_, busIndex) => busIndex % layers.length,
+  )
+  addAssignment(balancedLayerIndexes)
+  for (
+    let globalShift = 1;
+    globalShift < layers.length && assignments.length < combinationCount;
+    globalShift++
+  ) {
+    addAssignment(
+      balancedLayerIndexes.map(
+        (layerIndex) => (layerIndex + globalShift) % layers.length,
+      ),
+    )
+  }
+  for (
+    let busIndex = 0;
+    busIndex < busIds.length && assignments.length < combinationCount;
+    busIndex++
+  ) {
+    for (
+      let shift = 1;
+      shift < layers.length && assignments.length < combinationCount;
+      shift++
+    ) {
+      const layerIndexes = [...balancedLayerIndexes]
+      layerIndexes[busIndex] =
+        (balancedLayerIndexes[busIndex]! + shift) % layers.length
+      addAssignment(layerIndexes)
+    }
+  }
+  for (
+    let seed = 1;
+    assignments.length < combinationCount && seed < combinationCount * 20;
+    seed++
+  ) {
+    addAssignment(
+      busIds.map(
+        (_, busIndex) =>
+          mix32(seed * 0x9e3779b1 + busIndex * 0x85ebca6b) % layers.length,
+      ),
+    )
+  }
+
+  return assignments
+}