@tscircuit/rectdiff 0.0.9 → 0.0.11

package/lib/solvers/rectdiff/gapfill/detection/mergeUncoveredCells.ts

@@ -1,75 +0,0 @@
-// lib/solvers/rectdiff/gapfill/detection/mergeUncoveredCells.ts
-import type { XYRect } from "../../types"
-import { EPS } from "../../geometry"
-
-/**
- * Merge adjacent uncovered cells into larger rectangles using a greedy approach.
- */
-export function mergeUncoveredCells(
-  cells: Array<{ x: number; y: number; w: number; h: number }>,
-): XYRect[] {
-  if (cells.length === 0) return []
-
-  // Group cells by their left edge and width
-  const byXW = new Map<string, typeof cells>()
-  for (const c of cells) {
-    const key = `${c.x.toFixed(9)}|${c.w.toFixed(9)}`
-    const arr = byXW.get(key) ?? []
-    arr.push(c)
-    byXW.set(key, arr)
-  }
-
-  // Within each vertical strip, merge adjacent cells
-  const verticalStrips: XYRect[] = []
-  for (const stripCells of byXW.values()) {
-    // Sort by y
-    stripCells.sort((a, b) => a.y - b.y)
-
-    let current: XYRect | null = null
-    for (const c of stripCells) {
-      if (!current) {
-        current = { x: c.x, y: c.y, width: c.w, height: c.h }
-      } else if (Math.abs(current.y + current.height - c.y) < EPS) {
-        // Adjacent vertically, merge
-        current.height += c.h
-      } else {
-        // Gap, save current and start new
-        verticalStrips.push(current)
-        current = { x: c.x, y: c.y, width: c.w, height: c.h }
-      }
-    }
-    if (current) verticalStrips.push(current)
-  }
-
-  // Now try to merge horizontal strips with same y and height
-  const byYH = new Map<string, XYRect[]>()
-  for (const r of verticalStrips) {
-    const key = `${r.y.toFixed(9)}|${r.height.toFixed(9)}`
-    const arr = byYH.get(key) ?? []
-    arr.push(r)
-    byYH.set(key, arr)
-  }
-
-  const merged: XYRect[] = []
-  for (const rowRects of byYH.values()) {
-    // Sort by x
-    rowRects.sort((a, b) => a.x - b.x)
-
-    let current: XYRect | null = null
-    for (const r of rowRects) {
-      if (!current) {
-        current = { ...r }
-      } else if (Math.abs(current.x + current.width - r.x) < EPS) {
-        // Adjacent horizontally, merge
-        current.width += r.width
-      } else {
-        // Gap, save current and start new
-        merged.push(current)
-        current = { ...r }
-      }
-    }
-    if (current) merged.push(current)
-  }
-
-  return merged
-}

package/lib/solvers/rectdiff/gapfill/detection.ts

@@ -1,3 +0,0 @@
-// lib/solvers/rectdiff/gapfill/detection.ts
-export * from "./detection/findAllGaps"
-// findGapsOnLayer is not exported as it's only used by findAllGaps

package/lib/solvers/rectdiff/gapfill/engine/addPlacement.ts

@@ -1,27 +0,0 @@
-// lib/solvers/rectdiff/gapfill/engine/addPlacement.ts
-import type { Placed3D, XYRect } from "../../types"
-import type { GapFillState } from "../types"
-
-/**
- * Add a new placement to the state.
- */
-export function addPlacement(
-  state: GapFillState,
-  {
-    rect,
-    zLayers,
-  }: {
-    rect: XYRect
-    zLayers: number[]
-  },
-): void {
-  const placed: Placed3D = { rect, zLayers: [...zLayers] }
-  state.placed.push(placed)
-
-  for (const z of zLayers) {
-    if (!state.placedByLayer[z]) {
-      state.placedByLayer[z] = []
-    }
-    state.placedByLayer[z]!.push(rect)
-  }
-}

package/lib/solvers/rectdiff/gapfill/engine/calculateCoverage.ts

