@tscircuit/curvy-trace-solver 0.0.1

package/lib/geometry/getObstacleOuterSegments.ts

@@ -0,0 +1,25 @@
+import type { Point } from "@tscircuit/math-utils"
+import type { Obstacle } from "lib/types"
+
+export const getObstacleOuterSegments = (obstacle: Obstacle) => {
+  const segments: [Point, Point][] = [
+    [
+      { x: obstacle.minX, y: obstacle.minY },
+      { x: obstacle.maxX, y: obstacle.minY },
+    ],
+    [
+      { x: obstacle.maxX, y: obstacle.minY },
+      { x: obstacle.maxX, y: obstacle.maxY },
+    ],
+    [
+      { x: obstacle.maxX, y: obstacle.maxY },
+      { x: obstacle.minX, y: obstacle.maxY },
+    ],
+    [
+      { x: obstacle.minX, y: obstacle.maxY },
+      { x: obstacle.minX, y: obstacle.minY },
+    ],
+  ]
+
+  return segments
+}

package/lib/geometry/index.ts

@@ -0,0 +1,8 @@
+import type { Bounds } from "@tscircuit/math-utils"
+
+export const getBoundsCenter = (bounds: Bounds) => {
+  return {
+    x: (bounds.minX + bounds.maxX) / 2,
+    y: (bounds.minY + bounds.maxY) / 2,
+  }
+}

package/lib/index.ts

@@ -0,0 +1,2 @@
+export * from "./CurvyTraceSolver"
+export * from "./types"

package/lib/problem-generator/countChordCrossings.ts

@@ -0,0 +1,119 @@
+import type { WaypointPair } from "lib/types"
+
+/**
+ * Maps a boundary point to a 1D perimeter coordinate.
+ * Starting at top-left corner, going clockwise:
+ * - Top edge (y=ymax): t = x - xmin
+ * - Right edge (x=xmax): t = W + (ymax - y)
+ * - Bottom edge (y=ymin): t = 2W + H + (xmax - x)
+ * - Left edge (x=xmin): t = 2W + 2H + (y - ymin)
+ */
+export function perimeterT(
+  p: { x: number; y: number },
+  xmin: number,
+  xmax: number,
+  ymin: number,
+  ymax: number,
+): number {
+  const W = xmax - xmin
+  const H = ymax - ymin
+  const eps = 1e-6
+
+  // Top edge
+  if (Math.abs(p.y - ymax) < eps) {
+    return p.x - xmin
+  }
+  // Right edge
+  if (Math.abs(p.x - xmax) < eps) {
+    return W + (ymax - p.y)
+  }
+  // Bottom edge
+  if (Math.abs(p.y - ymin) < eps) {
+    return W + H + (xmax - p.x)
+  }
+  // Left edge
+  if (Math.abs(p.x - xmin) < eps) {
+    return 2 * W + H + (p.y - ymin)
+  }
+
+  // Point is not exactly on boundary - find closest edge
+  const distTop = Math.abs(p.y - ymax)
+  const distRight = Math.abs(p.x - xmax)
+  const distBottom = Math.abs(p.y - ymin)
+  const distLeft = Math.abs(p.x - xmin)
+
+  const minDist = Math.min(distTop, distRight, distBottom, distLeft)
+
+  if (minDist === distTop) {
+    return Math.max(0, Math.min(W, p.x - xmin))
+  }
+  if (minDist === distRight) {
+    return W + Math.max(0, Math.min(H, ymax - p.y))
+  }
+  if (minDist === distBottom) {
+    return W + H + Math.max(0, Math.min(W, xmax - p.x))
+  }
+  // Left edge
+  return 2 * W + H + Math.max(0, Math.min(H, p.y - ymin))
+}
+
+/**
+ * Check if two perimeter coordinates are coincident (within epsilon)
+ */
+function areCoincident(t1: number, t2: number, eps: number = 1e-6): boolean {
+  return Math.abs(t1 - t2) < eps
+}
+
+/**
+ * Check if two chords cross using the interleaving criterion.
+ * Two chords (a,b) and (c,d) with a < b and c < d cross iff: a < c < b < d OR c < a < d < b
+ *
+ * Chords that share a coincident endpoint do NOT count as crossing.
+ */
+export function chordsCross(
+  chord1: [number, number],
+  chord2: [number, number],
+): boolean {
+  // Normalize each chord so first endpoint is smaller
+  const [a, b] = chord1[0] < chord1[1] ? chord1 : [chord1[1], chord1[0]]
+  const [c, d] = chord2[0] < chord2[1] ? chord2 : [chord2[1], chord2[0]]
+
+  // Skip if chords share a coincident endpoint
+  if (
+    areCoincident(a, c) ||
+    areCoincident(a, d) ||
+    areCoincident(b, c) ||
+    areCoincident(b, d)
+  ) {
+    return false
+  }
+
+  // Two chords cross iff their endpoints interleave: a < c < b < d OR c < a < d < b
+  return (a < c && c < b && b < d) || (c < a && a < d && d < b)
+}
+
+export const countChordCrossings = (
+  waypointPairs: WaypointPair[],
+  bounds: { minX: number; maxX: number; minY: number; maxY: number },
+): number => {
+  const { minX: xmin, maxX: xmax, minY: ymin, maxY: ymax } = bounds
+
+  // Map all waypoint pairs to perimeter coordinates (t)
+  const chords: [number, number][] = waypointPairs.map((pair) => {
+    const t1 = perimeterT(pair.start, xmin, xmax, ymin, ymax)
+    const t2 = perimeterT(pair.end, xmin, xmax, ymin, ymax)
+    return [t1, t2]
+  })
+
+  // Count all crossings between unique pairs
+  let crossings = 0
+  for (let i = 0; i < chords.length; i++) {
+    for (let j = i + 1; j < chords.length; j++) {
+      if (chordsCross(chords[i], chords[j])) {
+        crossings++
+      }
+    }
+  }
+
+  return crossings
+}

