@tscircuit/curvy-trace-solver 0.0.3 → 0.0.4

package/lib/geometry/getObstacleOuterSegments.ts

@@ -1,25 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

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

package/lib/problem-generator/countChordCrossings.ts

@@ -1,119 +0,0 @@
-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

@@ -1,13 +0,0 @@
-/**
- * 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

@@ -1,225 +0,0 @@
-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

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

package/lib/problem-generator/randomBoundaryPoint.ts

@@ -1,30 +0,0 @@
-/**
- * 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

@@ -1,16 +0,0 @@
-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

@@ -1,62 +0,0 @@
-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

@@ -1,116 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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"