@@ -1,44 +0,0 @@
-// lib/solvers/rectdiff/gapfill/engine/calculateCoverage.ts
-import type { LayerContext } from "../types"
-
-/**
- * Calculate coverage percentage (0-1).
- */
-export function calculateCoverage(
-  { sampleResolution = 0.1 }: { sampleResolution?: number },
-  ctx: LayerContext,
-): number {
-  const { bounds, layerCount, obstaclesByLayer, placedByLayer } = ctx
-
-  let totalPoints = 0
-  let coveredPoints = 0
-
-  for (let z = 0; z < layerCount; z++) {
-    const obstacles = obstaclesByLayer[z] ?? []
-    const placed = placedByLayer[z] ?? []
-    const allRects = [...obstacles, ...placed]
-
-    for (
-      let x = bounds.x;
-      x <= bounds.x + bounds.width;
-      x += sampleResolution
-    ) {
-      for (
-        let y = bounds.y;
-        y <= bounds.y + bounds.height;
-        y += sampleResolution
-      ) {
-        totalPoints++
-
-        const isCovered = allRects.some(
-          (r) =>
-            x >= r.x && x <= r.x + r.width && y >= r.y && y <= r.y + r.height,
-        )
-
-        if (isCovered) coveredPoints++
-      }
-    }
-  }
-
-  return totalPoints > 0 ? coveredPoints / totalPoints : 1
-}

package/lib/solvers/rectdiff/gapfill/engine/findUncoveredPoints.ts

@@ -1,43 +0,0 @@
-// lib/solvers/rectdiff/gapfill/engine/findUncoveredPoints.ts
-import type { LayerContext } from "../types"
-
-/**
- * Find uncovered points for debugging gaps.
- */
-export function findUncoveredPoints(
-  { sampleResolution = 0.05 }: { sampleResolution?: number },
-  ctx: LayerContext,
-): Array<{ x: number; y: number; z: number }> {
-  const { bounds, layerCount, obstaclesByLayer, placedByLayer } = ctx
-
-  const uncovered: Array<{ x: number; y: number; z: number }> = []
-
-  for (let z = 0; z < layerCount; z++) {
-    const obstacles = obstaclesByLayer[z] ?? []
-    const placed = placedByLayer[z] ?? []
-    const allRects = [...obstacles, ...placed]
-
-    for (
-      let x = bounds.x;
-      x <= bounds.x + bounds.width;
-      x += sampleResolution
-    ) {
-      for (
-        let y = bounds.y;
-        y <= bounds.y + bounds.height;
-        y += sampleResolution
-      ) {
-        const isCovered = allRects.some(
-          (r) =>
-            x >= r.x && x <= r.x + r.width && y >= r.y && y <= r.y + r.height,
-        )
-
-        if (!isCovered) {
-          uncovered.push({ x, y, z })
-        }
-      }
-    }
-  }
-
-  return uncovered
-}

package/lib/solvers/rectdiff/gapfill/engine/getGapFillProgress.ts

@@ -1,42 +0,0 @@
-// lib/solvers/rectdiff/gapfill/engine/getGapFillProgress.ts
-import type { GapFillState } from "../types"
-
-/**
- * Get progress as a number between 0 and 1.
- * Accounts for four-stage processing (scan → select → expand → place for each gap).
- */
-export function getGapFillProgress(state: GapFillState): number {
-  if (state.done) return 1
-
-  const iterationProgress = state.iteration / state.options.maxIterations
-  const gapProgress =
-    state.gapsFound.length > 0 ? state.gapIndex / state.gapsFound.length : 0
-
-  // Add sub-progress within current gap based on stage
-  let stageProgress = 0
-  switch (state.stage) {
-    case "scan":
-      stageProgress = 0
-      break
-    case "select":
-      stageProgress = 0.25
-      break
-    case "expand":
-      stageProgress = 0.5
-      break
-    case "place":
-      stageProgress = 0.75
-      break
-  }
-
-  const gapStageProgress =
-    state.gapsFound.length > 0
-      ? stageProgress / (state.gapsFound.length * 4) // 4 stages per gap
-      : 0
-
-  return Math.min(
-    0.999,
-    iterationProgress +
-      (gapProgress + gapStageProgress) / state.options.maxIterations,
-  )
-}

package/lib/solvers/rectdiff/gapfill/engine/initGapFillState.ts

@@ -1,57 +0,0 @@
-// lib/solvers/rectdiff/gapfill/engine/initGapFillState.ts
-import type { Placed3D } from "../../types"
-import type { GapFillState, GapFillOptions, LayerContext } from "../types"
-
-const DEFAULT_OPTIONS: GapFillOptions = {
-  minWidth: 0.1,
-  minHeight: 0.1,
-  maxIterations: 10,
-  targetCoverage: 0.999,
-  scanResolution: 0.5,
-}
-
-/**
- * Initialize the gap fill state from existing rectdiff state.
- */
-export function initGapFillState(
-  {
-    placed,
-    options,
-  }: {
-    placed: Placed3D[]
-    options?: Partial<GapFillOptions>
-  },
-  ctx: LayerContext,
-): GapFillState {
-  const opts = { ...DEFAULT_OPTIONS, ...options }
-
-  // Deep copy placed arrays to avoid mutation issues
-  const placedCopy = placed.map((p) => ({
-    rect: { ...p.rect },
-    zLayers: [...p.zLayers],
-  }))
-
-  const placedByLayerCopy = ctx.placedByLayer.map((layer) =>
-    layer.map((r) => ({ ...r })),
-  )
-
-  return {
-    bounds: { ...ctx.bounds },
-    layerCount: ctx.layerCount,
-    obstaclesByLayer: ctx.obstaclesByLayer,
-    placed: placedCopy,
-    placedByLayer: placedByLayerCopy,
-    options: opts,
-    iteration: 0,
-    gapsFound: [],
-    gapIndex: 0,
-    done: false,
-    initialGapCount: 0,
-    filledCount: 0,
-    // Four-stage visualization state
-    stage: "scan",
-    currentGap: null,
-    currentSeed: null,
-    expandedRect: null,
-  }
-}

