Merge branch 'main' into snapshot-test

Author: 0hmX

lib/solvers/RectDiffExpansionSolver/RectDiffExpansionSolver.ts

@@ -1,13 +1,21 @@
 import { BaseSolver } from "@tscircuit/solver-utils"
 import type { GraphicsObject } from "graphics-debug"
-import type { CapacityMeshNode } from "../../types/capacity-mesh-types"
+import type { CapacityMeshNode, RTreeRect } from "lib/types/capacity-mesh-types"
 import { expandRectFromSeed } from "../../utils/expandRectFromSeed"
 import { finalizeRects } from "../../utils/finalizeRects"
 import { allLayerNode } from "../../utils/buildHardPlacedByLayer"
 import { resizeSoftOverlaps } from "../../utils/resizeSoftOverlaps"
 import { rectsToMeshNodes } from "./rectsToMeshNodes"
 import type { XYRect, Candidate3D, Placed3D } from "../../rectdiff-types"
-import type { SimpleRouteJson } from "../../types/srj-types"
+import type { SimpleRouteJson } from "lib/types/srj-types"
+import {
+  buildZIndexMap,
+  obstacleToXYRect,
+  obstacleZs,
+} from "../RectDiffSeedingSolver/layers"
+import RBush from "rbush"
+import { rectToTree } from "../../utils/rectToTree"
+import { sameTreeRect } from "../../utils/sameTreeRect"
 
 export type RectDiffExpansionSolverSnapshot = {
   srj: SimpleRouteJson
@@ -19,12 +27,10 @@ export type RectDiffExpansionSolverSnapshot = {
     // the engine only uses gridSizes here, other options are ignored
     [key: string]: any
   }
-  obstaclesByLayer: XYRect[][]
   boardVoidRects: XYRect[]
   gridIndex: number
   candidates: Candidate3D[]
   placed: Placed3D[]
-  placedByLayer: XYRect[][]
   expansionIndex: number
   edgeAnalysisDone: boolean
   totalSeedsThisGrid: number
@@ -33,6 +39,7 @@ export type RectDiffExpansionSolverSnapshot = {
 
 export type RectDiffExpansionSolverInput = {
   initialSnapshot: RectDiffExpansionSolverSnapshot
+  obstacleIndexByLayer: Array<RBush<RTreeRect>>
 }
 
 /**
@@ -52,12 +59,11 @@ export class RectDiffExpansionSolver extends BaseSolver {
     // the engine only uses gridSizes here, other options are ignored
     [key: string]: any
   }
-  private obstaclesByLayer!: XYRect[][]
   private boardVoidRects!: XYRect[]
   private gridIndex!: number
   private candidates!: Candidate3D[]
   private placed!: Placed3D[]
-  private placedByLayer!: XYRect[][]
+  private placedIndexByLayer!: Array<RBush<RTreeRect>>
   private expansionIndex!: number
   private edgeAnalysisDone!: boolean
   private totalSeedsThisGrid!: number
@@ -75,6 +81,44 @@ export class RectDiffExpansionSolver extends BaseSolver {
     this.stats = {
       gridIndex: this.gridIndex,
     }
+
+    if (this.input.obstacleIndexByLayer) {
+    } else {
+      const { zIndexByName } = buildZIndexMap(this.srj)
+      this.input.obstacleIndexByLayer = Array.from(
+        { length: this.layerCount },
+        () => new RBush<RTreeRect>(),
+      )
+      const insertObstacle = (rect: XYRect, z: number) => {
+        const tree = this.input.obstacleIndexByLayer[z]
+        if (tree) tree.insert(rectToTree(rect))
+      }
+      for (const voidRect of this.boardVoidRects ?? []) {
+        for (let z = 0; z < this.layerCount; z++) insertObstacle(voidRect, z)
+      }
+      for (const obstacle of this.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)
+        zLayers.forEach((z) => {
+          if (z >= 0 && z < this.layerCount) insertObstacle(rect, z)
+        })
+      }
+    }
+
+    this.placedIndexByLayer = Array.from(
+      { length: this.layerCount },
+      () => new RBush<RTreeRect>(),
+    )
+    for (const placement of this.placed ?? []) {
+      for (const z of placement.zLayers) {
+        const tree = this.placedIndexByLayer[z]
+        if (tree) tree.insert(rectToTree(placement.rect))
+      }
+    }
   }
 
   override _step() {
@@ -107,7 +151,8 @@ export class RectDiffExpansionSolver extends BaseSolver {
     // HARD blockers only: obstacles on p.zLayers + full-stack nodes
     const hardBlockers: XYRect[] = []
     for (const z of p.zLayers) {
-      hardBlockers.push(...(this.obstaclesByLayer[z] ?? []))
+      const obstacleTree = this.input.obstacleIndexByLayer[z]
+      if (obstacleTree) hardBlockers.push(...obstacleTree.all())
       hardBlockers.push(...(hardPlacedByLayer[z] ?? []))
     }
 
@@ -127,18 +172,20 @@ export class RectDiffExpansionSolver extends BaseSolver {
       // Update placement + per-layer index (replace old rect object)
       this.placed[idx] = { rect: expanded, zLayers: p.zLayers }
       for (const z of p.zLayers) {
-        const arr = this.placedByLayer[z]!
-        const j = arr.findIndex((r) => r === oldRect)
-        if (j >= 0) arr[j] = expanded
+        const tree = this.placedIndexByLayer[z]
+        if (tree) {
+          tree.remove(rectToTree(oldRect), sameTreeRect)
+          tree.insert(rectToTree(expanded))
+        }
       }
 
       // Carve overlapped soft neighbors (respect full-stack nodes)
       resizeSoftOverlaps(
         {
           layerCount: this.layerCount,
           placed: this.placed,
-          placedByLayer: this.placedByLayer,
           options: this.options,
+          placedIndexByLayer: this.placedIndexByLayer,
         },
         idx,
       )
@@ -152,7 +199,7 @@ export class RectDiffExpansionSolver extends BaseSolver {
 
     const rects = finalizeRects({
       placed: this.placed,
-      obstaclesByLayer: this.obstaclesByLayer,
+      srj: this.srj,
       boardVoidRects: this.boardVoidRects,
     })
     this._meshNodes = rectsToMeshNodes(rects)

lib/solvers/RectDiffGridSolverPipeline/RectDiffGridSolverPipeline.ts

@@ -3,12 +3,14 @@ import {
   definePipelineStep,
   type PipelineStep,
 } from "@tscircuit/solver-utils"
-import type { SimpleRouteJson } from "../../types/srj-types"
-import type { GridFill3DOptions } from "../../rectdiff-types"
-import type { CapacityMeshNode } from "../../types/capacity-mesh-types"
-import { RectDiffSeedingSolver } from "../RectDiffSeedingSolver/RectDiffSeedingSolver"
-import { RectDiffExpansionSolver } from "../RectDiffExpansionSolver/RectDiffExpansionSolver"
+import type { SimpleRouteJson } from "lib/types/srj-types"
+import type { GridFill3DOptions, XYRect } from "lib/rectdiff-types"
+import type { CapacityMeshNode, RTreeRect } from "lib/types/capacity-mesh-types"
+import { RectDiffSeedingSolver } from "lib/solvers/RectDiffSeedingSolver/RectDiffSeedingSolver"
+import { RectDiffExpansionSolver } from "lib/solvers/RectDiffExpansionSolver/RectDiffExpansionSolver"
 import type { GraphicsObject } from "graphics-debug"
+import RBush from "rbush"
+import { buildObstacleIndexes } from "./buildObstacleIndexes"
 
 export type RectDiffGridSolverPipelineInput = {
   simpleRouteJson: SimpleRouteJson
@@ -18,6 +20,17 @@ export type RectDiffGridSolverPipelineInput = {
 export class RectDiffGridSolverPipeline extends BasePipelineSolver<RectDiffGridSolverPipelineInput> {
   rectDiffSeedingSolver?: RectDiffSeedingSolver
   rectDiffExpansionSolver?: RectDiffExpansionSolver
+  private boardVoidRects?: XYRect[]
+  private obstacleIndexByLayer: Array<RBush<RTreeRect>>
+
+  constructor(inputProblem: RectDiffGridSolverPipelineInput) {
+    super(inputProblem)
+    const { obstacleIndexByLayer, boardVoidRects } = buildObstacleIndexes(
+      inputProblem.simpleRouteJson,
+    )
+    this.obstacleIndexByLayer = obstacleIndexByLayer
+    this.boardVoidRects = boardVoidRects
+  }
 
   override pipelineDef: PipelineStep<any>[] = [
     definePipelineStep(
@@ -27,6 +40,8 @@ export class RectDiffGridSolverPipeline extends BasePipelineSolver<RectDiffGridS
         {
           simpleRouteJson: pipeline.inputProblem.simpleRouteJson,
           gridOptions: pipeline.inputProblem.gridOptions,
+          obstacleIndexByLayer: pipeline.obstacleIndexByLayer,
+          boardVoidRects: pipeline.boardVoidRects,
         },
       ],
     ),
@@ -35,7 +50,11 @@ export class RectDiffGridSolverPipeline extends BasePipelineSolver<RectDiffGridS
       RectDiffExpansionSolver,
       (pipeline: RectDiffGridSolverPipeline) => [
         {
-          initialSnapshot: pipeline.rectDiffSeedingSolver!.getOutput(),
+          initialSnapshot: {
+            ...pipeline.rectDiffSeedingSolver!.getOutput(),
+            boardVoidRects: pipeline.boardVoidRects ?? [],
+          },
+          obstacleIndexByLayer: pipeline.obstacleIndexByLayer,
         },
       ],
     ),

lib/solvers/RectDiffGridSolverPipeline/buildObstacleIndexes.ts

@@ -0,0 +1,70 @@
+import type { SimpleRouteJson } from "lib/types/srj-types"
+import RBush from "rbush"
+import { computeInverseRects } from "lib/solvers/RectDiffSeedingSolver/computeInverseRects"
+import {
+  buildZIndexMap,
+  obstacleToXYRect,
+  obstacleZs,
+} from "lib/solvers/RectDiffSeedingSolver/layers"
+import type { XYRect } from "lib/rectdiff-types"
+import type { RTreeRect } from "lib/types/capacity-mesh-types"
+
+export const buildObstacleIndexes = (
+  srj: SimpleRouteJson,
+): {
+  obstacleIndexByLayer: Array<RBush<RTreeRect>>
+  boardVoidRects: XYRect[]
+} => {
+  const { layerNames, zIndexByName } = buildZIndexMap(srj)
+  const layerCount = Math.max(1, layerNames.length, srj.layerCount || 1)
+  const bounds: XYRect = {
+    x: srj.bounds.minX,
+    y: srj.bounds.minY,
+    width: srj.bounds.maxX - srj.bounds.minX,
+    height: srj.bounds.maxY - srj.bounds.minY,
+  }
+  const obstacleIndexByLayer = Array.from(
+    { length: layerCount },
+    () => new RBush<RTreeRect>(),
+  )
+
+  const insertObstacle = (rect: XYRect, z: number) => {
+    const treeRect = {
+      ...rect,
+      minX: rect.x,
+      minY: rect.y,
+      maxX: rect.x + rect.width,
+      maxY: rect.y + rect.height,
+    }
+    obstacleIndexByLayer[z]?.insert(treeRect)
+  }
+
+  let boardVoidRects: XYRect[] = []
+  if (srj.outline && srj.outline.length > 2) {
+    boardVoidRects = computeInverseRects(bounds, srj.outline as any)
+    for (const voidRect of boardVoidRects) {
+      for (let z = 0; z < layerCount; z++) insertObstacle(voidRect, z)
+    }
+  }
+
+  for (const obstacle of srj.obstacles ?? []) {
+    const rect = obstacleToXYRect(obstacle as any)
+    if (!rect) continue
+    const zLayers = obstacleZs(obstacle as any, zIndexByName)
+    const invalidZs = zLayers.filter((z) => z < 0 || z >= layerCount)
+    if (invalidZs.length) {
+      throw new Error(
+        `RectDiff: obstacle uses z-layer indices ${invalidZs.join(",")} outside 0-${layerCount - 1}`,
+      )
+    }
+    if (
+      (!obstacle.zLayers || obstacle.zLayers.length === 0) &&
+      zLayers.length
+    ) {
+      obstacle.zLayers = zLayers
+    }
+    for (const z of zLayers) insertObstacle(rect, z)
+  }
+
+  return { obstacleIndexByLayer, boardVoidRects }
+}