package/lib/problem-generator/createRng.ts

@@ -0,0 +1,13 @@
+/**
+ * Simple seeded random number generator (mulberry32)
+ */
+export function createRng(seed: number) {
+  let state = seed
+  return () => {
+    state |= 0
+    state = (state + 0x6d2b79f5) | 0
+    let t = Math.imul(state ^ (state >>> 15), 1 | state)
+    t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296
+  }
+}

package/lib/problem-generator/generateRandomProblem.ts

@@ -0,0 +1,225 @@
+import type { Bounds } from "@tscircuit/math-utils"
+import type { CurvyTraceProblem, Obstacle, WaypointPair } from "lib/types"
+import { perimeterT } from "./countChordCrossings"
+import { createRng } from "./createRng"
+import { randomBoundaryPoint } from "./randomBoundaryPoint"
+import { wouldCrossAny } from "./wouldCrossAny"
+
+type Side = "top" | "bottom" | "left" | "right"
+
+/**
+ * Check if two obstacles overlap.
+ */
+const obstaclesOverlap = (a: Obstacle, b: Obstacle): boolean => {
+  return !(
+    a.maxX <= b.minX ||
+    a.minX >= b.maxX ||
+    a.maxY <= b.minY ||
+    a.minY >= b.maxY
+  )
+}
+
+/**
+ * Generate an obstacle that is outside the bounds but touching a specific side.
+ * The obstacle takes up at least 10% of the side it's touching.
+ */
+const generateObstacleOnSide = (
+  rng: () => number,
+  bounds: Bounds,
+  side: Side,
+): Obstacle => {
+  const { minX, maxX, minY, maxY } = bounds
+  const W = maxX - minX
+  const H = maxY - minY
+
+  // Obstacle depth (how far it extends outside the bounds)
+  const minDepth = Math.min(W, H) * 0.1
+  const maxDepth = Math.min(W, H) * 0.3
+  const depth = minDepth + rng() * (maxDepth - minDepth)
+
+  let obstacleMinX: number
+  let obstacleMaxX: number
+  let obstacleMinY: number
+  let obstacleMaxY: number
+
+  if (side === "top" || side === "bottom") {
+    // Obstacle spans horizontally along top or bottom
+    const minSpan = W * 0.1 // At least 10% of the side
+    const maxSpan = W * 0.4 // Up to 40% of the side
+    const span = minSpan + rng() * (maxSpan - minSpan)
+
+    // Random position along the side (ensuring it fits within bounds)
+    const startX = minX + rng() * (W - span)
+    obstacleMinX = startX
+    obstacleMaxX = startX + span
+
+    if (side === "top") {
+      obstacleMinY = maxY
+      obstacleMaxY = maxY + depth
+    } else {
+      obstacleMinY = minY - depth
+      obstacleMaxY = minY
+    }
+  } else {
+    // Obstacle spans vertically along left or right
+    const minSpan = H * 0.1 // At least 10% of the side
+    const maxSpan = H * 0.4 // Up to 40% of the side
+    const span = minSpan + rng() * (maxSpan - minSpan)
+
+    // Random position along the side (ensuring it fits within bounds)
+    const startY = minY + rng() * (H - span)
+    obstacleMinY = startY
+    obstacleMaxY = startY + span
+
+    if (side === "right") {
+      obstacleMinX = maxX
+      obstacleMaxX = maxX + depth
+    } else {
+      obstacleMinX = minX - depth
+      obstacleMaxX = minX
+    }
+  }
+
+  return {
+    minX: obstacleMinX,
+    maxX: obstacleMaxX,
+    minY: obstacleMinY,
+    maxY: obstacleMaxY,
+    center: {
+      x: (obstacleMinX + obstacleMaxX) / 2,
+      y: (obstacleMinY + obstacleMaxY) / 2,
+    },
+  }
+}
+
+export const generateRandomProblem = (opts: {
+  numWaypointPairs: number
+  numObstacles: number
+  randomSeed: number
+  bounds?: Bounds
+  preferredSpacing?: number
+  /**
+   * Minimum spacing between a waypoint point and any other waypoint point.
+   */
+  minSpacing?: number
+}): CurvyTraceProblem => {
+
+  const rng = createRng(opts.randomSeed)
+
+  const bounds = opts.bounds ?? { minX: 0, maxX: 100, minY: 0, maxY: 100 }
+  const { minX: xmin, maxX: xmax, minY: ymin, maxY: ymax } = bounds
+  const W = xmax - xmin
+  const H = ymax - ymin
+  const perimeter = 2 * W + 2 * H
+
+  const waypointPairs: WaypointPair[] = []
+  const chords: [number, number][] = []
+
+  const MAX_ATTEMPTS = 1000
+
+  for (let i = 0; i < opts.numWaypointPairs; i++) {
+    let attempts = 0
+    let start: { x: number; y: number } | null = null
+    let end: { x: number; y: number } | null = null
+    let newChord: [number, number] | null = null
+
+    while (attempts < MAX_ATTEMPTS) {
+      // Generate two random boundary points
+      start = randomBoundaryPoint(rng, xmin, xmax, ymin, ymax)
+      end = randomBoundaryPoint(rng, xmin, xmax, ymin, ymax)
+
+      // Convert to perimeter t values using existing utility
+      const t1 = perimeterT(start, xmin, xmax, ymin, ymax)
+      const t2 = perimeterT(end, xmin, xmax, ymin, ymax)
+
+      // Ensure the two points aren't too close together
+      const minSeparation = perimeter * 0.05
+      const dist = Math.min(Math.abs(t1 - t2), perimeter - Math.abs(t1 - t2))
+      if (dist < minSeparation) {
+        attempts++
+        continue
+      }
+
+      newChord = [t1, t2]
+
+      // Check minSpacing constraint against all existing waypoint points
+      if (opts.minSpacing !== undefined) {
+        let tooClose = false
+        for (const pair of waypointPairs) {
+          const dStart1 = Math.hypot(start.x - pair.start.x, start.y - pair.start.y)
+          const dStart2 = Math.hypot(start.x - pair.end.x, start.y - pair.end.y)
+          const dEnd1 = Math.hypot(end.x - pair.start.x, end.y - pair.start.y)
+          const dEnd2 = Math.hypot(end.x - pair.end.x, end.y - pair.end.y)
+          if (dStart1 < opts.minSpacing || dStart2 < opts.minSpacing ||
+              dEnd1 < opts.minSpacing || dEnd2 < opts.minSpacing) {
+            tooClose = true
+            break
+          }
+        }
+        if (tooClose) {
+          attempts++
+          continue
+        }
+      }
+
+      // Check if this chord would cross any existing chords
+      if (!wouldCrossAny(newChord, chords)) {
+        break
+      }
+
+      newChord = null
+      attempts++
+    }
+
+    if (newChord === null || start === null || end === null) {
+      throw new Error(
+        `Failed to generate non-crossing waypoint pair after ${MAX_ATTEMPTS} attempts. ` +
+          `This may happen if too many waypoint pairs are requested.`,
+      )
+    }
+
+    chords.push(newChord)
+    waypointPairs.push({ start, end, networkId: `net${i}` })
+  }
+
+  // Generate obstacles outside the bounds but touching them
+  const obstacles: Obstacle[] = []
+  const sides: Side[] = ["top", "bottom", "left", "right"]
+
+  for (let i = 0; i < opts.numObstacles; i++) {
+    let attempts = 0
+    let obstacle: Obstacle | null = null
+
+    while (attempts < MAX_ATTEMPTS) {
+      // Pick a random side for this obstacle
+      const side = sides[Math.floor(rng() * sides.length)]
+      const candidate = generateObstacleOnSide(rng, bounds, side)
+
+      // Check if it overlaps with any existing obstacle
+      const overlaps = obstacles.some((existing) =>
+        obstaclesOverlap(candidate, existing),
+      )
+
+      if (!overlaps) {
+        obstacle = candidate
+        break
+      }
+
+      attempts++
+    }
+
+    if (obstacle === null) {
+      // Could not place obstacle without overlap, skip it
+      break
+    }
+
+    obstacles.push(obstacle)
+  }
+
+  return {
+    bounds,
+    waypointPairs,
+    obstacles,
+    preferredSpacing: opts.preferredSpacing ?? 10,
+  }
+}

