@tscircuit/rectdiff 0.0.21 → 0.0.23

package/components/SolverDebugger3d.tsx

@@ -602,7 +602,7 @@ export const SolverDebugger3d: React.FC<SolverDebugger3dProps> = ({
   useEffect(() => {
     const interval = setInterval(() => {
       // Only update if solver has output available
-      if (solver.solved || (solver as any).stats?.placed > 0) {
+      if (solver.solved || solver.stats?.placed > 0) {
         updateMeshNodes()
       }
     }, 100) // Poll every 100ms during active solving
@@ -731,7 +731,7 @@ export const SolverDebugger3d: React.FC<SolverDebugger3dProps> = ({
         {/* Render 2D view */}
         {renderMode === "2d" && (
           <GenericSolverDebugger
-            solver={solver as any}
+            solver={solver}
             onSolverCompleted={handleSolverCompleted}
           />
         )}

package/dist/index.d.ts

@@ -220,6 +220,9 @@ type RectDiffSeedingSolverInput = {
     obstacleIndexByLayer: Array<RBush<RTreeRect>>;
     gridOptions?: Partial<GridFill3DOptions>;
     boardVoidRects?: XYRect[];
+    layerNames: string[];
+    zIndexByName: Map<string, number>;
+    obstacleClearance?: number;
 };
 /**
  * First phase of RectDiff: grid-based seeding and placement.
@@ -258,7 +261,6 @@ declare class RectDiffSeedingSolver extends BaseSolver {
      * expansion phase solver.
      */
     getOutput(): {
-        srj: SimpleRouteJson;
         layerNames: string[];
         layerCount: number;
         bounds: XYRect;
@@ -274,13 +276,14 @@ declare class RectDiffSeedingSolver extends BaseSolver {
         edgeAnalysisDone: boolean;
         totalSeedsThisGrid: number;
         consumedSeedsThisGrid: number;
+        obstacles: Obstacle[];
+        obstacleClearance: number | undefined;
     };
     /** Visualization focused on the grid seeding phase. */
     visualize(): GraphicsObject;
 }
 
 type RectDiffExpansionSolverInput = {
-    srj: SimpleRouteJson;
     layerNames: string[];
     layerCount: number;
     bounds: XYRect;
@@ -297,6 +300,10 @@ type RectDiffExpansionSolverInput = {
     totalSeedsThisGrid: number;
     consumedSeedsThisGrid: number;
     obstacleIndexByLayer: Array<RBush<RTreeRect>>;
+    zIndexByName: Map<string, number>;
+    layerNamesCanonical: string[];
+    obstacles: Obstacle[];
+    obstacleClearance?: number;
 };
 /**
  * Second phase of RectDiff: expand placed rects to their maximal extents.
@@ -322,14 +329,24 @@ declare class RectDiffExpansionSolver extends BaseSolver {
 }
 
 type RectDiffGridSolverPipelineInput = {
-    simpleRouteJson: SimpleRouteJson;
+    bounds: Bounds;
+    obstacles: Obstacle[];
+    connections: SimpleRouteConnection[];
+    outline?: Pick<SimpleRouteJson, "outline">;
+    layerCount: number;
+    minTraceWidth: number;
+    obstacleClearance?: number;
     gridOptions?: Partial<GridFill3DOptions>;
     boardVoidRects?: XYRect[];
+    layerNames?: string[];
+    zIndexByName?: Map<string, number>;
 };
 declare class RectDiffGridSolverPipeline extends BasePipelineSolver<RectDiffGridSolverPipelineInput> {
     rectDiffSeedingSolver?: RectDiffSeedingSolver;
     rectDiffExpansionSolver?: RectDiffExpansionSolver;
     private obstacleIndexByLayer;
+    private layerNames;
+    private zIndexByName;
     constructor(inputProblem: RectDiffGridSolverPipelineInput);
     pipelineDef: PipelineStep<any>[];
     getConstructorParams(): RectDiffGridSolverPipelineInput[];
@@ -342,11 +359,14 @@ declare class RectDiffGridSolverPipeline extends BasePipelineSolver<RectDiffGrid
 interface RectDiffPipelineInput {
     simpleRouteJson: SimpleRouteJson;
     gridOptions?: Partial<GridFill3DOptions>;
+    obstacleClearance?: number;
 }
 declare class RectDiffPipeline extends BasePipelineSolver<RectDiffPipelineInput> {
     rectDiffGridSolverPipeline?: RectDiffGridSolverPipeline;
     gapFillSolver?: GapFillSolverPipeline;
     boardVoidRects: XYRect[] | undefined;
+    zIndexByName?: Map<string, number>;
+    layerNames?: string[];
     pipelineDef: PipelineStep<any>[];
     _setup(): void;
     getConstructorParams(): RectDiffPipelineInput[];

package/dist/index.js

@@ -749,11 +749,31 @@ function isPointInPolygon(p, polygon) {
 }
 
 // lib/solvers/RectDiffSeedingSolver/computeInverseRects.ts
+function simplifyPolygon(polygon, precision) {
+  const round = (v) => Math.round(v / precision) * precision;
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const p of polygon) {
+    const rx = round(p.x);
+    const ry = round(p.y);
+    const key = `${rx},${ry}`;
+    if (!seen.has(key)) {
+      seen.add(key);
+      result.push({ x: rx, y: ry });
+    }
+  }
+  return result;
+}
 function computeInverseRects(bounds, polygon) {
   if (!polygon || polygon.length < 3) return [];
+  const MAX_POLYGON_POINTS = 100;
+  const workingPolygon = polygon.length > MAX_POLYGON_POINTS ? simplifyPolygon(
+    polygon,
+    Math.max(bounds.width, bounds.height) / MAX_POLYGON_POINTS
+  ) : polygon;
   const xs = /* @__PURE__ */ new Set([bounds.x, bounds.x + bounds.width]);
   const ys = /* @__PURE__ */ new Set([bounds.y, bounds.y + bounds.height]);
-  for (const p of polygon) {
+  for (const p of workingPolygon) {
     xs.add(p.x);
     ys.add(p.y);
   }
@@ -839,11 +859,11 @@ function canonicalizeLayerOrder(names) {
     return a.localeCompare(b);
   });
 }
-function buildZIndexMap(srj) {
+function buildZIndexMap(params) {
   const names = canonicalizeLayerOrder(
-    (srj.obstacles ?? []).flatMap((o) => o.layers ?? [])
+    (params.obstacles ?? []).flatMap((o) => o.layers ?? [])
   );
-  const declaredLayerCount = Math.max(1, srj.layerCount || names.length || 1);
+  const declaredLayerCount = Math.max(1, params.layerCount || names.length || 1);
   const fallback = Array.from(
     { length: declaredLayerCount },
     (_, i) => i === 0 ? "top" : i === declaredLayerCount - 1 ? "bottom" : `inner${i}`
@@ -1113,34 +1133,38 @@ function expandRectFromSeed(params) {
       continue;
     }
     for (const b of blockers) if (overlaps(r, b)) continue STRATS;
+    const MIN_EXPANSION = 1e-6;
+    const MAX_ITERATIONS = 1e3;
     let improved = true;
-    while (improved) {
+    let iterations = 0;
+    while (improved && iterations < MAX_ITERATIONS) {
+      iterations++;
       improved = false;
       const commonParams = { bounds, blockers, maxAspect: maxAspectRatio };
       collectBlockers(searchStripRight({ rect: r, bounds }));
       const eR = maxExpandRight({ ...commonParams, r });
-      if (eR > 0) {
+      if (eR > MIN_EXPANSION) {
         r = { ...r, width: r.width + eR };
         collectBlockers(r);
         improved = true;
       }
       collectBlockers(searchStripDown({ rect: r, bounds }));
       const eD = maxExpandDown({ ...commonParams, r });
-      if (eD > 0) {
+      if (eD > MIN_EXPANSION) {
         r = { ...r, height: r.height + eD };
         collectBlockers(r);
         improved = true;
       }
       collectBlockers(searchStripLeft({ rect: r, bounds }));
       const eL = maxExpandLeft({ ...commonParams, r });
-      if (eL > 0) {
+      if (eL > MIN_EXPANSION) {
         r = { x: r.x - eL, y: r.y, width: r.width + eL, height: r.height };
         collectBlockers(r);
         improved = true;
       }
       collectBlockers(searchStripUp({ rect: r, bounds }));
       const eU = maxExpandUp({ ...commonParams, r });
-      if (eU > 0) {
+      if (eU > MIN_EXPANSION) {
         r = { x: r.x, y: r.y - eU, width: r.width, height: r.height + eU };
         collectBlockers(r);
         improved = true;
@@ -1686,7 +1710,14 @@ var RectDiffSeedingSolver = class extends BaseSolver3 {
   _setup() {
     const srj = this.input.simpleRouteJson;
     const opts = this.input.gridOptions ?? {};
-    const { layerNames, zIndexByName } = buildZIndexMap(srj);
+    const precomputed = this.input.layerNames && this.input.zIndexByName;
+    const { layerNames, zIndexByName } = precomputed ? {
+      layerNames: this.input.layerNames,
+      zIndexByName: this.input.zIndexByName
+    } : buildZIndexMap({
+      obstacles: srj.obstacles,
+      layerCount: srj.layerCount
+    });
     const layerCount = Math.max(1, layerNames.length, srj.layerCount || 1);
     const bounds = {
       x: srj.bounds.minX,
@@ -1884,7 +1915,6 @@ var RectDiffSeedingSolver = class extends BaseSolver3 {
    */
   getOutput() {
     return {
-      srj: this.srj,
       layerNames: this.layerNames,
       layerCount: this.layerCount,
       bounds: this.bounds,
@@ -1896,7 +1926,9 @@ var RectDiffSeedingSolver = class extends BaseSolver3 {
       expansionIndex: this.expansionIndex,
       edgeAnalysisDone: this.edgeAnalysisDone,
       totalSeedsThisGrid: this.totalSeedsThisGrid,
-      consumedSeedsThisGrid: this.consumedSeedsThisGrid
+      consumedSeedsThisGrid: this.consumedSeedsThisGrid,
+      obstacles: this.srj.obstacles,
+      obstacleClearance: this.input.obstacleClearance
     };
   }
   /** Visualization focused on the grid seeding phase. */
@@ -1944,6 +1976,29 @@ var RectDiffSeedingSolver = class extends BaseSolver3 {
         });
       }
     }
+    if (this.input.obstacleClearance && this.input.obstacleClearance > 0) {
+      for (const obstacle of srj.obstacles ?? []) {
+        const pad = this.input.obstacleClearance;
+        const expanded = {
+          x: obstacle.center.x - obstacle.width / 2 - pad,
+          y: obstacle.center.y - obstacle.height / 2 - pad,
+          width: obstacle.width + 2 * pad,
+          height: obstacle.height + 2 * pad
+        };
+        rects.push({
+          center: {
+            x: expanded.x + expanded.width / 2,
+            y: expanded.y + expanded.height / 2
+          },
+          width: expanded.width,
+          height: expanded.height,
+          fill: "rgba(234, 179, 8, 0.15)",
+          stroke: "rgba(202, 138, 4, 0.9)",
+          layer: "obstacle-clearance",
+          label: "clearance"
+        });
+      }
+    }
     if (this.boardVoidRects) {
       let outlineBBox = null;
       if (srj.outline && srj.outline.length > 0) {
@@ -1977,8 +2032,6 @@ var RectDiffSeedingSolver = class extends BaseSolver3 {
         points.push({
           x: cand.x,
           y: cand.y,
-          fill: "#9333ea",
-          stroke: "#6b21a8",
           label: `z:${cand.z}`
         });
       }
@@ -2023,12 +2076,17 @@ function finalizeRects(params) {
     maxY: p.rect.y + p.rect.height,
     zLayers: [...p.zLayers].sort((a, b) => a - b)
   }));
-  const { zIndexByName } = buildZIndexMap(params.srj);
   const layersByKey = /* @__PURE__ */ new Map();
-  for (const obstacle of params.srj.obstacles ?? []) {
-    const rect = obstacleToXYRect(obstacle);
-    if (!rect) continue;
-    const zLayers = obstacle.zLayers?.length && obstacle.zLayers.length > 0 ? obstacle.zLayers : obstacleZs(obstacle, zIndexByName);
+  for (const obstacle of params.obstacles ?? []) {
+    const baseRect = obstacleToXYRect(obstacle);
+    if (!baseRect) continue;
+    const rect = params.obstacleClearance ? {
+      x: baseRect.x - params.obstacleClearance,
+      y: baseRect.y - params.obstacleClearance,
+      width: baseRect.width + 2 * params.obstacleClearance,
+      height: baseRect.height + 2 * params.obstacleClearance
+    } : baseRect;
+    const zLayers = obstacle.zLayers?.length && obstacle.zLayers.length > 0 ? obstacle.zLayers : obstacleZs(obstacle, params.zIndexByName);
     const key = `${rect.x}:${rect.y}:${rect.width}:${rect.height}`;
     let entry = layersByKey.get(key);
     if (!entry) {
@@ -2158,8 +2216,10 @@ var RectDiffExpansionSolver = class extends BaseSolver4 {
     if (this.solved) return;
     const rects = finalizeRects({
       placed: this.input.placed,
-      srj: this.input.srj,
-      boardVoidRects: this.input.boardVoidRects
+      obstacles: this.input.obstacles,
+      zIndexByName: this.input.zIndexByName,
+      boardVoidRects: this.input.boardVoidRects,
+      obstacleClearance: this.input.obstacleClearance
     });
     this._meshNodes = rectsToMeshNodes(rects);
     this.solved = true;
@@ -2222,9 +2282,25 @@ import "rbush";
 
 // lib/solvers/RectDiffGridSolverPipeline/buildObstacleIndexes.ts
 import RBush5 from "rbush";
+
+// lib/utils/padRect.ts
+var padRect = (rect, clearance) => {
+  if (!clearance || clearance <= 0) return rect;
+  return {
+    x: rect.x - clearance,
+    y: rect.y - clearance,
+    width: rect.width + 2 * clearance,
+    height: rect.height + 2 * clearance
+  };
+};
+
+// lib/solvers/RectDiffGridSolverPipeline/buildObstacleIndexes.ts
 var buildObstacleIndexesByLayer = (params) => {
-  const { srj, boardVoidRects } = params;
-  const { layerNames, zIndexByName } = buildZIndexMap(srj);
+  const { srj, boardVoidRects, obstacleClearance } = params;
+  const { layerNames, zIndexByName } = buildZIndexMap({
+    obstacles: srj.obstacles,
+    layerCount: srj.layerCount
+  });
   const layerCount = Math.max(1, layerNames.length, srj.layerCount || 1);
   const bounds = {
     x: srj.bounds.minX,
@@ -2253,8 +2329,9 @@ var buildObstacleIndexesByLayer = (params) => {
     }
   }
   for (const obstacle of srj.obstacles ?? []) {
-    const rect = obstacleToXYRect(obstacle);
-    if (!rect) continue;
+    const rectBase = obstacleToXYRect(obstacle);
+    if (!rectBase) continue;
+    const rect = padRect(rectBase, obstacleClearance ?? 0);
     const zLayers = obstacleZs(obstacle, zIndexByName);
     const invalidZs = zLayers.filter((z) => z < 0 || z >= layerCount);
     if (invalidZs.length) {
@@ -2267,7 +2344,7 @@ var buildObstacleIndexesByLayer = (params) => {
     }
     for (const z of zLayers) insertObstacle(rect, z);
   }
-  return { obstacleIndexByLayer };
+  return { obstacleIndexByLayer, layerNames, zIndexByName };
 };
 
 // lib/solvers/RectDiffGridSolverPipeline/RectDiffGridSolverPipeline.ts
@@ -2275,13 +2352,25 @@ var RectDiffGridSolverPipeline = class extends BasePipelineSolver2 {
   rectDiffSeedingSolver;
   rectDiffExpansionSolver;
   obstacleIndexByLayer;
+  layerNames;
+  zIndexByName;
   constructor(inputProblem) {
     super(inputProblem);
-    const { obstacleIndexByLayer } = buildObstacleIndexesByLayer({
-      srj: inputProblem.simpleRouteJson,
-      boardVoidRects: inputProblem.boardVoidRects
+    const { obstacleIndexByLayer, layerNames, zIndexByName } = buildObstacleIndexesByLayer({
+      srj: {
+        bounds: inputProblem.bounds,
+        obstacles: inputProblem.obstacles,
+        connections: inputProblem.connections,
+        outline: inputProblem.outline?.outline,
+        layerCount: inputProblem.layerCount,
+        minTraceWidth: inputProblem.minTraceWidth
+      },
+      boardVoidRects: inputProblem.boardVoidRects,
+      obstacleClearance: inputProblem.obstacleClearance
     });
     this.obstacleIndexByLayer = obstacleIndexByLayer;
+    this.layerNames = inputProblem.layerNames ?? layerNames;
+    this.zIndexByName = inputProblem.zIndexByName ?? zIndexByName;
   }
   pipelineDef = [
     definePipelineStep2(
@@ -2289,10 +2378,20 @@ var RectDiffGridSolverPipeline = class extends BasePipelineSolver2 {
       RectDiffSeedingSolver,
       (pipeline) => [
         {
-          simpleRouteJson: pipeline.inputProblem.simpleRouteJson,
+          simpleRouteJson: {
+            bounds: pipeline.inputProblem.bounds,
+            obstacles: pipeline.inputProblem.obstacles,
+            connections: pipeline.inputProblem.connections,
+            outline: pipeline.inputProblem.outline?.outline,
+            layerCount: pipeline.inputProblem.layerCount,
+            minTraceWidth: pipeline.inputProblem.minTraceWidth
+          },
           gridOptions: pipeline.inputProblem.gridOptions,
           obstacleIndexByLayer: pipeline.obstacleIndexByLayer,
-          boardVoidRects: pipeline.inputProblem.boardVoidRects
+          boardVoidRects: pipeline.inputProblem.boardVoidRects,
+          layerNames: pipeline.layerNames,
+          zIndexByName: pipeline.zIndexByName,
+          obstacleClearance: pipeline.inputProblem.obstacleClearance
         }
       ]
     ),
@@ -2306,10 +2405,9 @@ var RectDiffGridSolverPipeline = class extends BasePipelineSolver2 {
         }
         return [
           {
-            srj: pipeline.inputProblem.simpleRouteJson,
             layerNames: output.layerNames ?? [],
             boardVoidRects: pipeline.inputProblem.boardVoidRects ?? [],
-            layerCount: pipeline.inputProblem.simpleRouteJson.layerCount,
+            layerCount: pipeline.inputProblem.layerCount,
             bounds: output.bounds,
             candidates: output.candidates,
             consumedSeedsThisGrid: output.placed.length,
@@ -2319,7 +2417,11 @@ var RectDiffGridSolverPipeline = class extends BasePipelineSolver2 {
             gridIndex: output.gridIndex,
             expansionIndex: output.expansionIndex,
             obstacleIndexByLayer: pipeline.obstacleIndexByLayer,
-            options: output.options
+            options: output.options,
+            zIndexByName: pipeline.zIndexByName,
+            layerNamesCanonical: pipeline.layerNames,
+            obstacles: pipeline.inputProblem.obstacles,
+            obstacleClearance: pipeline.inputProblem.obstacleClearance
           }
         ];
       }
@@ -2400,6 +2502,7 @@ function createBaseVisualization(srj, title = "RectDiff") {
   }
   for (const obstacle of srj.obstacles ?? []) {
     if (obstacle.type === "rect" || obstacle.type === "oval") {
+      const layerLabel = (obstacle.zLayers ?? []).join(",") || "all";
       rects.push({
         center: { x: obstacle.center.x, y: obstacle.center.y },
         width: obstacle.width,
@@ -2407,7 +2510,8 @@ function createBaseVisualization(srj, title = "RectDiff") {
         fill: "#fee2e2",
         stroke: "#ef4444",
         layer: "obstacle",
-        label: "obstacle"
+        label: `obstacle
+z:${layerLabel}`
       });
     }
   }
@@ -2420,20 +2524,72 @@ function createBaseVisualization(srj, title = "RectDiff") {
   };
 }
 
+// lib/utils/renderObstacleClearance.ts
+var buildObstacleClearanceGraphics = (params) => {
+  const { srj, clearance } = params;
+  const c = clearance ?? 0;
+  if (c <= 0) {
+    return {
+      title: "Obstacle Clearance",
+      coordinateSystem: "cartesian",
+      rects: []
+    };
+  }
+  const rects = [];
+  for (const obstacle of srj.obstacles ?? []) {
+    if (obstacle.type !== "rect" && obstacle.type !== "oval") continue;
+    const expanded = {
+      x: obstacle.center.x - obstacle.width / 2 - c,
+      y: obstacle.center.y - obstacle.height / 2 - c,
+      width: obstacle.width + 2 * c,
+      height: obstacle.height + 2 * c
+    };
+    rects.push({
+      center: {
+        x: expanded.x + expanded.width / 2,
+        y: expanded.y + expanded.height / 2
+      },
+      width: expanded.width,
+      height: expanded.height,
+      stroke: "rgba(202, 138, 4, 0.9)",
+      fill: "rgba(234, 179, 8, 0.15)",
+      layer: "obstacle-clearance",
+      label: `clearance
+z:${(obstacle.zLayers ?? []).join(",") || "all"}`
+    });
+  }
+  return {
+    title: "Obstacle Clearance",
+    coordinateSystem: "cartesian",
+    rects
+  };
+};
+
 // lib/RectDiffPipeline.ts
+import { mergeGraphics } from "graphics-debug";
 var RectDiffPipeline = class extends BasePipelineSolver3 {
   rectDiffGridSolverPipeline;
   gapFillSolver;
   boardVoidRects;
+  zIndexByName;
+  layerNames;
   pipelineDef = [
     definePipelineStep3(
       "rectDiffGridSolverPipeline",
       RectDiffGridSolverPipeline,
       (rectDiffPipeline) => [
         {
-          simpleRouteJson: rectDiffPipeline.inputProblem.simpleRouteJson,
+          bounds: rectDiffPipeline.inputProblem.simpleRouteJson.bounds,
+          obstacles: rectDiffPipeline.inputProblem.simpleRouteJson.obstacles,
+          connections: rectDiffPipeline.inputProblem.simpleRouteJson.connections,
+          outline: rectDiffPipeline.inputProblem.simpleRouteJson.outline ? { outline: rectDiffPipeline.inputProblem.simpleRouteJson.outline } : void 0,
+          layerCount: rectDiffPipeline.inputProblem.simpleRouteJson.layerCount,
           gridOptions: rectDiffPipeline.inputProblem.gridOptions,
-          boardVoidRects: rectDiffPipeline.boardVoidRects
+          boardVoidRects: rectDiffPipeline.boardVoidRects,
+          layerNames: rectDiffPipeline.layerNames,
+          zIndexByName: rectDiffPipeline.zIndexByName,
+          minTraceWidth: rectDiffPipeline.inputProblem.simpleRouteJson.minTraceWidth,
+          obstacleClearance: rectDiffPipeline.inputProblem.obstacleClearance
         }
       ]
     ),
@@ -2452,6 +2608,12 @@ var RectDiffPipeline = class extends BasePipelineSolver3 {
     )
   ];
   _setup() {
+    const { zIndexByName, layerNames } = buildZIndexMap({
+      obstacles: this.inputProblem.simpleRouteJson.obstacles,
+      layerCount: this.inputProblem.simpleRouteJson.layerCount
+    });
+    this.zIndexByName = zIndexByName;
+    this.layerNames = layerNames;
     if (this.inputProblem.simpleRouteJson.outline) {
       this.boardVoidRects = computeInverseRects(
         {
@@ -2478,13 +2640,19 @@ var RectDiffPipeline = class extends BasePipelineSolver3 {
     return { meshNodes: [] };
   }
   initialVisualize() {
-    const graphics = createBaseVisualization(
+    const base = createBaseVisualization(
       this.inputProblem.simpleRouteJson,
       "RectDiffPipeline - Initial"
     );
+    const clearance = buildObstacleClearanceGraphics({
+      srj: this.inputProblem.simpleRouteJson,
+      clearance: this.inputProblem.obstacleClearance
+    });
     const initialNodes = this.rectDiffGridSolverPipeline?.getOutput().meshNodes ?? [];
-    for (const node of initialNodes) {
-      graphics.rects.push({
+    const nodeRects = {
+      title: "Initial Nodes",
+      coordinateSystem: "cartesian",
+      rects: initialNodes.map((node) => ({
         center: node.center,
         width: node.width,
         height: node.height,
@@ -2495,37 +2663,45 @@ var RectDiffPipeline = class extends BasePipelineSolver3 {
           `node ${node.capacityMeshNodeId}`,
           `z:${node.availableZ.join(",")}`
         ].join("\n")
-      });
-    }
-    return graphics;
+      }))
+    };
+    return mergeGraphics(mergeGraphics(base, clearance), nodeRects);
   }
   finalVisualize() {
-    const graphics = createBaseVisualization(
+    const base = createBaseVisualization(
       this.inputProblem.simpleRouteJson,
       "RectDiffPipeline - Final"
     );
+    const clearance = buildObstacleClearanceGraphics({
+      srj: this.inputProblem.simpleRouteJson,
+      clearance: this.inputProblem.obstacleClearance
+    });
     const { meshNodes: outputNodes } = this.getOutput();
     const initialNodeIds = new Set(
       (this.rectDiffGridSolverPipeline?.getOutput().meshNodes ?? []).map(
         (n) => n.capacityMeshNodeId
       )
     );
-    for (const node of outputNodes) {
-      const isExpanded = !initialNodeIds.has(node.capacityMeshNodeId);
-      graphics.rects.push({
-        center: node.center,
-        width: node.width,
-        height: node.height,
-        stroke: isExpanded ? "rgba(0, 128, 0, 0.8)" : "rgba(0, 0, 0, 0.3)",
-        fill: isExpanded ? "rgba(0, 200, 0, 0.3)" : "rgba(100, 100, 100, 0.1)",
-        layer: `z${node.availableZ.join(",")}`,
-        label: [
-          `${isExpanded ? "[expanded] " : ""}node ${node.capacityMeshNodeId}`,
-          `z:${node.availableZ.join(",")}`
-        ].join("\n")
-      });
-    }
-    return graphics;
+    const nodeRects = {
+      title: "Final Nodes",
+      coordinateSystem: "cartesian",
+      rects: outputNodes.map((node) => {
+        const isExpanded = !initialNodeIds.has(node.capacityMeshNodeId);
+        return {
+          center: node.center,
+          width: node.width,
+          height: node.height,
+          stroke: isExpanded ? "rgba(0, 128, 0, 0.8)" : "rgba(0, 0, 0, 0.3)",
+          fill: isExpanded ? "rgba(0, 200, 0, 0.3)" : "rgba(100, 100, 100, 0.1)",
+          layer: `z${node.availableZ.join(",")}`,
+          label: [
+            `${isExpanded ? "[expanded] " : ""}node ${node.capacityMeshNodeId}`,
+            `z:${node.availableZ.join(",")}`
+          ].join("\n")
+        };
+      })
+    };
+    return mergeGraphics(mergeGraphics(base, clearance), nodeRects);
   }
 };
 export {