@tscircuit/rectdiff 0.0.12 → 0.0.14

package/lib/{solvers/rectdiff/geometry.ts → utils/expandRectFromSeed.ts}

@@ -1,64 +1,15 @@
-// lib/solvers/rectdiff/geometry.ts
-import type { XYRect } from "./types"
+import type { XYRect } from "../rectdiff-types"
+import { EPS, gt, gte, lt, lte, overlaps } from "./rectdiff-geometry"
 
-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, x: number, y: number) {
-  return (
-    x >= r.x - EPS &&
-    x <= r.x + r.width + EPS &&
-    y >= r.y - EPS &&
-    y <= r.y + r.height + EPS
-  )
-}
-
-export function distancePointToRectEdges(px: number, py: 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 = px - x1,
-      B = py - 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(px - xx, py - yy))
-  }
-  return best
+type ExpandDirectionParams = {
+  r: XYRect
+  bounds: XYRect
+  blockers: XYRect[]
+  maxAspect: number | null | undefined
 }
 
-// --- directional expansion caps (respect board + blockers + aspect) ---
-
-function maxExpandRight(
-  r: XYRect,
-  bounds: XYRect,
-  blockers: XYRect[],
-  maxAspect: number | null | undefined,
-) {
+function maxExpandRight(params: ExpandDirectionParams) {
+  const { r, bounds, blockers, maxAspect } = params
   // Start with board boundary
   let maxWidth = bounds.x + bounds.width - r.x
 
@@ -94,12 +45,8 @@ function maxExpandRight(
   return Math.max(0, e)
 }
 
-function maxExpandDown(
-  r: XYRect,
-  bounds: XYRect,
-  blockers: XYRect[],
-  maxAspect: number | null | undefined,
-) {
+function maxExpandDown(params: ExpandDirectionParams) {
+  const { r, bounds, blockers, maxAspect } = params
   // Start with board boundary
   let maxHeight = bounds.y + bounds.height - r.y
 
@@ -134,12 +81,8 @@ function maxExpandDown(
   return Math.max(0, e)
 }
 
-function maxExpandLeft(
-  r: XYRect,
-  bounds: XYRect,
-  blockers: XYRect[],
-  maxAspect: number | null | undefined,
-) {
+function maxExpandLeft(params: ExpandDirectionParams) {
+  const { r, bounds, blockers, maxAspect } = params
   // Start with board boundary
   let minX = bounds.x
 
@@ -172,12 +115,8 @@ function maxExpandLeft(
   return Math.max(0, e)
 }
 
-function maxExpandUp(
-  r: XYRect,
-  bounds: XYRect,
-  blockers: XYRect[],
-  maxAspect: number | null | undefined,
-) {
+function maxExpandUp(params: ExpandDirectionParams) {
+  const { r, bounds, blockers, maxAspect } = params
   // Start with board boundary
   let minY = bounds.y
 
@@ -271,25 +210,27 @@ export function expandRectFromSeed(params: {
     let improved = true
     while (improved) {
       improved = false
-      const eR = maxExpandRight(r, bounds, blockers, maxAspectRatio)
+      const commonParams = { bounds, blockers, maxAspect: maxAspectRatio }
+
+      const eR = maxExpandRight({ ...commonParams, r })
       if (eR > 0) {
         r = { ...r, width: r.width + eR }
         improved = true
       }
 
-      const eD = maxExpandDown(r, bounds, blockers, maxAspectRatio)
+      const eD = maxExpandDown({ ...commonParams, r })
       if (eD > 0) {
         r = { ...r, height: r.height + eD }
         improved = true
       }
 
-      const eL = maxExpandLeft(r, bounds, blockers, maxAspectRatio)
+      const eL = maxExpandLeft({ ...commonParams, r })
       if (eL > 0) {
         r = { x: r.x - eL, y: r.y, width: r.width + eL, height: r.height }
         improved = true
       }
 
-      const eU = maxExpandUp(r, bounds, blockers, maxAspectRatio)
+      const eU = maxExpandUp({ ...commonParams, r })
       if (eU > 0) {
         r = { x: r.x, y: r.y - eU, width: r.width, height: r.height + eU }
         improved = true
@@ -307,43 +248,3 @@ export function expandRectFromSeed(params: {
 
   return best
 }
-
-/** Find the intersection of two 1D intervals, or null if they don't overlap. */
-export function intersect1D(a0: number, a1: number, b0: number, b1: number) {
-  const lo = Math.max(a0, b0)
-  const hi = Math.min(a1, b1)
-  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/finalizeRects.ts

@@ -0,0 +1,54 @@
+import type { Placed3D, Rect3d, XYRect } from "../rectdiff-types"
+import type { SimpleRouteJson } from "../types/srj-types"
+import {
+  buildZIndexMap,
+  obstacleToXYRect,
+  obstacleZs,
+} from "../solvers/RectDiffSeedingSolver/layers"
+
+export function finalizeRects(params: {
+  placed: Placed3D[]
+  srj: SimpleRouteJson
+  boardVoidRects: XYRect[]
+}): Rect3d[] {
+  // Convert all placed (free space) nodes to output format
+  const out: Rect3d[] = params.placed.map((p) => ({
+    minX: p.rect.x,
+    minY: p.rect.y,
+    maxX: p.rect.x + p.rect.width,
+    maxY: p.rect.y + p.rect.height,
+    zLayers: [...p.zLayers].sort((a, b) => a - b),
+  }))
+
+  const { zIndexByName } = buildZIndexMap(params.srj)
+  const layersByKey = new Map<string, { rect: XYRect; layers: Set<number> }>()
+
+  for (const obstacle of params.srj.obstacles ?? []) {
+    const rect = obstacleToXYRect(obstacle as any)
+    if (!rect) continue
+    const zLayers =
+      obstacle.zLayers?.length && obstacle.zLayers.length > 0
+        ? obstacle.zLayers
+        : obstacleZs(obstacle as any, zIndexByName)
+    const key = `${rect.x}:${rect.y}:${rect.width}:${rect.height}`
+    let entry = layersByKey.get(key)
+    if (!entry) {
+      entry = { rect, layers: new Set() }
+      layersByKey.set(key, entry)
+    }
+    zLayers.forEach((layer) => entry!.layers.add(layer))
+  }
+
+  for (const { rect, layers } of layersByKey.values()) {
+    out.push({
+      minX: rect.x,
+      minY: rect.y,
+      maxX: rect.x + rect.width,
+      maxY: rect.y + rect.height,
+      zLayers: Array.from(layers).sort((a, b) => a - b),
+      isObstacle: true,
+    })
+  }
+
+  return out
+}

package/lib/utils/isFullyOccupiedAtPoint.ts

@@ -0,0 +1,28 @@
+import type { RTreeRect } from "lib/types/capacity-mesh-types"
+import RBush from "rbush"
+
+export type OccupancyParams = {
+  layerCount: number
+  obstacleIndexByLayer: Array<RBush<RTreeRect> | undefined>
+  placedIndexByLayer: Array<RBush<RTreeRect> | undefined>
+  point: { x: number; y: number }
+}
+
+export function isFullyOccupiedAtPoint(params: OccupancyParams): boolean {
+  const query = {
+    minX: params.point.x,
+    minY: params.point.y,
+    maxX: params.point.x,
+    maxY: params.point.y,
+  }
+  for (let z = 0; z < params.layerCount; z++) {
+    const obstacleIdx = params.obstacleIndexByLayer[z]
+    const hasObstacle = !!obstacleIdx && obstacleIdx.search(query).length > 0
+
+    const placedIdx = params.placedIndexByLayer[z]
+    const hasPlaced = !!placedIdx && placedIdx.search(query).length > 0
+
+    if (!hasObstacle && !hasPlaced) return false
+  }
+  return true
+}

package/lib/utils/rectToTree.ts

@@ -0,0 +1,10 @@
+import type { XYRect } from "lib/rectdiff-types"
+import type { RTreeRect } from "lib/types/capacity-mesh-types"
+
+export const rectToTree = (rect: XYRect): RTreeRect => ({
+  ...rect,
+  minX: rect.x,
+  minY: rect.y,
+  maxX: rect.x + rect.width,
+  maxY: rect.y + rect.height,
+})

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,103 @@
+import type { RTreeRect } from "lib/types/capacity-mesh-types"
+import type { Placed3D, XYRect } from "../rectdiff-types"
+import { overlaps, subtractRect2D, EPS } from "./rectdiff-geometry"
+import type RBush from "rbush"
+
+export function resizeSoftOverlaps(
+  params: {
+    layerCount: number
+    placed: Placed3D[]
+    options: any
+    placedIndexByLayer?: Array<RBush<RTreeRect> | undefined>
+  },
+  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 fully overlapped nodes and keep indexes in sync
+  const rectToTree = (rect: XYRect): RTreeRect => ({
+    ...rect,
+    minX: rect.x,
+    minY: rect.y,
+    maxX: rect.x + rect.width,
+    maxY: rect.y + rect.height,
+  })
+  const sameRect = (a: RTreeRect, b: RTreeRect) =>
+    a.minX === b.minX &&
+    a.minY === b.minY &&
+    a.maxX === b.maxX &&
+    a.maxY === b.maxY
+
+  removeIdx
+    .sort((a, b) => b - a)
+    .forEach((idx) => {
+      const rem = params.placed.splice(idx, 1)[0]!
+      if (params.placedIndexByLayer) {
+        for (const z of rem.zLayers) {
+          const tree = params.placedIndexByLayer[z]
+          if (tree) tree.remove(rectToTree(rem.rect), sameRect)
+        }
+      }
+    })
+
+  // Add replacements
+  for (const p of toAdd) {
+    params.placed.push(p)
+    for (const z of p.zLayers) {
+      if (params.placedIndexByLayer) {
+        const idx = params.placedIndexByLayer[z]
+        if (idx) {
+          idx.insert({
+            ...p.rect,
+            minX: p.rect.x,
+            minY: p.rect.y,
+            maxX: p.rect.x + p.rect.width,
+            maxY: p.rect.y + p.rect.height,
+          })
+        }
+      }
+    }
+  }
+}

package/lib/utils/sameTreeRect.ts

@@ -0,0 +1,7 @@
+import type { RTreeRect } from "lib/types/capacity-mesh-types"
+
+export const sameTreeRect = (a: RTreeRect, b: RTreeRect) =>
+  a.minX === b.minX &&
+  a.minY === b.minY &&
+  a.maxX === b.maxX &&
+  a.maxY === b.maxY

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tscircuit/rectdiff",
-  "version": "0.0.12",
+  "version": "0.0.14",
   "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/examples/example01.test.tsx

@@ -2,6 +2,11 @@ import { expect, test } from "bun:test"
 import simpleRouteJson from "../../test-assets/example01.json"
 import { RectDiffPipeline } from "../../lib/RectDiffPipeline"
 import { getSvgFromGraphicsObject } from "graphics-debug"
+import {
+  buildZIndexMap,
+  obstacleToXYRect,
+  obstacleZs,
+} from "lib/solvers/RectDiffSeedingSolver/layers"
 
 test.skip("example01", () => {
   const solver = new RectDiffPipeline({ simpleRouteJson })
@@ -17,7 +22,19 @@ test.skip("example01", () => {
   const step = 0.004
   const layerCount = simpleRouteJson.layerCount || 2
   const state = (solver as any).state
-  const obstacles = state.obstaclesByLayer
+  const { zIndexByName } = buildZIndexMap(simpleRouteJson as any)
+  const obstacles = Array.from({ length: layerCount }, () => [] as any[])
+  for (const obstacle of simpleRouteJson.obstacles ?? []) {
+    const rect = obstacleToXYRect(obstacle as any)
+    if (!rect) continue
+    const zLayers =
+      obstacle.zLayers?.length && obstacle.zLayers.length > 0
+        ? obstacle.zLayers
+        : obstacleZs(obstacle as any, zIndexByName)
+    zLayers.forEach((z: number) => {
+      if (z >= 0 && z < layerCount) obstacles[z]!.push(rect)
+    })
+  }
   const placed = state.placed
 
   const gapPoints: Array<{ x: number; y: number; z: number }> = []

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.