@tscircuit/rectdiff 0.0.12 → 0.0.13

package/lib/utils/isFullyOccupiedAtPoint.ts

@@ -0,0 +1,21 @@
+import type { XYRect } from "../rectdiff-types"
+import { containsPoint } from "./rectdiff-geometry"
+
+export function isFullyOccupiedAtPoint(
+  params: {
+    layerCount: number
+    obstaclesByLayer: XYRect[][]
+    placedByLayer: XYRect[][]
+  },
+  point: { x: number; y: number },
+): boolean {
+  for (let z = 0; z < params.layerCount; z++) {
+    const obs = params.obstaclesByLayer[z] ?? []
+    const placed = params.placedByLayer[z] ?? []
+    const occ =
+      obs.some((b) => containsPoint(b, point)) ||
+      placed.some((b) => containsPoint(b, point))
+    if (!occ) return false
+  }
+  return true
+}

package/lib/utils/rectdiff-geometry.ts

@@ -0,0 +1,94 @@
+import type { XYRect } from "../rectdiff-types"
+
+export const EPS = 1e-9
+export const clamp = (v: number, lo: number, hi: number) =>
+  Math.max(lo, Math.min(hi, v))
+export const gt = (a: number, b: number) => a > b + EPS
+export const gte = (a: number, b: number) => a > b - EPS
+export const lt = (a: number, b: number) => a < b - EPS
+export const lte = (a: number, b: number) => a < b + EPS
+
+export function overlaps(a: XYRect, b: XYRect) {
+  return !(
+    a.x + a.width <= b.x + EPS ||
+    b.x + b.width <= a.x + EPS ||
+    a.y + a.height <= b.y + EPS ||
+    b.y + b.height <= a.y + EPS
+  )
+}
+
+export function containsPoint(r: XYRect, p: { x: number; y: number }) {
+  return (
+    p.x >= r.x - EPS &&
+    p.x <= r.x + r.width + EPS &&
+    p.y >= r.y - EPS &&
+    p.y <= r.y + r.height + EPS
+  )
+}
+
+export function distancePointToRectEdges(
+  p: { x: number; y: number },
+  r: XYRect,
+) {
+  const edges: [number, number, number, number][] = [
+    [r.x, r.y, r.x + r.width, r.y],
+    [r.x + r.width, r.y, r.x + r.width, r.y + r.height],
+    [r.x + r.width, r.y + r.height, r.x, r.y + r.height],
+    [r.x, r.y + r.height, r.x, r.y],
+  ]
+  let best = Infinity
+  for (const [x1, y1, x2, y2] of edges) {
+    const A = p.x - x1,
+      B = p.y - y1,
+      C = x2 - x1,
+      D = y2 - y1
+    const dot = A * C + B * D
+    const lenSq = C * C + D * D
+    let t = lenSq !== 0 ? dot / lenSq : 0
+    t = clamp(t, 0, 1)
+    const xx = x1 + t * C
+    const yy = y1 + t * D
+    best = Math.min(best, Math.hypot(p.x - xx, p.y - yy))
+  }
+  return best
+}
+
+/** Find the intersection of two 1D intervals, or null if they don't overlap. */
+export function intersect1D(r1: [number, number], r2: [number, number]) {
+  const lo = Math.max(r1[0], r2[0])
+  const hi = Math.min(r1[1], r2[1])
+  return hi > lo + EPS ? ([lo, hi] as const) : null
+}
+
+/** Return A \ B as up to 4 non-overlapping rectangles (or [A] if no overlap). */
+export function subtractRect2D(A: XYRect, B: XYRect): XYRect[] {
+  if (!overlaps(A, B)) return [A]
+
+  const Xi = intersect1D([A.x, A.x + A.width], [B.x, B.x + B.width])
+  const Yi = intersect1D([A.y, A.y + A.height], [B.y, B.y + B.height])
+  if (!Xi || !Yi) return [A]
+
+  const [X0, X1] = Xi
+  const [Y0, Y1] = Yi
+  const out: XYRect[] = []
+
+  // Left strip
+  if (X0 > A.x + EPS) {
+    out.push({ x: A.x, y: A.y, width: X0 - A.x, height: A.height })
+  }
+  // Right strip
+  if (A.x + A.width > X1 + EPS) {
+    out.push({ x: X1, y: A.y, width: A.x + A.width - X1, height: A.height })
+  }
+  // Top wedge in the middle band
+  const midW = Math.max(0, X1 - X0)
+  if (midW > EPS && Y0 > A.y + EPS) {
+    out.push({ x: X0, y: A.y, width: midW, height: Y0 - A.y })
+  }
+  // Bottom wedge in the middle band
+  if (midW > EPS && A.y + A.height > Y1 + EPS) {
+    out.push({ x: X0, y: Y1, width: midW, height: A.y + A.height - Y1 })
+  }
+
+  return out.filter((r) => r.width > EPS && r.height > EPS)
+}

