fix regression soft nodes were treated as blockers they should not be

lib/solvers/RectDiffExpansionSolver/RectDiffExpansionSolver.ts

@@ -56,7 +56,10 @@ export class RectDiffExpansionSolver extends BaseSolver {
     for (const placement of this.input.placed) {
       for (const z of placement.zLayers) {
         const placedIndex = this.placedIndexByLayer[z]
-        if (placedIndex) placedIndex.insert(rectToTree(placement.rect))
+        if (placedIndex)
+          placedIndex.insert(
+            rectToTree(placement.rect, { zLayers: placement.zLayers }),
+          )
       }
     }
   }
@@ -104,8 +107,8 @@ export class RectDiffExpansionSolver extends BaseSolver {
       for (const z of p.zLayers) {
         const tree = this.placedIndexByLayer[z]
         if (tree) {
-          tree.remove(rectToTree(oldRect), sameTreeRect)
-          tree.insert(rectToTree(expanded))
+          tree.remove(rectToTree(oldRect, { zLayers: p.zLayers }), sameTreeRect)
+          tree.insert(rectToTree(expanded, { zLayers: p.zLayers }))
         }
       }
 

lib/solvers/RectDiffGridSolverPipeline/buildObstacleIndexes.ts

@@ -30,12 +30,13 @@ export const buildObstacleIndexesByLayer = (params: {
   )
 
   const insertObstacle = (rect: XYRect, z: number) => {
-    const treeRect = {
+    const treeRect: RTreeRect = {
       ...rect,
       minX: rect.x,
       minY: rect.y,
       maxX: rect.x + rect.width,
       maxY: rect.y + rect.height,
+      zLayers: [z],
     }
     obstacleIndexByLayer[z]?.insert(treeRect)
   }

lib/solvers/RectDiffSeedingSolver/RectDiffSeedingSolver.ts

@@ -21,6 +21,7 @@ import { resizeSoftOverlaps } from "../../utils/resizeSoftOverlaps"
 import { getColorForZLayer } from "lib/utils/getColorForZLayer"
 import RBush from "rbush"
 import type { RTreeRect } from "lib/types/capacity-mesh-types"
+import { rectToTree } from "lib/utils/rectToTree"
 
 export type RectDiffSeedingSolverInput = {
   simpleRouteJson: SimpleRouteJson
@@ -258,13 +259,7 @@ export class RectDiffSeedingSolver extends BaseSolver {
       for (const z of attempt.layers) {
         const idx = this.placedIndexByLayer[z]
         if (idx) {
-          idx.insert({
-            ...rect,
-            minX: rect.x,
-            minY: rect.y,
-            maxX: rect.x + rect.width,
-            maxY: rect.y + rect.height,
-          })
+          idx.insert(rectToTree(rect, { zLayers: placed.zLayers }))
         }
       }
 

lib/types/capacity-mesh-types.ts

@@ -39,4 +39,5 @@ export type RTreeRect = XYRect & {
   minY: number
   maxX: number
   maxY: number
+  zLayers: number[]
 }

lib/utils/expandRectFromSeed.ts

@@ -216,6 +216,7 @@ export function expandRectFromSeed(params: {
   const initialH = Math.max(minSide, minReq.height)
   const blockers: XYRect[] = []
   const seen = new Set<string>()
+  const totalLayers = placedIndexByLayer.length
 
   // Ignore the existing placement we are expanding so it doesn't self-block.
 
@@ -232,6 +233,8 @@ export function expandRectFromSeed(params: {
       const placedLayer = placedIndexByLayer[z]
       if (placedLayer) {
         for (const entry of placedLayer.search(query)) {
+          const isFullStack = entry.zLayers.length >= totalLayers
+          if (!isFullStack) continue
           const rect = toRect(entry)
           if (
             isSelfRect({

lib/utils/rectToTree.ts

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

lib/utils/resizeSoftOverlaps.ts

@@ -1,7 +1,8 @@
 import type { RTreeRect } from "lib/types/capacity-mesh-types"
-import type { Placed3D, XYRect } from "../rectdiff-types"
+import type { Placed3D } from "../rectdiff-types"
 import { overlaps, subtractRect2D, EPS } from "./rectdiff-geometry"
 import type RBush from "rbush"
+import { rectToTree } from "./rectToTree"
 
 export function resizeSoftOverlaps(
   params: {
@@ -57,13 +58,6 @@ export function resizeSoftOverlaps(
   }
 
   // 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 &&
@@ -77,7 +71,11 @@ export function resizeSoftOverlaps(
       if (params.placedIndexByLayer) {
         for (const z of rem.zLayers) {
           const tree = params.placedIndexByLayer[z]
-          if (tree) tree.remove(rectToTree(rem.rect), sameRect)
+          if (tree)
+            tree.remove(
+              rectToTree(rem.rect, { zLayers: rem.zLayers }),
+              sameRect,
+            )
         }
       }
     })
@@ -89,13 +87,7 @@ export function resizeSoftOverlaps(
       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,
-          })
+          idx.insert(rectToTree(p.rect, { zLayers: p.zLayers.slice() }))
         }
       }
     }