Atlas Load RAW (NEF/CR2/CR3/RAF/ARW) 📷

The atlas-camera pack's story is "one photograph in, a metric pinhole camera out." But the solve is only as good as the plate, and a JPEG off your camera body has already been cooked - white-balanced, tone-mapped, sharpened, the lens distortion baked into the image. Atlas Load RAW is the upgrade that makes the solve stop guessing: it reads your camera's actual RAW file and hands the pipeline the physical lens and sensor it was shot on.

It's the 📷 node in Atlas/01 · Input & Camera, and it replaces the entire Adobe Camera Raw round-trip in one node. Feed it a .nef (Nikon), .cr2/.cr3 (Canon), .raf (Fuji), .arw (Sony) or .dng, and it does four things at once.

How it works

Under the hood it's a single rawpy demosaic (rawpy bundles libraw, so X-Trans Fuji and CR3 are covered). From that one demosaic it produces:

1. A display tensor for the graph and solve - an IMAGE you can look at and feed to any solver.
2. A scene-linear EXR sidecar - geometrically identical to the tensor by construction, because they share the one demosaic and undistort grid. This is what a DCC gets, so nothing downstream inherits an 8-bit preview.
3. Measured intrinsics - EXIF focal length plus a camera-model→sensor-width registry, exposed as raw_meta, focal_length_mm and sensor_width_mm. Wire raw_meta into a solve node's input and the solve starts from your real lens instead of a learned prior's estimate.
4. Optional lens distortion correction - a lensfun undistort straightens the plate for solving, and the Nuke export writes a redistort_stmap.exr beside the script so comp can put the distortion back over the render. Solve on straight lines, deliver on the real lens.

The colours are handled by Atlas's own path backed by OpenImageIO's built-in ACES config - no $OCIO to configure.

Inputs and outputs

• file_path (required) - the RAW file; relative paths resolve from ComfyUI's input folder.
• undistort (default on) - lensfun geometry correction; skipped with a report line when no profile matches.
• half_size - half-resolution demosaic for fast iteration on 36–100 MP files.
• white_balance - camera or auto.
• exposure_ev - ±6 EV, for the display tensor.
• write_exr (default on) - write the linear sidecar (needs [oiio]); degrades to proxy plate_ref on failure.
• output_dir, colorspace, headroom - the headroom default of 6 matches rawtoaces: sensor clip lands ~6x above 1.0 so diffuse white sits near 1.0, which is what ACES scene-linear expects.
• project - optional AtlasProject delivery project to route the EXR into.

Outputs: image, plate_ref, raw_meta, focal_length_mm, sensor_width_mm, report.

Installing it

The [raw] extra does the heavy lifting:

cd <ComfyUI>/custom_nodes
git clone https://github.com/mikejamesvfx/atlas-camera.git
<ComfyUI>/venv/Scripts/python.exe -m pip install ".[raw,oiio]"

[raw] brings rawpy, exifread and Pillow; [oiio] (OpenImageIO) is what writes the EXR sidecar. For the lensfun undistort, add the separate [raw-lens] extra - it's deliberately separate because lensfunpy wheels can lag new Python/Windows releases, and RAW decode must keep working without it.

Common issues

• CR3 metadata is best-effort - pure-Python readers, no ExifTool dependency. When EXIF can't be read, the report says so and you can type focal/sensor into the solve node manually.
• Fuji RAF + lensfun - decode works fine, but lensfun's X-mount coverage is thin because Fuji corrects in-body. The undistort step will usually report no_profile_lens and pass pixels through unchanged. That's expected, not a fault.
• Sidecar colorspace - the EXR is scene-linear with sRGB/Rec.709 primaries (Linear Rec.709 (sRGB)), not ACEScg. Convert downstream via OCIO. The pack tags it correctly; don't fight it.
• If the EXR write fails, the node doesn't crash - plate_ref degrades to proxy and the report names the cause. Check the report before assuming the render is float-clean.