package/lib/solvers/rectdiff/gapfill/engine/stepGapFill.ts

@@ -1,128 +0,0 @@
-// lib/solvers/rectdiff/gapfill/engine/stepGapFill.ts
-import type { GapFillState } from "../types"
-import { findAllGaps } from "../detection"
-import { tryExpandGap } from "./tryExpandGap"
-import { addPlacement } from "./addPlacement"
-
-/**
- * Perform one step of gap filling with four-stage visualization.
- * Stages: scan → select → expand → place
- * Returns true if still working, false if done.
- */
-export function stepGapFill(state: GapFillState): boolean {
-  if (state.done) return false
-
-  switch (state.stage) {
-    case "scan": {
-      // Stage 1: Gap detection/scanning
-
-      // Check if we need to find new gaps
-      if (
-        state.gapsFound.length === 0 ||
-        state.gapIndex >= state.gapsFound.length
-      ) {
-        // Check if we've hit max iterations
-        if (state.iteration >= state.options.maxIterations) {
-          state.done = true
-          return false
-        }
-
-        // Find new gaps
-        state.gapsFound = findAllGaps(
-          {
-            scanResolution: state.options.scanResolution,
-            minWidth: state.options.minWidth,
-            minHeight: state.options.minHeight,
-          },
-          {
-            bounds: state.bounds,
-            layerCount: state.layerCount,
-            obstaclesByLayer: state.obstaclesByLayer,
-            placedByLayer: state.placedByLayer,
-          },
-        )
-
-        if (state.iteration === 0) {
-          state.initialGapCount = state.gapsFound.length
-        }
-
-        state.gapIndex = 0
-        state.iteration++
-
-        // If no gaps found, we're done
-        if (state.gapsFound.length === 0) {
-          state.done = true
-          return false
-        }
-      }
-
-      // Move to select stage
-      state.stage = "select"
-      return true
-    }
-
-    case "select": {
-      // Stage 2: Show the gap being targeted
-      if (state.gapIndex >= state.gapsFound.length) {
-        // No more gaps in this iteration, go back to scan
-        state.stage = "scan"
-        return true
-      }
-
-      state.currentGap = state.gapsFound[state.gapIndex]!
-      state.currentSeed = {
-        x: state.currentGap.centerX,
-        y: state.currentGap.centerY,
-      }
-      state.expandedRect = null
-
-      // Move to expand stage
-      state.stage = "expand"
-      return true
-    }
-
-    case "expand": {
-      // Stage 3: Show expansion attempt
-      if (!state.currentGap) {
-        // Shouldn't happen, but handle gracefully
-        state.stage = "select"
-        return true
-      }
-
-      // Try to expand from the current seed
-      const expandedRect = tryExpandGap(state, {
-        gap: state.currentGap,
-        seed: state.currentSeed!,
-      })
-      state.expandedRect = expandedRect
-
-      // Move to place stage
-      state.stage = "place"
-      return true
-    }
-
-    case "place": {
-      // Stage 4: Show the placed result
-      if (state.expandedRect && state.currentGap) {
-        // Actually place the rectangle
-        addPlacement(state, {
-          rect: state.expandedRect,
-          zLayers: state.currentGap.zLayers,
-        })
-        state.filledCount++
-      }
-
-      // Move to next gap and reset to select stage
-      state.gapIndex++
-      state.currentGap = null
-      state.currentSeed = null
-      state.expandedRect = null
-      state.stage = "select"
-      return true
-    }
-
-    default:
-      state.stage = "scan"
-      return true
-  }
-}

package/lib/solvers/rectdiff/gapfill/engine/tryExpandGap.ts

