@tscircuit/rectdiff 0.0.12 → 0.0.14

package/lib/solvers/{rectdiff/candidates.ts → RectDiffSeedingSolver/computeEdgeCandidates3D.ts}

@@ -1,190 +1,9 @@
-// lib/solvers/rectdiff/candidates.ts
-import type { Candidate3D, XYRect } from "./types"
-import { EPS, clamp, containsPoint, distancePointToRectEdges } from "./geometry"
-
-/**
- * Check if a point is occupied on all layers.
- */
-function isFullyOccupiedAllLayers(params: {
-  x: number
-  y: number
-  layerCount: number
-  obstaclesByLayer: XYRect[][]
-  placedByLayer: XYRect[][]
-}): boolean {
-  const { x, y, layerCount, obstaclesByLayer, placedByLayer } = params
-  for (let z = 0; z < layerCount; z++) {
-    const obs = obstaclesByLayer[z] ?? []
-    const placed = placedByLayer[z] ?? []
-    const occ =
-      obs.some((b) => containsPoint(b, x, y)) ||
-      placed.some((b) => containsPoint(b, x, y))
-    if (!occ) return false
-  }
-  return true
-}
-
-/**
- * Compute candidate seed points for a given grid size.
- */
-export function computeCandidates3D(params: {
-  bounds: XYRect
-  gridSize: number
-  layerCount: number
-  obstaclesByLayer: XYRect[][]
-  placedByLayer: XYRect[][]
-  hardPlacedByLayer: XYRect[][]
-}): Candidate3D[] {
-  const {
-    bounds,
-    gridSize,
-    layerCount,
-    obstaclesByLayer,
-    placedByLayer,
-    hardPlacedByLayer,
-  } = params
-  const out = new Map<string, Candidate3D>() // key by (x,y)
-
-  for (let x = bounds.x; x < bounds.x + bounds.width; x += gridSize) {
-    for (let y = bounds.y; y < bounds.y + bounds.height; y += gridSize) {
-      // Skip outermost row/col (stable with prior behavior)
-      if (
-        Math.abs(x - bounds.x) < EPS ||
-        Math.abs(y - bounds.y) < EPS ||
-        x > bounds.x + bounds.width - gridSize - EPS ||
-        y > bounds.y + bounds.height - gridSize - EPS
-      ) {
-        continue
-      }
-
-      // New rule: Only drop if EVERY layer is occupied (by obstacle or node)
-      if (
-        isFullyOccupiedAllLayers({
-          x,
-          y,
-          layerCount,
-          obstaclesByLayer,
-          placedByLayer,
-        })
-      )
-        continue
-
-      // Find the best (longest) free contiguous Z span at (x,y) ignoring soft nodes.
-      let bestSpan: number[] = []
-      let bestZ = 0
-      for (let z = 0; z < layerCount; z++) {
-        const s = longestFreeSpanAroundZ({
-          x,
-          y,
-          z,
-          layerCount,
-          minSpan: 1,
-          maxSpan: undefined,
-          obstaclesByLayer,
-          placedByLayer: hardPlacedByLayer,
-        })
-        if (s.length > bestSpan.length) {
-          bestSpan = s
-          bestZ = z
-        }
-      }
-      const anchorZ = bestSpan.length
-        ? bestSpan[Math.floor(bestSpan.length / 2)]!
-        : bestZ
-
-      // Distance heuristic against hard blockers only (obstacles + full-stack)
-      const hardAtZ = [
-        ...(obstaclesByLayer[anchorZ] ?? []),
-        ...(hardPlacedByLayer[anchorZ] ?? []),
-      ]
-      const d = Math.min(
-        distancePointToRectEdges(x, y, bounds),
-        ...(hardAtZ.length
-          ? hardAtZ.map((b) => distancePointToRectEdges(x, y, b))
-          : [Infinity]),
-      )
-
-      const k = `${x.toFixed(6)}|${y.toFixed(6)}`
-      const cand: Candidate3D = {
-        x,
-        y,
-        z: anchorZ,
-        distance: d,
-        zSpanLen: bestSpan.length,
-      }
-      const prev = out.get(k)
-      if (
-        !prev ||
-        cand.zSpanLen! > (prev.zSpanLen ?? 0) ||
-        (cand.zSpanLen === prev.zSpanLen && cand.distance > prev.distance)
-      ) {
-        out.set(k, cand)
-      }
-    }
-  }
-
-  const arr = Array.from(out.values())
-  arr.sort((a, b) => b.zSpanLen! - a.zSpanLen! || b.distance - a.distance)
-  return arr
-}
-
-/**
- * Find the longest contiguous free span around z (optionally capped).
- */
-export function longestFreeSpanAroundZ(params: {
-  x: number
-  y: number
-  z: number
-  layerCount: number
-  minSpan: number
-  maxSpan: number | undefined
-  obstaclesByLayer: XYRect[][]
-  placedByLayer: XYRect[][]
-}): number[] {
-  const {
-    x,
-    y,
-    z,
-    layerCount,
-    minSpan,
-    maxSpan,
-    obstaclesByLayer,
-    placedByLayer,
-  } = params
-
-  const isFreeAt = (layer: number) => {
-    const blockers = [
-      ...(obstaclesByLayer[layer] ?? []),
-      ...(placedByLayer[layer] ?? []),
-    ]
-    return !blockers.some((b) => containsPoint(b, x, y))
-  }
-  let lo = z
-  let hi = z
-  while (lo - 1 >= 0 && isFreeAt(lo - 1)) lo--
-  while (hi + 1 < layerCount && isFreeAt(hi + 1)) hi++
-
-  if (typeof maxSpan === "number") {
-    const target = clamp(maxSpan, 1, layerCount)
-    // trim symmetrically (keeping z inside)
-    while (hi - lo + 1 > target) {
-      if (z - lo > hi - z) lo++
-      else hi--
-    }
-  }
-
-  const res: number[] = []
-  for (let i = lo; i <= hi; i++) res.push(i)
-  return res.length >= minSpan ? res : []
-}
-
-/**
- * Compute default grid sizes based on bounds.
- */
-export function computeDefaultGridSizes(bounds: XYRect): number[] {
-  const ref = Math.max(bounds.width, bounds.height)
-  return [ref / 8, ref / 16, ref / 32]
-}
+import type { Candidate3D, XYRect } from "../../rectdiff-types"
+import { EPS, distancePointToRectEdges } from "../../utils/rectdiff-geometry"
+import { isFullyOccupiedAtPoint } from "../../utils/isFullyOccupiedAtPoint"
+import { longestFreeSpanAroundZ } from "./longestFreeSpanAroundZ"
+import type RBush from "rbush"
+import type { RTreeRect } from "lib/types/capacity-mesh-types"
 
 /**
  * Compute exact uncovered segments along a 1D line.
@@ -262,16 +81,16 @@ export function computeEdgeCandidates3D(params: {
   bounds: XYRect
   minSize: number
   layerCount: number
-  obstaclesByLayer: XYRect[][]
-  placedByLayer: XYRect[][]
+  obstacleIndexByLayer: Array<RBush<RTreeRect> | undefined>
+  placedIndexByLayer: Array<RBush<RTreeRect> | undefined>
   hardPlacedByLayer: XYRect[][]
 }): Candidate3D[] {
   const {
     bounds,
     minSize,
     layerCount,
-    obstaclesByLayer,
-    placedByLayer,
+    obstacleIndexByLayer,
+    placedIndexByLayer,
     hardPlacedByLayer,
   } = params
 
@@ -279,20 +98,20 @@ export function computeEdgeCandidates3D(params: {
   // Use small inset from edges for placement
   const δ = Math.max(minSize * 0.15, EPS * 3)
   const dedup = new Set<string>()
-  const key = (x: number, y: number, z: number) =>
-    `${z}|${x.toFixed(6)}|${y.toFixed(6)}`
+  const key = (p: { x: number; y: number; z: number }) =>
+    `${p.z}|${p.x.toFixed(6)}|${p.y.toFixed(6)}`
 
-  function fullyOcc(x: number, y: number) {
-    return isFullyOccupiedAllLayers({
-      x,
-      y,
+  function fullyOcc(p: { x: number; y: number }) {
+    return isFullyOccupiedAtPoint({
       layerCount,
-      obstaclesByLayer,
-      placedByLayer,
+      obstacleIndexByLayer,
+      placedIndexByLayer,
+      point: p,
     })
   }
 
-  function pushIfFree(x: number, y: number, z: number) {
+  function pushIfFree(p: { x: number; y: number; z: number }) {
+    const { x, y, z } = p
     if (
       x < bounds.x + EPS ||
       y < bounds.y + EPS ||
@@ -300,21 +119,21 @@ export function computeEdgeCandidates3D(params: {
       y > bounds.y + bounds.height - EPS
     )
       return
-    if (fullyOcc(x, y)) return // new rule: only drop if truly impossible
+    if (fullyOcc({ x, y })) return // new rule: only drop if truly impossible
 
     // Distance uses obstacles + hard nodes (soft nodes ignored for ranking)
     const hard = [
-      ...(obstaclesByLayer[z] ?? []),
+      ...(obstacleIndexByLayer[z]?.all() ?? []),
       ...(hardPlacedByLayer[z] ?? []),
     ]
     const d = Math.min(
-      distancePointToRectEdges(x, y, bounds),
+      distancePointToRectEdges({ x, y }, bounds),
       ...(hard.length
-        ? hard.map((b) => distancePointToRectEdges(x, y, b))
+        ? hard.map((b) => distancePointToRectEdges({ x, y }, b))
         : [Infinity]),
     )
 
-    const k = key(x, y, z)
+    const k = key({ x, y, z })
     if (dedup.has(k)) return
     dedup.add(k)
 
@@ -326,15 +145,15 @@ export function computeEdgeCandidates3D(params: {
       layerCount,
       minSpan: 1,
       maxSpan: undefined,
-      obstaclesByLayer,
-      placedByLayer: hardPlacedByLayer,
+      obstacleIndexByLayer,
+      additionalBlockersByLayer: hardPlacedByLayer,
     })
     out.push({ x, y, z, distance: d, zSpanLen: span.length, isEdgeSeed: true })
   }
 
   for (let z = 0; z < layerCount; z++) {
     const blockers = [
-      ...(obstaclesByLayer[z] ?? []),
+      ...(obstacleIndexByLayer[z]?.all() ?? []),
       ...(hardPlacedByLayer[z] ?? []),
     ]
 
@@ -348,7 +167,7 @@ export function computeEdgeCandidates3D(params: {
       { x: bounds.x + bounds.width - δ, y: bounds.y + bounds.height - δ }, // bottom-right
     ]
     for (const corner of corners) {
-      pushIfFree(corner.x, corner.y, z)
+      pushIfFree({ x: corner.x, y: corner.y, z })
     }
 
     // Top edge (y = bounds.y + δ)
@@ -370,10 +189,10 @@ export function computeEdgeCandidates3D(params: {
       const segLen = seg.end - seg.start
       if (segLen >= minSize) {
         // Seed center and a few strategic points
-        pushIfFree(seg.center, topY, z)
+        pushIfFree({ x: seg.center, y: topY, z })
         if (segLen > minSize * 1.5) {
-          pushIfFree(seg.start + minSize * 0.4, topY, z)
-          pushIfFree(seg.end - minSize * 0.4, topY, z)
+          pushIfFree({ x: seg.start + minSize * 0.4, y: topY, z })
+          pushIfFree({ x: seg.end - minSize * 0.4, y: topY, z })
         }
       }
     }
@@ -395,10 +214,10 @@ export function computeEdgeCandidates3D(params: {
     for (const seg of bottomUncovered) {
       const segLen = seg.end - seg.start
       if (segLen >= minSize) {
-        pushIfFree(seg.center, bottomY, z)
+        pushIfFree({ x: seg.center, y: bottomY, z })
         if (segLen > minSize * 1.5) {
-          pushIfFree(seg.start + minSize * 0.4, bottomY, z)
-          pushIfFree(seg.end - minSize * 0.4, bottomY, z)
+          pushIfFree({ x: seg.start + minSize * 0.4, y: bottomY, z })
+          pushIfFree({ x: seg.end - minSize * 0.4, y: bottomY, z })
         }
       }
     }
@@ -420,10 +239,10 @@ export function computeEdgeCandidates3D(params: {
     for (const seg of leftUncovered) {
       const segLen = seg.end - seg.start
       if (segLen >= minSize) {
-        pushIfFree(leftX, seg.center, z)
+        pushIfFree({ x: leftX, y: seg.center, z })
         if (segLen > minSize * 1.5) {
-          pushIfFree(leftX, seg.start + minSize * 0.4, z)
-          pushIfFree(leftX, seg.end - minSize * 0.4, z)
+          pushIfFree({ x: leftX, y: seg.start + minSize * 0.4, z })
+          pushIfFree({ x: leftX, y: seg.end - minSize * 0.4, z })
         }
       }
     }
@@ -445,10 +264,10 @@ export function computeEdgeCandidates3D(params: {
     for (const seg of rightUncovered) {
       const segLen = seg.end - seg.start
       if (segLen >= minSize) {
-        pushIfFree(rightX, seg.center, z)
+        pushIfFree({ x: rightX, y: seg.center, z })
         if (segLen > minSize * 1.5) {
-          pushIfFree(rightX, seg.start + minSize * 0.4, z)
-          pushIfFree(rightX, seg.end - minSize * 0.4, z)
+          pushIfFree({ x: rightX, y: seg.start + minSize * 0.4, z })
+          pushIfFree({ x: rightX, y: seg.end - minSize * 0.4, z })
         }
       }
     }
@@ -473,7 +292,7 @@ export function computeEdgeCandidates3D(params: {
           minSegmentLength: minSize * 0.5,
         })
         for (const seg of obLeftUncovered) {
-          pushIfFree(obLeftX, seg.center, z)
+          pushIfFree({ x: obLeftX, y: seg.center, z })
         }
       }
 
@@ -498,7 +317,7 @@ export function computeEdgeCandidates3D(params: {
           minSegmentLength: minSize * 0.5,
         })
         for (const seg of obRightUncovered) {
-          pushIfFree(obRightX, seg.center, z)
+          pushIfFree({ x: obRightX, y: seg.center, z })
         }
       }
 
@@ -520,7 +339,7 @@ export function computeEdgeCandidates3D(params: {
           minSegmentLength: minSize * 0.5,
         })
         for (const seg of obTopUncovered) {
-          pushIfFree(seg.center, obTopY, z)
+          pushIfFree({ x: seg.center, y: obTopY, z })
         }
       }
 
@@ -546,7 +365,7 @@ export function computeEdgeCandidates3D(params: {
           minSegmentLength: minSize * 0.5,
         })
         for (const seg of obBottomUncovered) {
-          pushIfFree(seg.center, obBottomY, z)
+          pushIfFree({ x: seg.center, y: obBottomY, z })
         }
       }
     }

package/lib/solvers/{rectdiff/geometry → RectDiffSeedingSolver}/computeInverseRects.ts

@@ -1,6 +1,10 @@
-import type { XYRect } from "../types"
+import type { XYRect } from "../../rectdiff-types"
+import {
+  containsPoint,
+  subtractRect2D,
+  EPS,
+} from "../../utils/rectdiff-geometry"
 import { isPointInPolygon } from "./isPointInPolygon"
-import { EPS } from "../geometry" // Import EPS from common geometry file
 
 /**
  * Decompose the empty space inside 'bounds' but outside 'polygon' into rectangles.

package/lib/solvers/{rectdiff → RectDiffSeedingSolver}/layers.ts

@@ -1,6 +1,7 @@
-// lib/solvers/rectdiff/layers.ts
-import type { SimpleRouteJson, Obstacle } from "../../types/srj-types"
-import type { XYRect } from "./types"
+import type { SimpleRouteJson } from "../../types/srj-types"
+import type { XYRect } from "../../rectdiff-types"
+
+type Obstacle = NonNullable<SimpleRouteJson["obstacles"]>[number]
 
 function layerSortKey(n: string) {
   const L = n.toLowerCase()

package/lib/solvers/RectDiffSeedingSolver/longestFreeSpanAroundZ.ts

@@ -0,0 +1,60 @@
+import type { RTreeRect } from "lib/types/capacity-mesh-types"
+import type { XYRect } from "../../rectdiff-types"
+import { clamp, containsPoint } from "../../utils/rectdiff-geometry"
+import type RBush from "rbush"
+
+/**
+ * Find the longest contiguous free span around z (optionally capped).
+ */
+export function longestFreeSpanAroundZ(params: {
+  x: number
+  y: number
+  z: number
+  layerCount: number
+  minSpan: number
+  maxSpan: number | undefined
+  obstacleIndexByLayer: Array<RBush<RTreeRect> | undefined>
+  additionalBlockersByLayer?: XYRect[][]
+}): number[] {
+  const {
+    x,
+    y,
+    z,
+    layerCount,
+    minSpan,
+    maxSpan,
+    obstacleIndexByLayer,
+    additionalBlockersByLayer,
+  } = params
+
+  const isFreeAt = (layer: number) => {
+    const query = {
+      minX: x,
+      minY: y,
+      maxX: x,
+      maxY: y,
+    }
+    const obstacleIdx = obstacleIndexByLayer[layer]
+    if (obstacleIdx && obstacleIdx.search(query).length > 0) return false
+
+    const extras = additionalBlockersByLayer?.[layer] ?? []
+    return !extras.some((b) => containsPoint(b, { x, y }))
+  }
+  let lo = z
+  let hi = z
+  while (lo - 1 >= 0 && isFreeAt(lo - 1)) lo--
+  while (hi + 1 < layerCount && isFreeAt(hi + 1)) hi++
+
+  if (typeof maxSpan === "number") {
+    const target = clamp(maxSpan, 1, layerCount)
+    // trim symmetrically (keeping z inside)
+    while (hi - lo + 1 > target) {
+      if (z - lo > hi - z) lo++
+      else hi--
+    }
+  }
+
+  const res: number[] = []
+  for (let i = lo; i <= hi; i++) res.push(i)
+  return res.length >= minSpan ? res : []
+}

package/lib/types/capacity-mesh-types.ts

@@ -1,3 +1,5 @@
+import type { XYRect } from "lib/rectdiff-types"
+
 export type CapacityMeshNodeId = string
 
 export interface CapacityMesh {
@@ -31,3 +33,10 @@ export interface CapacityMeshEdge {
   capacityMeshEdgeId: string
   nodeIds: [CapacityMeshNodeId, CapacityMeshNodeId]
 }
+
+export type RTreeRect = XYRect & {
+  minX: number
+  minY: number
+  maxX: number
+  maxY: number
+}

package/lib/utils/buildHardPlacedByLayer.ts

@@ -0,0 +1,14 @@
+import type { Placed3D, XYRect } from "../rectdiff-types"
+
+export function allLayerNode(params: {
+  layerCount: number
+  placed: Placed3D[]
+}): XYRect[][] {
+  const out: XYRect[][] = Array.from({ length: params.layerCount }, () => [])
+  for (const p of params.placed) {
+    if (p.zLayers.length >= params.layerCount) {
+      for (const z of p.zLayers) out[z]!.push(p.rect)
+    }
+  }
+  return out
+}