@tscircuit/rectdiff 0.0.13 → 0.0.15

package/lib/solvers/RectDiffSeedingSolver/longestFreeSpanAroundZ.ts

@@ -1,5 +1,7 @@
+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).
@@ -11,8 +13,8 @@ export function longestFreeSpanAroundZ(params: {
   layerCount: number
   minSpan: number
   maxSpan: number | undefined
-  obstaclesByLayer: XYRect[][]
-  placedByLayer: XYRect[][]
+  obstacleIndexByLayer: Array<RBush<RTreeRect> | undefined>
+  additionalBlockersByLayer?: XYRect[][]
 }): number[] {
   const {
     x,
@@ -21,16 +23,22 @@ export function longestFreeSpanAroundZ(params: {
     layerCount,
     minSpan,
     maxSpan,
-    obstaclesByLayer,
-    placedByLayer,
+    obstacleIndexByLayer,
+    additionalBlockersByLayer,
   } = params
 
   const isFreeAt = (layer: number) => {
-    const blockers = [
-      ...(obstaclesByLayer[layer] ?? []),
-      ...(placedByLayer[layer] ?? []),
-    ]
-    return !blockers.some((b) => containsPoint(b, { x, y }))
+    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

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/finalizeRects.ts

@@ -1,8 +1,14 @@
 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[]
-  obstaclesByLayer: XYRect[][]
+  srj: SimpleRouteJson
   boardVoidRects: XYRect[]
 }): Rect3d[] {
   // Convert all placed (free space) nodes to output format
@@ -14,33 +20,32 @@ export function finalizeRects(params: {
     zLayers: [...p.zLayers].sort((a, b) => a - b),
   }))
 
-  /**
-   * Recover obstacles as mesh nodes.
-   * Obstacles are stored per-layer in `obstaclesByLayer`, but we want to emit
-   * single 3D nodes for multi-layer obstacles if they share the same rect.
-   * We use the `XYRect` object reference identity to group layers.
-   */
-  const layersByObstacleRect = new Map<XYRect, number[]>()
+  const { zIndexByName } = buildZIndexMap(params.srj)
+  const layersByKey = new Map<string, { rect: XYRect; layers: Set<number> }>()
 
-  params.obstaclesByLayer.forEach((layerObs, z) => {
-    for (const rect of layerObs) {
-      const layerIndices = layersByObstacleRect.get(rect) ?? []
-      layerIndices.push(z)
-      layersByObstacleRect.set(rect, layerIndices)
+  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)
     }
-  })
-
-  // Append obstacle nodes to the output
-  const voidSet = new Set(params.boardVoidRects || [])
-  for (const [rect, layerIndices] of layersByObstacleRect.entries()) {
-    if (voidSet.has(rect)) continue // Skip void rects
+    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: layerIndices.sort((a, b) => a - b),
+      zLayers: Array.from(layers).sort((a, b) => a - b),
       isObstacle: true,
     })
   }

package/lib/utils/getColorForZLayer.ts

@@ -0,0 +1,17 @@
+export const 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" },
+  ] as const
+  return colors[minZ % colors.length]!
+}

package/lib/utils/isFullyOccupiedAtPoint.ts

@@ -1,21 +1,28 @@
-import type { XYRect } from "../rectdiff-types"
-import { containsPoint } from "./rectdiff-geometry"
+import type { RTreeRect } from "lib/types/capacity-mesh-types"
+import RBush from "rbush"
 
-export function isFullyOccupiedAtPoint(
-  params: {
-    layerCount: number
-    obstaclesByLayer: XYRect[][]
-    placedByLayer: XYRect[][]
-  },
-  point: { x: number; y: number },
-): boolean {
+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 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
+    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/resizeSoftOverlaps.ts

@@ -1,12 +1,14 @@
+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[]
-    placedByLayer: XYRect[][]
     options: any
+    placedIndexByLayer?: Array<RBush<RTreeRect> | undefined>
   },
   newIndex: number,
 ) {
@@ -54,21 +56,48 @@ export function resizeSoftOverlaps(
     }
   }
 