package/lib/problem-generator/index.ts

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

package/lib/problem-generator/randomBoundaryPoint.ts

@@ -0,0 +1,30 @@
+/**
+ * Generate a random point on the boundary of the rectangle
+ */
+export function randomBoundaryPoint(
+  rng: () => number,
+  xmin: number,
+  xmax: number,
+  ymin: number,
+  ymax: number,
+): { x: number; y: number } {
+  const W = xmax - xmin
+  const H = ymax - ymin
+  const perimeter = 2 * W + 2 * H
+  const t = rng() * perimeter
+
+  // Top edge: t in [0, W)
+  if (t < W) {
+    return { x: xmin + t, y: ymax }
+  }
+  // Right edge: t in [W, W + H)
+  if (t < W + H) {
+    return { x: xmax, y: ymax - (t - W) }
+  }
+  // Bottom edge: t in [W + H, 2W + H)
+  if (t < 2 * W + H) {
+    return { x: xmax - (t - W - H), y: ymin }
+  }
+  // Left edge: t in [2W + H, 2W + 2H)
+  return { x: xmin, y: ymin + (t - 2 * W - H) }
+}

package/lib/problem-generator/wouldCrossAny.ts

@@ -0,0 +1,16 @@
+import { chordsCross } from "./countChordCrossings"
+
+/**
+ * Check if a new chord would cross any existing chords
+ */
+export function wouldCrossAny(
+  newChord: [number, number],
+  existingChords: [number, number][],
+): boolean {
+  for (const existing of existingChords) {
+    if (chordsCross(newChord, existing)) {
+      return true
+    }
+  }
+  return false
+}