@@ -1,78 +0,0 @@
-// lib/solvers/rectdiff/gapfill/engine/tryExpandGap.ts
-import type { XYRect } from "../../types"
-import type { GapFillState, GapRegion } from "../types"
-import { expandRectFromSeed } from "../../geometry"
-
-/**
- * Try to expand a rectangle from a seed point within the gap.
- * Returns the expanded rectangle or null if expansion fails.
- */
-export function tryExpandGap(
-  state: GapFillState,
-  {
-    gap,
-    seed,
-  }: {
-    gap: GapRegion
-    seed: { x: number; y: number }
-  },
-): XYRect | null {
-  // Build blockers for the gap's z-layers
-  const blockers: XYRect[] = []
-  for (const z of gap.zLayers) {
-    blockers.push(...(state.obstaclesByLayer[z] ?? []))
-    blockers.push(...(state.placedByLayer[z] ?? []))
-  }
-
-  // Try to expand from the seed point
-  const rect = expandRectFromSeed({
-    startX: seed.x,
-    startY: seed.y,
-    gridSize: Math.min(gap.rect.width, gap.rect.height),
-    bounds: state.bounds,
-    blockers,
-    initialCellRatio: 0,
-    maxAspectRatio: null,
-    minReq: { width: state.options.minWidth, height: state.options.minHeight },
-  })
-
-  if (!rect) {
-    // Try additional seed points within the gap
-    const seeds = [
-      { x: gap.rect.x + state.options.minWidth / 2, y: gap.centerY },
-      {
-        x: gap.rect.x + gap.rect.width - state.options.minWidth / 2,
-        y: gap.centerY,
-      },
-      { x: gap.centerX, y: gap.rect.y + state.options.minHeight / 2 },
-      {
-        x: gap.centerX,
-        y: gap.rect.y + gap.rect.height - state.options.minHeight / 2,
-      },
-    ]
-
-    for (const altSeed of seeds) {
-      const altRect = expandRectFromSeed({
-        startX: altSeed.x,
-        startY: altSeed.y,
-        gridSize: Math.min(gap.rect.width, gap.rect.height),
-        bounds: state.bounds,
-        blockers,
-        initialCellRatio: 0,
-        maxAspectRatio: null,
-        minReq: {
-          width: state.options.minWidth,
-          height: state.options.minHeight,
-        },
-      })
-
-      if (altRect) {
-        return altRect
-      }
-    }
-
-    return null
-  }
-
-  return rect
-}

package/lib/solvers/rectdiff/gapfill/engine.ts

@@ -1,7 +0,0 @@
-// lib/solvers/rectdiff/gapfill/engine.ts
-export * from "./engine/calculateCoverage"
-export * from "./engine/findUncoveredPoints"
-export * from "./engine/getGapFillProgress"
-export * from "./engine/initGapFillState"
-
-export * from "./engine/stepGapFill"

package/lib/solvers/rectdiff/gapfill/types.ts

@@ -1,60 +0,0 @@
-// lib/solvers/rectdiff/gapfill/types.ts
-import type { XYRect, Placed3D } from "../types"
-
-export interface GapFillOptions {
-  /** Minimum width for gap-fill rectangles (can be smaller than main solver) */
-  minWidth: number
-  /** Minimum height for gap-fill rectangles */
-  minHeight: number
-  /** Maximum iterations to prevent infinite loops */
-  maxIterations: number
-  /** Target coverage percentage (0-1) to stop early */
-  targetCoverage: number
-  /** Grid resolution for gap detection */
-  scanResolution: number
-}
-
-export interface GapRegion {
-  /** Bounding box of the gap */
-  rect: XYRect
-  /** Z-layers where this gap exists */
-  zLayers: number[]
-  /** Center point for seeding */
-  centerX: number
-  centerY: number
-  /** Approximate area of the gap */
-  area: number
-}
-
-export interface GapFillState {
-  bounds: XYRect
-  layerCount: number
-  obstaclesByLayer: XYRect[][]
-  placed: Placed3D[]
-  placedByLayer: XYRect[][]
-  options: GapFillOptions
-
-  // Progress tracking
-  iteration: number
-  gapsFound: GapRegion[]
-  gapIndex: number
-  done: boolean
-
-  // Stats
-  initialGapCount: number
-  filledCount: number
-
-  // Four-stage visualization state
-  stage: "scan" | "select" | "expand" | "place"
-  currentGap: GapRegion | null
-  currentSeed: { x: number; y: number } | null
-  expandedRect: XYRect | null
-}
-
-/** Context for layer-based operations shared across gap fill functions */
-export interface LayerContext {
-  bounds: XYRect
-  layerCount: number
-  obstaclesByLayer: XYRect[][]
-  placedByLayer: XYRect[][]
-}