Atlas Occlusion Graph 🕸

Every scene built from one photograph has the same structure: things in front, things behind, and behind-things where the camera physically couldn't see. Before you can decide whether to patch a hole or rebuild a whole layer, you need to know which occludes which. Atlas Occlusion Graph is the node that decomposes your solved scene into exactly that structure - one node per fitted surface with a single permitted completion policy, and one edge per silhouette tear where the nearer side occludes the farther one. It's the 🕸 in Atlas/06 · Patch & Repair.

It's the brains behind the pack's "honest hole beats invented geometry" doctrine. The node builds nothing and changes no measurements - it reads the proxy primitives already on the solve plus the shared depth map, produces the graph, and attaches it to the solve's semantics slot so every downstream node and the exported solve JSON carry it. A tear that can't be classified licenses nothing - and that's deliberate. In a solve that claims to be measured, an honest hole beats confident-looking invented geometry.

How it works

The graph is a dependency for the repair pipeline, not a preview. Each fitted surface becomes a node with one completion_policy; each silhouette tear becomes an edge. The depth input is what lets the graph actually analyse tears - without it, the node still lists the scene's parts, but it can't tell a real occlusion from a modelling gap, and no tear-driven completion gets licensed.

From the graph, downstream nodes decide. AtlasLayerPlan turns it into the clean-plate manifest (which surfaces need painting out), and the patch nodes get told which holes are genuine occlusions worth filling versus open sky that should stay open.

Inputs and outputs

• solve (required) - must have fitted primitives on it. The docstring is direct: run AtlasDeriveProjectionGeometry first; without fitted primitives there's nothing to decompose, and the report says so rather than returning a confident-looking empty graph.
• depth (optional but really not) - the shared ATLAS_DEPTH_MAP. Without it the graph can't analyse tears.

Outputs: solve (graph attached) and report.

Installing it

Core-tier, dependency-free:

cd <ComfyUI>/custom_nodes
git clone https://github.com/mikejamesvfx/atlas-camera.git

Restart and it's in Atlas/06 · Patch & Repair (ComfyUI Manager: "atlas-camera"). The depth input needs a depth model upstream, but this node itself runs on pure Python.

Common issues

The two mistakes map to the two inputs. Skip AtlasDeriveProjectionGeometry and the node has nothing to decompose - the report tells you, so read it instead of assuming a bug. Skip the depth input and you get a graph that lists parts but can't tell a tear from a gap, which silently disables the tear-driven repair path downstream.

And if the graph feels conservative - plenty of "unclassified" holes - that's the design. It's licensing only what it can prove. Feed it better depth or better geometry and the classifications tighten; don't force it.