package/lib/sampleTraceIntoSegments.ts

@@ -0,0 +1,62 @@
+import type { Point } from "@tscircuit/math-utils"
+
+/**
+ * Samples a trace (array of points) into evenly-spaced segments.
+ * This is useful for limiting computation when comparing traces.
+ */
+export const sampleTraceIntoSegments = (
+  points: Point[],
+  numSegments: number,
+  networkId?: string,
+): { segment: [Point, Point]; networkId?: string }[] => {
+  if (points.length < 2) return []
+
+  // Compute total length of the trace
+  let totalLength = 0
+  for (let i = 0; i < points.length - 1; i++) {
+    const dx = points[i + 1].x - points[i].x
+    const dy = points[i + 1].y - points[i].y
+    totalLength += Math.sqrt(dx * dx + dy * dy)
+  }
+
+  if (totalLength === 0) return []
+
+  const segmentLength = totalLength / numSegments
+  const sampledPoints: Point[] = [points[0]]
+
+  let currentLength = 0
+  let pointIndex = 0
+
+  for (let i = 1; i <= numSegments; i++) {
+    const targetLength = i * segmentLength
+
+    while (pointIndex < points.length - 1) {
+      const dx = points[pointIndex + 1].x - points[pointIndex].x
+      const dy = points[pointIndex + 1].y - points[pointIndex].y
+      const segLen = Math.sqrt(dx * dx + dy * dy)
+
+      if (currentLength + segLen >= targetLength) {
+        const t = (targetLength - currentLength) / segLen
+        sampledPoints.push({
+          x: points[pointIndex].x + t * dx,
+          y: points[pointIndex].y + t * dy,
+        })
+        break
+      }
+
+      currentLength += segLen
+      pointIndex++
+    }
+  }
+
+  // Convert sampled points to segments
+  const segments: { segment: [Point, Point]; networkId?: string }[] = []
+  for (let i = 0; i < sampledPoints.length - 1; i++) {
+    segments.push({
+      segment: [sampledPoints[i], sampledPoints[i + 1]],
+      networkId,
+    })
+  }
+
+  return segments
+}