package/lib/utils/resizeSoftOverlaps.ts

@@ -0,0 +1,74 @@
+import type { Placed3D, XYRect } from "../rectdiff-types"
+import { overlaps, subtractRect2D, EPS } from "./rectdiff-geometry"
+
+export function resizeSoftOverlaps(
+  params: {
+    layerCount: number
+    placed: Placed3D[]
+    placedByLayer: XYRect[][]
+    options: any
+  },
+  newIndex: number,
+) {
+  const newcomer = params.placed[newIndex]!
+  const { rect: newR, zLayers: newZs } = newcomer
+  const layerCount = params.layerCount
+
+  const removeIdx: number[] = []
+  const toAdd: typeof params.placed = []
+
+  for (let i = 0; i < params.placed.length; i++) {
+    if (i === newIndex) continue
+    const old = params.placed[i]!
+    // Protect full-stack nodes
+    if (old.zLayers.length >= layerCount) continue
+
+    const sharedZ = old.zLayers.filter((z) => newZs.includes(z))
+    if (sharedZ.length === 0) continue
+    if (!overlaps(old.rect, newR)) continue
+
+    // Carve the overlap on the shared layers
+    const parts = subtractRect2D(old.rect, newR)
+
+    // We will replace `old` entirely; re-add unaffected layers (same rect object).
+    removeIdx.push(i)
+
+    const unaffectedZ = old.zLayers.filter((z) => !newZs.includes(z))
+    if (unaffectedZ.length > 0) {
+      toAdd.push({ rect: old.rect, zLayers: unaffectedZ })
+    }
+
+    // Re-add carved pieces for affected layers, dropping tiny slivers
+    const minW = Math.min(
+      params.options.minSingle.width,
+      params.options.minMulti.width,
+    )
+    const minH = Math.min(
+      params.options.minSingle.height,
+      params.options.minMulti.height,
+    )
+    for (const p of parts) {
+      if (p.width + EPS >= minW && p.height + EPS >= minH) {
+        toAdd.push({ rect: p, zLayers: sharedZ.slice() })
+      }
+    }
+  }
+
+  // Remove (and clear placedByLayer)
+  removeIdx
+    .sort((a, b) => b - a)
+    .forEach((idx) => {
+      const rem = params.placed.splice(idx, 1)[0]!
+      for (const z of rem.zLayers) {
+        const arr = params.placedByLayer[z]!
+        const j = arr.findIndex((r) => r === rem.rect)
+        if (j >= 0) arr.splice(j, 1)
+      }
+    })
+
+  // Add replacements
+  for (const p of toAdd) {
+    params.placed.push(p)
+    for (const z of p.zLayers) params.placedByLayer[z]!.push(p.rect)
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tscircuit/rectdiff",
-  "version": "0.0.12",
+  "version": "0.0.13",
   "type": "module",
   "main": "dist/index.js",
   "scripts": {

package/tests/board-outline.test.ts

@@ -11,7 +11,8 @@ test("board outline snapshot", async () => {
   // Run to completion
   solver.solve()
 
-  const viz = solver.rectDiffSolver!.visualize()
+  const viz =
+    solver.rectDiffGridSolverPipeline!.rectDiffSeedingSolver!.visualize()
   const svg = getSvgFromGraphicsObject(viz)
 
   await expect(svg).toMatchSvgSnapshot(import.meta.path)

package/tests/obstacle-extra-layers.test.ts

@@ -40,5 +40,5 @@ test("RectDiffSolver clamps extra layer names to available z indices", () => {
   expect(output.meshNodes.length).toBeGreaterThan(0)
 
   // Verify solver was instantiated and processed obstacles
-  expect(pipeline.rectDiffSolver).toBeDefined()
+  expect(pipeline.rectDiffGridSolverPipeline).toBeDefined()
 })

package/tests/obstacle-zlayers.test.ts

@@ -41,5 +41,5 @@ test("RectDiffSolver maps obstacle layers to numeric zLayers", () => {
 
   // Verify obstacles were processed correctly
   // The internal solver should have mapped layer names to z indices
-  expect(pipeline.rectDiffSolver).toBeDefined()
+  expect(pipeline.rectDiffGridSolverPipeline).toBeDefined()
 })

package/utils/rectsEqual.ts

@@ -1,6 +1,6 @@
 // utils/rectsEqual.ts
-import type { XYRect } from "../lib/solvers/rectdiff/types"
-import { EPS } from "../lib/solvers/rectdiff/geometry"
+import type { XYRect } from "../lib/rectdiff-types"
+import { EPS } from "../lib/utils/rectdiff-geometry"
 
 /**
  * Checks if two rectangles are equal within a small tolerance (EPS).

package/utils/rectsOverlap.ts

@@ -1,6 +1,6 @@
 // utils/rectsOverlap.ts
-import type { XYRect } from "../lib/solvers/rectdiff/types"
-import { EPS } from "../lib/solvers/rectdiff/geometry"
+import type { XYRect } from "../lib/rectdiff-types"
+import { EPS } from "../lib/utils/rectdiff-geometry"
 
 /**
  * Checks if two rectangles overlap.

package/lib/solvers/RectDiffSolver.ts

@@ -1,231 +0,0 @@
-// lib/solvers/RectDiffSolver.ts
-import { BaseSolver, BasePipelineSolver } from "@tscircuit/solver-utils"
-import type { SimpleRouteJson } from "../types/srj-types"
-import type { GraphicsObject } from "graphics-debug"
-import type { CapacityMeshNode } from "../types/capacity-mesh-types"
-
-import type { GridFill3DOptions, RectDiffState } from "./rectdiff/types"
-import {
-  initState,
-  stepGrid,
-  stepExpansion,
-  finalizeRects,
-  computeProgress,
-} from "./rectdiff/engine"
-import { rectsToMeshNodes } from "./rectdiff/rectsToMeshNodes"
-import { overlaps } from "./rectdiff/geometry"
-
-/**
- * A streaming, one-step-per-iteration solver for capacity mesh generation.
- */
-export class RectDiffSolver extends BaseSolver {
-  private srj: SimpleRouteJson
-  private gridOptions: Partial<GridFill3DOptions>
-  private state!: RectDiffState
-  private _meshNodes: CapacityMeshNode[] = []
-
-  constructor(opts: {
-    simpleRouteJson: SimpleRouteJson
-    gridOptions?: Partial<GridFill3DOptions>
-  }) {
-    super()
-    this.srj = opts.simpleRouteJson
-    this.gridOptions = opts.gridOptions ?? {}
-  }
-
-  override _setup() {
-    this.state = initState(this.srj, this.gridOptions)
-    this.stats = {
-      phase: this.state.phase,
-      gridIndex: this.state.gridIndex,
-    }
-  }
-
-  /** Exactly ONE small step per call. */
-  override _step() {
-    if (this.state.phase === "GRID") {
-      stepGrid(this.state)
-    } else if (this.state.phase === "EXPANSION") {
-      stepExpansion(this.state)
-    } else if (this.state.phase === "GAP_FILL") {
-      this.state.phase = "DONE"
-    } else if (this.state.phase === "DONE") {
-      // Finalize once
-      if (!this.solved) {
-        const rects = finalizeRects(this.state)
-        this._meshNodes = rectsToMeshNodes(rects)
-        this.solved = true
-      }
-      return
-    }
-
-    // Lightweight stats for debugger
-    this.stats.phase = this.state.phase
-    this.stats.gridIndex = this.state.gridIndex
-    this.stats.placed = this.state.placed.length
-  }
-
-  /** Compute solver progress (0 to 1). */
-  computeProgress(): number {
-    if (this.solved || this.state.phase === "DONE") {
-      return 1
-    }
-    return computeProgress(this.state)
-  }
-
-  override getOutput(): { meshNodes: CapacityMeshNode[] } {
-    return { meshNodes: this._meshNodes }
-  }
-
-  /** Get color based on z layer for visualization. */
-  private getColorForZLayer(zLayers: number[]): {
-    fill: string
-    stroke: string
-  } {
-    const minZ = Math.min(...zLayers)
-    const colors = [
-      { fill: "#dbeafe", stroke: "#3b82f6" },
-      { fill: "#fef3c7", stroke: "#f59e0b" },
-      { fill: "#d1fae5", stroke: "#10b981" },
-      { fill: "#e9d5ff", stroke: "#a855f7" },
-      { fill: "#fed7aa", stroke: "#f97316" },
-      { fill: "#fecaca", stroke: "#ef4444" },
-    ]
-    return colors[minZ % colors.length]!
-  }
-
-  /** Streaming visualization: board + obstacles + current placements. */
-  override visualize(): GraphicsObject {
-    const rects: NonNullable<GraphicsObject["rects"]> = []
-    const points: NonNullable<GraphicsObject["points"]> = []
-    const lines: NonNullable<GraphicsObject["lines"]> = [] // Initialize lines array
-
-    // Board bounds - use srj bounds which is always available
-    const boardBounds = {
-      minX: this.srj.bounds.minX,
-      maxX: this.srj.bounds.maxX,
-      minY: this.srj.bounds.minY,
-      maxY: this.srj.bounds.maxY,
-    }
-
-    // board or outline
-    if (this.srj.outline && this.srj.outline.length > 1) {
-      lines.push({
-        points: [...this.srj.outline, this.srj.outline[0]!], // Close the loop by adding the first point again
-        strokeColor: "#111827",
-        strokeWidth: 0.01,
-        label: "outline",
-      })
-    } else {
-      rects.push({
-        center: {
-          x: (boardBounds.minX + boardBounds.maxX) / 2,
-          y: (boardBounds.minY + boardBounds.maxY) / 2,
-        },
-        width: boardBounds.maxX - boardBounds.minX,
-        height: boardBounds.maxY - boardBounds.minY,
-        fill: "none",
-        stroke: "#111827",
-        label: "board",
-      })
-    }
-
-    // obstacles (rect & oval as bounding boxes)
-    for (const obstacle of this.srj.obstacles ?? []) {
-      if (obstacle.type === "rect" || obstacle.type === "oval") {
-        rects.push({
-          center: { x: obstacle.center.x, y: obstacle.center.y },
-          width: obstacle.width,
-          height: obstacle.height,
-          fill: "#fee2e2",
-          stroke: "#ef4444",
-          layer: "obstacle",
-          label: "obstacle",
-        })
-      }
-    }
-
-    // board void rects
-    if (this.state?.boardVoidRects) {
-      // If outline exists, compute its bbox to hide outer padding voids
-      let outlineBBox: {
-        x: number
-        y: number
-        width: number
-        height: number
-      } | null = null
-
-      if (this.srj.outline && this.srj.outline.length > 0) {
-        const xs = this.srj.outline.map((p) => p.x)
-        const ys = this.srj.outline.map((p) => p.y)
-        const minX = Math.min(...xs)
-        const minY = Math.min(...ys)
-        outlineBBox = {
-          x: minX,
-          y: minY,
-          width: Math.max(...xs) - minX,
-          height: Math.max(...ys) - minY,
-        }
-      }
-
-      for (const r of this.state.boardVoidRects) {
-        // If we have an outline, only show voids that overlap its bbox (hides outer padding)
-        if (outlineBBox && !overlaps(r, outlineBBox)) {
-          continue
-        }
-
-        rects.push({
-          center: { x: r.x + r.width / 2, y: r.y + r.height / 2 },
-          width: r.width,
-          height: r.height,
-          fill: "rgba(0, 0, 0, 0.5)",
-          stroke: "none",
-          label: "void",
-        })
-      }
-    }
-
-    // candidate positions (where expansion started from)
-    if (this.state?.candidates?.length) {
-      for (const cand of this.state.candidates) {
-        points.push({
-          x: cand.x,
-          y: cand.y,
-          fill: "#9333ea",
-          stroke: "#6b21a8",
-          label: `z:${cand.z}`,
-        } as any)
-      }
-    }
-
-    // current placements (streaming) if not yet solved
-    if (this.state?.placed?.length) {
-      for (const p of this.state.placed) {
-        const colors = this.getColorForZLayer(p.zLayers)
-        rects.push({
-          center: {
-            x: p.rect.x + p.rect.width / 2,
-            y: p.rect.y + p.rect.height / 2,
-          },
-          width: p.rect.width,
-          height: p.rect.height,
-          fill: colors.fill,
-          stroke: colors.stroke,
-          layer: `z${p.zLayers.join(",")}`,
-          label: `free\nz:${p.zLayers.join(",")}`,
-        })
-      }
-    }
-
-    return {
-      title: `RectDiff (${this.state?.phase ?? "init"})`,
-      coordinateSystem: "cartesian",
-      rects,
-      points,
-      lines, // Include lines in the returned GraphicsObject
-    }
-  }
-}
-
-// Re-export types for convenience
-export type { GridFill3DOptions } from "./rectdiff/types"