Atlas Clean Plate Layer 🖼

One depth band of your 2.5D matte painting

By mikejamesvfx·Created 2 months ago·Updated a day ago· 1

solve
depth
plate_image
plate_ref
exclude_mask
layer_matte
band_split
band_ref_mask
plate_depth
object_mask

solve
hole_mask
extend_mask
report

◄near_m0.0►

◄far_m0.0►

◄near_pct0.00►

◄far_pct0.50►

◄namelayer►

◄priority0►

◄relief_grid384►

◄depth_edge_rel1.50►

◄fill_occludedfalse►

◄embed_mattefalse►

◄edge_extend_px0►

◄skirt_bevel0.00►

◄frame_outpaint_px0►

◄exclude_choke_cells2►

◄band_sidemanual►

◄band_geometryrelief►

◄geometry_override►

◄band_override►

◄max_edge_factor12►

◄normal_edge_deg0►

◄quad_coherencetrue►

◄sub_quad_boundaryfalse►

◄silhouette_mattefalse►

◄soft_visibilityfalse►

◄transition_ribbonfalse►

◄ribbon_px64►

◄ribbon_bend-0.30►

◄ribbon_adaptivefalse►

◄ribbon_depth_slope2.00►

◄ribbon_smudge_px12►

The heart of the pack's matte-painting look is the layered 2.5D stack: you split the photo into depth bands, give each band its own cleaned-up plate, and project each onto its own relief mesh so a camera move reveals real parallax instead of smeared texture. Atlas Clean Plate Layer 🖼 is one band of that stack - build one per layer (sky, far, mid, foreground), each from its own inpainted plate, and the viewport composites them by depth.

The core contract

Three required inputs: solve, depth (the metric depth map), and plate_image - the clean plate for this band, i.e. the image after you've inpainted out the foreground occluder within this band's range. The critical rule is right in the tooltips: the near_m / far_m (or near_pct / far_pct) settings MUST match the AtlasDepthLayerMask band that produced your plate image. Both nodes call the same shared depth-band resolver, so identical settings always agree - the trap is changing one and not the other. Lower near_pct means tighter occlusion, not looser.

Also respect the priority doctrine: farther bands take HIGHER priority (far 15 / bg 10 / mid 5 / fg 0). At a watertight seam the surfaces are depth-adjacent, and this near-tie bias picks the winner so a band's edge smear renders in front of the layer behind it - that's what kills striped seams. A sky dome goes negative via AtlasSkyDomeLayer.

The knobs that actually matter

The input list is intimidating - this is the pack's most parameter-dense node - but most defaults are calibrated and you can leave them alone. The ones to know:

band_geometry - how the band's surface is built: relief (depth-following mesh, for anything with real shape), card (ONE flat fronto-parallel plane at the band's median depth - the classic DMP card for distant flat layers; never tears, zero depth noise), or ground (the exact Y=0 plane for floors, water, roads). Wire AtlasAssessImage's geom_* output into geometry_override to let the VLM pick per layer.
fill_occluded - diffusion-fills this band's mesh across the foreground occluder's footprint, so the inpainted plate content lands on real geometry instead of a hole. This is the disocclusion "shadow ray" mesh; leave on when you've inpainted a foreground object out.
embed_matte - embeds a full-res per-pixel edge matte so the projection shader cuts the true band silhouette instead of the mesh's blocky grid-resolution tear. Auto-computed from the band; wire layer_matte to override with a hand/SAM matte for crisper edges.
edge_extend_px - deterministic edge-extend: smear the plate's colors past the matte edge by N pixels (quarter-res neighbor propagation, not an inpaint). Plausible only for narrow slivers - big reveals still want a real inpainted plate.
frame_outpaint_px - extends this layer past the frame edges by padding the canvas and giving the source its own widened camera. Closes the frame-edge reveal that shows up as the binding constraint on wide scenes. The invented ring lands in extend_mask for downstream regrain.
band_split - with band_side set, the fg/bg boundary lives in exactly one AtlasBoundedBand widget and layers can never drift apart. Prefer this over hand-setting near/far.

Outputs and troubleshooting

Outputs: the updated solve, hole_mask (where this band has no geometry - the disocclusion holes for the inpaint), extend_mask (invented pixels), and a report. If band seams tear or meshes look combed, the advanced edge-tuning section (max_edge_factor, normal_edge_deg, sub_quad_boundary, silhouette_matte, soft_visibility) is where you go - each has a measured, documented effect in the source. The [neural] extra is required for the metric depth that band meshes are built from. Install is the pack's usual clone-and-go.