-  // Remove (and clear placedByLayer)
+  // 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]!
-      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)
+      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) params.placedByLayer[z]!.push(p.rect)
+    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.13",
+  "version": "0.0.15",
   "type": "module",
   "main": "dist/index.js",
   "scripts": {

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/fixtures/getPerLayerVisualizations.ts

@@ -0,0 +1,130 @@
+import type { GraphicsObject, Line, Point, Rect } from "graphics-debug"
+
+export function getPerLayerVisualizations(
+  graphics: GraphicsObject,
+): Map<string, GraphicsObject> {
+  const rects = (graphics.rects ?? []) as NonNullable<Rect[]>
+  const lines = (graphics.lines ?? []) as NonNullable<Line[]>
+  const points = (graphics.points ?? []) as NonNullable<Point[]>
+
+  const zValues = new Set<number>()
+
+  const addZValuesFromLayer = (layer: string) => {
+    if (!layer.startsWith("z")) return
+    const rest = layer.slice(1)
+    if (!rest) return
+    for (const part of rest.split(",")) {
+      const value = Number.parseInt(part, 10)
+      if (!Number.isNaN(value)) zValues.add(value)
+    }
+  }
+
+  for (const rect of rects) addZValuesFromLayer(rect.layer!)
+  for (const line of lines) addZValuesFromLayer(line.layer!)
+  for (const point of points) addZValuesFromLayer(point.layer!)
+
+  const result = new Map<string, GraphicsObject>()
+  if (!zValues.size) return result
+
+  const sortedZ = Array.from(zValues).sort((a, b) => a - b)
+
+  const commonRects: NonNullable<Rect[]> = []
+  const perLayerRects: { layers: number[]; rect: Rect }[] = []
+
+  for (const rect of rects) {
+    const layer = rect.layer!
+    if (layer.startsWith("z")) {
+      const rest = layer.slice(1)
+      if (rest) {
+        const layers = rest
+          .split(",")
+          .map((part) => Number.parseInt(part, 10))
+          .filter((value) => !Number.isNaN(value))
+        if (layers.length) {
+          perLayerRects.push({ layers, rect })
+          continue
+        }
+      }
+    }
+    commonRects.push(rect)
+  }
+
+  const commonLines: NonNullable<Line[]> = []
+  const perLayerLines: { layers: number[]; line: Line }[] = []
+
+  for (const line of lines) {
+    const layer = line.layer!
+    if (layer.startsWith("z")) {
+      const rest = layer.slice(1)
+      if (rest) {
+        const layers = rest
+          .split(",")
+          .map((part) => Number.parseInt(part, 10))
+          .filter((value) => !Number.isNaN(value))
+        if (layers.length) {
+          perLayerLines.push({ layers, line })
+          continue
+        }
+      }
+    }
+    commonLines.push(line)
+  }
+
+  const commonPoints: NonNullable<Point[]> = []
+  const perLayerPoints: { layers: number[]; point: Point }[] = []
+
+  for (const point of points) {
+    const layer = point.layer!
+    if (layer.startsWith("z")) {
+      const rest = layer.slice(1)
+      if (rest) {
+        const layers = rest
+          .split(",")
+          .map((part) => Number.parseInt(part, 10))
+          .filter((value) => !Number.isNaN(value))
+        if (layers.length) {
+          perLayerPoints.push({ layers, point })
+          continue
+        }
+      }
+    }
+    commonPoints.push(point)
+  }
+
+  const allCombos: number[][] = [[]]
+  for (const z of sortedZ) {
+    const withZ = allCombos.map((combo) => [...combo, z])
+    allCombos.push(...withZ)
+  }
+
+  for (const combo of allCombos.filter((c) => c.length > 0)) {
+    const key = `z${combo.join(",")}`
+
+    const layerRects: NonNullable<Rect[]> = [...commonRects]
+    const layerLines: NonNullable<Line[]> = [...commonLines]
+    const layerPoints: NonNullable<Point[]> = [...commonPoints]
+
+    const intersects = (layers: number[]) =>
+      layers.some((layer) => combo.includes(layer))
+
+    for (const { layers, rect } of perLayerRects) {
+      if (intersects(layers)) layerRects.push(rect)
+    }
+    for (const { layers, line } of perLayerLines) {
+      if (intersects(layers)) layerLines.push(line)
+    }
+    for (const { layers, point } of perLayerPoints) {
+      if (intersects(layers)) layerPoints.push(point)
+    }
+
+    result.set(key, {
+      title: `${graphics.title ?? ""} - z${combo.join(",")}`,
+      coordinateSystem: graphics.coordinateSystem,
+      rects: layerRects,
+      lines: layerLines,
+      points: layerPoints,
+    })
+  }
+
+  return result
+}

package/tests/fixtures/makeCapacityMeshNodeWithLayerInfo.ts

@@ -0,0 +1,33 @@
+import type { Rect } from "graphics-debug"
+import type { CapacityMeshNode } from "lib/types/capacity-mesh-types"
+import { getColorForZLayer } from "lib/utils/getColorForZLayer"
+
+export const makeCapacityMeshNodeWithLayerInfo = (
+  nodes: CapacityMeshNode[],
+): Map<string, Rect[]> => {
+  const map = new Map<string, Rect[]>()
+
+  for (const node of nodes) {
+    if (!node.availableZ.length) continue
+    const key = node.availableZ.join(",")
+    const colors = getColorForZLayer(node.availableZ)
+    const rect: Rect = {
+      center: node.center,
+      width: node.width,
+      height: node.height,
+      layer: `z${key}`,
+      stroke: "black",
+      fill: node._containsObstacle ? "red" : colors.fill,
+      label: "node",
+    }
+
+    const existing = map.get(key)
+    if (existing) {
+      existing.push(rect)
+    } else {
+      map.set(key, [rect])
+    }
+  }
+
+  return map
+}