package/lib/scoreOutputCost.ts

@@ -0,0 +1,116 @@
+import type { CurvyTraceProblem, OutputTrace } from "./types"
+import type { Point } from "@tscircuit/math-utils"
+import { segmentToSegmentMinDistance } from "@tscircuit/math-utils"
+import { sampleTraceIntoSegments } from "./sampleTraceIntoSegments"
+
+/**
+ * Returns a cost for a solution, lower is better output
+ *
+ * The cost is computed by sampling the output traces into samplesPerTrace
+ * segments, then computing the minimum segment to segment distance to all
+ * other-network segments in the output and obstacles. Beyond
+ * problem.preferredSpacing the cost is 0. The max segment-to-segment cost
+ * is problem.preferredSpacing**2
+ *
+ * If a segment intersects any segment from a different net, an additional
+ * penalty of samplesPerTrace * preferredSpacing**2 is added.
+ */
+export const scoreOutputCost = ({
+  problem,
+  outputTraces,
+  samplesPerTrace = 20,
+}: {
+  problem: CurvyTraceProblem
+  outputTraces: OutputTrace[]
+  samplesPerTrace?: number
+}): number => {
+  const { preferredSpacing, obstacles } = problem
+
+  // Collect all trace segments
+  const allTraceSegments: { segment: [Point, Point]; networkId?: string }[] = []
+  for (const trace of outputTraces) {
+    const segments = sampleTraceIntoSegments(
+      trace.points,
+      samplesPerTrace,
+      trace.networkId,
+    )
+    allTraceSegments.push(...segments)
+  }
+
+  // Collect all obstacle segments
+  const allObstacleSegments: { segment: [Point, Point]; networkId?: string }[] =
+    []
+  for (const obstacle of obstacles) {
+    if (obstacle.outerSegments) {
+      for (const seg of obstacle.outerSegments) {
+        allObstacleSegments.push({
+          segment: seg,
+          networkId: obstacle.networkId,
+        })
+      }
+    }
+  }
+
+  // Compute total cost
+  let totalCost = 0
+
+  for (let i = 0; i < allTraceSegments.length; i++) {
+    const seg1 = allTraceSegments[i]
+
+    // Check against other trace segments (different network)
+    for (let j = i + 1; j < allTraceSegments.length; j++) {
+      const seg2 = allTraceSegments[j]
+
+      // Skip if same network (traces in same network are allowed to intersect)
+      if (
+        seg1.networkId &&
+        seg2.networkId &&
+        seg1.networkId === seg2.networkId
+      ) {
+        continue
+      }
+
+      const dist = segmentToSegmentMinDistance(
+        seg1.segment[0],
+        seg1.segment[1],
+        seg2.segment[0],
+        seg2.segment[1],
+      )
+      if (dist < preferredSpacing) {
+        totalCost += (preferredSpacing - dist) ** 2
+      }
+      // Add cross-net intersection penalty
+      if (dist < 1e-9) {
+        totalCost += samplesPerTrace * preferredSpacing ** 2
+      }
+    }
+
+    // Check against obstacle segments (different network)
+    for (const obsSeg of allObstacleSegments) {
+      // Skip if same network
+      if (
+        seg1.networkId &&
+        obsSeg.networkId &&
+        seg1.networkId === obsSeg.networkId
+      ) {
+        continue
+      }
+
+      const dist = segmentToSegmentMinDistance(
+        seg1.segment[0],
+        seg1.segment[1],
+        obsSeg.segment[0],
+        obsSeg.segment[1],
+      )
+      if (dist < preferredSpacing) {
+        totalCost += (preferredSpacing - dist) ** 2
+      }
+      // Add cross-net intersection penalty
+      if (dist < 1e-9) {
+        totalCost += samplesPerTrace * preferredSpacing ** 2
+      }
+    }
+  }
+
+  return totalCost
+}