CategoryAtlas/07 · Clean Plate & Inpaint

Inputs (40)

Name	Type	Default	Description
solve	ATLAS_SOLVE		—
depth	ATLAS_DEPTH_MAP		—
plate_image	IMAGE		—
near_mopt	FLOAT	0.00–10000	MUST match the AtlasDepthLayerMask band that produced plate_image.
far_mopt	FLOAT	0.00–10000	MUST match the AtlasDepthLayerMask band that produced plate_image.
near_pctopt	FLOAT	0.000–1	Must resolve to the same band as the AtlasDepthLayerMask that produced plate_image (both call the shared _resolve_depth_band helper, so identical near_m/far_m/near_pct/far_pct here and there always agree). LOWER near_pct = tighter occlusion, not looser — see AtlasDepthLayerMask's near_pct tooltip for the worked example.
far_pctopt	FLOAT	0.500–1	Must resolve to the same band as the AtlasDepthLayerMask that produced plate_image. 0 means no upper bound (+inf).
nameopt	STRING	layer	—
priorityopt	FLOAT	00–100	Blend priority among layers (higher wins). FARTHEST bands take the HIGHER priority (far 15 / bg 10 / mid 5 / fg 0): at a watertight seam the surfaces are depth-adjacent and this near-tie bias picks the winner, so nearest-highest renders a band's edge smear IN FRONT of the layer behind it (striped seams). Min is 0; a sky dome goes negative via AtlasSkyDomeLayer. Ordering is by depth + priority, never facing angle (clean-plate sources paint head-on AND grazing, unlike multi-angle patches).
plate_refopt	ATLAS_PLATE_REF		Optional registered final clean-plate reference. Browser still uses image_b64 preview; exporters use this for EXR/float-safe handoff.
relief_gridopt	INT	38416–4096	Band-clipped meshes tear at band boundaries ON TOP OF normal silhouette tearing, so per-layer meshes want more density than the generic 128 default - 384/1.5 is the empirically-calibrated band-layer setting (hangar + monument valley).
depth_edge_relopt	FLOAT	1.500.05–5	Looser than the generic 0.5: safe WITHIN a band because the band clip already bounds the mesh's depth range.
exclude_maskopt	MASK		Optional external exclusion (e.g. a real sky segmentation from SAM/RMBG). When connected it REPLACES the internal sky heuristic (which otherwise eats tall geometry above the horizon) - should match whatever was passed to the AtlasDepthLayerMask call that produced plate_image, for hole_mask/band resolution to stay in lockstep.
fill_occludedopt	BOOLEAN	false	Diffusion-fill this band's mesh across the foreground occluder's footprint (the band clip otherwise leaves a hole exactly there) so the INPAINTED plate content lands on real geometry instead of a hole - the disocclusion 'shadow ray' mesh. Synthesized depth is a smooth interpolation of the surrounding background, reported in metadata as n_filled_cells. Excluded (sky) regions are never filled.
embed_matteopt	BOOLEAN	false	Embed a full-resolution per-pixel edge matte on this layer (ProjectionSource.mask_b64) - the projection shader then cuts the TRUE band silhouette per-pixel instead of the mesh's blocky grid-resolution tear edge, and the Nuke layers export writes it into the plate's alpha. Auto-computed from this band (in-band pixels, plus the filled occluder footprint when fill_occluded is on, minus exclude_mask); wire layer_matte to override with a hand/SAM matte.
layer_matteopt	MASK		Optional explicit edge matte (overrides the auto-computed band matte when embed_matte is on) - e.g. a SAM segmentation of this layer's subject for a crisper edge than depth banding gives.
edge_extend_pxopt	INT	00–512	Deterministic edge-extend for THIS layer, same trick as the sky dome's: smear the plate's colors past the matte edge by this many pixels (quarter-res neighbor propagation — NOT an inpaint), dilate the embedded matte to expose the extension on disocclusion, and grow the mesh's boundary skirt to receive it. The invented region is reported on the extend_mask output AND exported to Nuke/Maya as {layer}_extend_matte.png so it can be processed downstream (regrain, blur, replace). Smeared pixels are plausible only for narrow slivers — large reveals still want a real inpainted plate. Turns on embed_matte implicitly (an extension needs a matte edge).
skirt_bevelopt	FLOAT	0.000–4	Bevel the mesh's boundary skirt AWAY from the camera, as a slope in local cell units: 1.0 recedes one cell per extension ring (a 45° skirt), 0 = today's flat skirt. Physically motivated — an occluded surface continues away from the camera behind its silhouette, so a receding bevel is the least-wrong geometry at a tear edge. Try 1.0–2.0 with edge_extend_px: the smeared colors land on the receding skirt and the extend matte marks them for regrain.
frame_outpaint_pxopt	INT	00–1024	Outpaint THIS layer past the FRAME edges by this many pixels — the same per-source widened-camera trick the sky dome uses: the plate canvas is padded edge-replicated, this source gets its OWN camera with shifted cx/cy and grown W/H (the primary solve and every other layer are untouched), and the band mesh extends past the original frustum to carry it. Closes the frame-edge reveal that 🧭 Safe Zone measurements show is the binding constraint on wide scenes (ground layers used to end exactly at the photo boundary). The ring is INVENTED pixels: it lands in extend_mask / {layer}_extend_matte.png for downstream regrain, and turns on embed_matte implicitly. 0 = off.
exclude_choke_cellsopt	INT	20–16	Choke-and-reskirt against the exclude_mask edge: segmentation and depth edges never align exactly, leaving a ribbon of cells the mask calls rock but whose depth IS sky — they back-project high above the real silhouette as a jagged floating band. This erodes the layer N grid cells away from the exclusion, then the boundary skirt regrows the ring with clean neighbor depth: same coverage, geometry hugging the true surface. Raise for sloppier segmentation masks; 0 disables.
band_sideopt	COMBO	manual	With band_split connected: foreground = [0, split), background = [split, +inf) — the node's own near/far widgets are ignored. manual = use this node's own near/far settings.
band_splitopt	ATLAS_BAND_SPLIT		Wire ONE AtlasDepthBandSplit into every band node (with band_side set) so the fg/bg boundary lives in exactly one widget and the layers can never drift apart.
band_geometryopt	COMBO	relief	How this band's projection surface is built. relief (default) = the depth-following mesh, for anything with real 3D shape inside the band. card = ONE flat fronto-parallel plane at the band's median depth (classic DMP card) — for distant/flat-facing layers with negligible internal parallax (far mountains at the horizon, a hangar's back wall, a skyline backdrop); never tears, zero depth noise. ground = the exact analytic Y=0 ground plane — for flat horizontal surfaces the camera stands over (desert floor, water, road); zero depth-noise bumps. Both flat modes keep band membership from the REAL depth (which pixels belong) and only flatten WHERE they sit; matte/edge-extend/outpaint all still apply.
geometry_overrideopt	STRING		Optional geometry-type override STRING — wins over band_geometry when non-empty ('relief'/'card'/'ground'). Exists because ComfyUI rejects STRING→combo links: wire AtlasAssessImage's geom_far/bg/mid/fg output here so the VLM's per-layer geometry recommendation flows in (same pattern as patch_view_override). Unknown values error loudly.
band_ref_maskopt	MASK		Exclusion used ONLY for resolving near/far percentages to metres. When exclude_mask carries per-layer scoping (🎯 scope rows), each layer's depth population differs and the shared band edges DRIFT apart (metric gaps between adjacent bands — debug-report finding). Wire the plain SKY mask here on every band node so all layers resolve identical edges. Unwired = legacy behavior (band edges from exclude_mask's population).
band_overrideopt	STRING		Optional band override STRING ('near_pct=<f> far_pct=<f>') — wins over this node's near/far widgets when non-empty. Wire AtlasAssessImage's band_far/bg/mid/fg output here so the VLM's subject-aware band boundaries flow in (jointly derived, so adjacent bands always share edges exactly). MUST be the same string the paired AtlasDepthLayerMask received. Loses to a connected band_split. Errors loudly on garbage.
max_edge_factoropt	FLOAT	122–200	World-space edge tear threshold (SEPARATE from depth_edge_rel). Dominant tear cause on deep / narrow-FOV / interior bands: raise to 40-80 to stop comb-tearing continuous grazing surfaces. >80 rubber-sheets real silhouettes.
normal_edge_degopt	FLOAT	00–180	0 = off. Tears where surface NORMALS bend past this angle — real creases / occlusion silhouettes — while leaving smoothly-receding walls intact. Pair with a higher max_edge_factor: raise mef to kill spurious combs, then ~40-70 here to keep genuine edges torn.
quad_coherenceopt	BOOLEAN	true	Reject both triangles when either half of a grid quad fails; avoids surviving diagonal UV wedges at band boundaries.
sub_quad_boundaryopt	BOOLEAN	false	Cut a torn cell AT the depth cliff instead of deleting the whole cell. A band silhouette can otherwise only turn in whole-cell steps AND loses a cell of real surface on both sides of every cliff - measured 5.67px mean boundary error at grid 128 on a 1024px plate (step 8px), WORSE than the 4px quantization bound. Reads the cliff from the full-resolution depth and rebuilds both sides up to it, never joining them: 5.67 -> 1.43px, camera coverage 97.8 -> 100%, ~5% more vertices. Same thresholds, same cells torn.
silhouette_matteopt	BOOLEAN	false	Cut this band's exclusion silhouette per-pixel rather than at grid resolution: grows a boundary skirt and ships a full-resolution matte the projection shader trims it back with (strip uncovered 0.083 -> 0.000, zero pixels spilled past the boundary, edge within 0.25px of truth vs 4px lattice). Skirt and matte are ONE switch - an unmatted skirt shows replicated pixels. Handles the sky/exclusion edge; depth cliffs need sub_quad_boundary.
soft_visibilityopt	BOOLEAN	false	SOFT LAYERING (SLIDE, ICCV 2021) - the viewport answer to sawtooth silhouettes. Instead of TEARING at a depth cliff and leaving a hole to feather, keep the surface continuous (it rubber-bands across the cliff) and fade those fragments with a per-pixel visibility A = exp(-beta*\|grad disparity\|^2) computed at PLATE resolution. No tear means no boundary to quantize, so there is no staircase at ANY grid - and the lattice stays intact, so planar hole patch and the CUDA repair keep working (unlike sub_quad_boundary, which this supersedes and disables). Measured on a diagonal cliff: fade to 0.039 over a 4px feather while smooth receding ground stays at 0.987. Needs something BEHIND to reveal (BG clean-plate / sky dome / clean_plate input) or the fade shows the backdrop. Export still tears - a DCC has no shader to fade with.
transition_ribbonopt	BOOLEAN	false	KEEP this band's tear and hang a bounded skirt off it, instead of soft_visibility's untorn rubber band whose fins run as far as the depth jump dictates. Separate topology grown from the open rim, stepping outward in IMAGE space so its apparent width is a fixed pixel count at any depth (a view-ray extrusion cannot do this - every point on a ray projects to the same pixel). UVs freeze at the silhouette texel, so it is an edge-extend CLAMP, which is what the seam doctrine asks of a layer that has bands behind it. Shares no vertex with the band surface. Mutually exclusive with soft_visibility.
ribbon_pxopt	FLOAT	640–400	Transition-ribbon width in SCREEN pixels of the plate, measured in the recovered camera; achieved width is reported back as stats.transition_ribbon.measured_px_p50/p95. Distinct from edge_extend_px, which smears TEXTURE outward on this band; this adds GEOMETRY carrying the frozen rim texel.
ribbon_bendopt	FLOAT	-0.30-0.5–0.5	Shape of the depth falloff toward the band behind. NEGATIVE curls away fast then levels off (the tight lip); 0 is linear; POSITIVE dwells at this band's depth then dives (a flange). Limited to +/-0.5, the range in which the ramp stays monotonic.
ribbon_adaptiveopt	BOOLEAN	false	Scale ribbon_px by the size of the discontinuity relative to depth_edge_rel, clamped 0.5x-2x. DEFAULTS OFF: measured on a real exterior it was the only setting that broke width consistency (p95 85px for a requested 64) and clamped the most folds.
ribbon_depth_slopeopt	FLOAT	2.000.25–8	How far the skirt may recede toward the band behind, as a multiple of its own world width. Governs what an ORBIT sees; ribbon_px alone bounds only the recovered camera. Low (0.5-1) hugs this band's silhouette, high (4-8) reaches further back at the cost of long slabs off-axis.
ribbon_smudge_pxopt	FLOAT	120–200	Blur the skirt along this band's silhouette, in plate texels, ramped in from the rim. At 0 each column is one frozen texel and the skirt reads as flat radial streaks. Applies in the viewport and is baked into the exported GLB as vertex colour.
plate_depthopt	ATLAS_DEPTH_MAP		AtlasDepthMap run on plate_image (MoGe, same solve wired). When connected, THIS layer's mesh is built from the clean plate's depth instead of `depth`: the terrain behind the foreground object comes from the plate that actually sees it. Its scale is registered to `depth` by median ratio over the mutually visible pixels (outside object_mask); the report carries scale + rel_mad. Same camera, so no second solve and nothing to line up.
object_maskopt	MASK		The foreground object (white) in the SOURCE frame — excluded from the scale registration (its depth differs between the plates by definition). Recommended when the object is large.

Outputs (4)

Name	Type	Description
solve	ATLAS_SOLVE	—
hole_mask	MASK	—
extend_mask	MASK	—
report	STRING	—