Depth Rasterize Layers

Depth maps are usually the boring middle step of a workflow - you generate one with Depth Anything so a ControlNet can steer your next generation, or so you can fake a little parallax. Depth Rasterize Layers is the rare node that makes the depth map the whole show. Feed it an image plus a depth map and it slices the scene into flat paper layers, fills each slice with stylized color, and stacks them back up with soft drop shadows - a paper-cut diorama straight out of ComfyUI, with no LoRA, no ControlNet, no external styling tool, and nothing that leaves your GPU.

The name is a lie in the best way: "rasterizer" sounds like you're about to install a render engine, but this is a pure torch/numpy image-processing pass. requirements.txt is two lines - torch and numpy. No model files to download, no API key, no weights over a gigabyte. Your only real dependency is upstream: a good depth map, which the README says comes from a node like Depth Anything or Depth Anything V2 (both ship in Fannovel16's comfyui_controlnet_aux). V2 Large is the community default for a reason - cleaner edges and better behavior on glass and reflections than v1.

How it works

The node normalizes the depth map, lets you gamma-curve and blur it, then quantizes it into rasterization_levels (default 12) bands. Each band becomes a mask, and each mask gets filled with one of the layer_color_mode styles: original keeps the real pixels inside the slice, flat_average paints each layer one solid color, color_zones splits each layer into flat average-color patches for that cel-shaded papercraft look, and grayscale / black_white go monochrome. Then it composites far-to-near, dropping a blurred offset shadow behind each layer (depth_scaled_shadow is on by default, so deeper layers cast further) and optionally drawing outlines or shifting whole layers for a parallax cutout effect.

The inputs that matter

• image and depth_map - the only required ones. The depth map just needs to be aligned with the image and roughly the same scene.
• rasterization_levels - the big creative dial. 12 is a good middle; more slices reads as photographic, fewer reads as a flat graphic stencil.
• output_mode - composite gives you the finished diorama; all_layers exports every cut layer so you can reassemble in Photoshop or send pieces to a plotter.
• invert_depth - flip this when near and far come out backwards.
• For video, set normalization_mode to whole_sequence and add a little temporal_smoothing so the depth bands stop flickering frame to frame.

You'll get five outputs but only really care about two: composited_image (the finished stack - wire it to a SaveImage) and layer_masks (the per-layer alphas for export or further compositing). depth_quantized shows the posterized bands, debug_preview is a false-color layer-ID view for diagnosing weird cuts.

Installing it

Boring in a good way. ComfyUI Manager, search "Depth Layer Rasterizer", or:

cd ComfyUI/custom_nodes
git clone https://github.com/maDcaDDie2000/comfyui_depth_layer_rasterizer.git
cd comfyui_depth_layer_rasterizer
pip install -r requirements.txt

Then restart ComfyUI. Since the only dependencies are torch and numpy you almost certainly already have, that pip line is often a no-op.

Where people get burned

The depth map is the actual input - the node doesn't invent depth. Run it without one and it works but every layer looks identical, which reads as "broken." Noisy depth gives jagged cut edges, so bump depth_blur and layer_smoothing before blaming the node. And remember the batch is frames × layers, so for long video keep rasterization_levels conservative or you'll feel it in VRAM. It's a young pack (v0.1.0, MIT) and a small niche - if the composite looks busy, fewer levels plus mask_feather at 0 is the fast route to a clean minimal look.