package/lib/types.ts

@@ -0,0 +1,35 @@
+import type { Point, Bounds } from "@tscircuit/math-utils"
+
+// Point: { x: number, y: number }
+// Bounds: { minX: number, minY: number, maxX: number, maxY: number }
+
+export interface WaypointPair {
+  start: Point
+  end: Point
+
+  // Waypoints may be part of the same network- in these cases they are allowed
+  // to intersect with each other
+  networkId?: string
+}
+
+export interface Obstacle extends Bounds {
+  center: Point
+
+  networkId?: string
+
+  // Computed prior to the solver running
+  outerSegments?: [Point, Point][]
+}
+
+export interface CurvyTraceProblem {
+  bounds: Bounds
+  waypointPairs: WaypointPair[]
+  obstacles: Obstacle[]
+  preferredSpacing: number
+}
+
+export interface OutputTrace {
+  waypointPair: WaypointPair
+  points: Point[]
+  networkId?: string
+}

package/lib/visualization-utils/index.ts

@@ -0,0 +1,14 @@
+export const hashString = (str: string) => {
+  let hash = 0
+  for (let i = 0; i < str.length; i++) {
+    hash = str.charCodeAt(i) * 779 + ((hash << 5) - hash)
+  }
+  return hash
+}
+
+export const getColorForNetworkId = (networkId?: string | null) => {
+  if (!networkId) return "rgba(0, 0, 0, 0.5)"
+  return `hsl(${hashString(networkId) % 360}, 100%, 50%)`
+}
+
+export { visualizeCurvyTraceProblem } from "./visualizeCurvyTraceProblem"