Atlas Face Scale Reference 🙂

AtlasFaceScaleReference measures camera height from a person's face - the scale anchor you reach for when nothing else is usable. In the atlas-camera scale cascade, an object standing on the ground is the strongest anchor, because it pins scale with no assumptions at all. But a half-body portrait, a seated subject, or a figure behind a car gives you no ground contact. A face is visible in all of those, and a face has a known size - so the node turns a face's bounding box into a metric camera height.

The honest framing, from the node's own docs: this is a tier-1.5 anchor. Better than assuming a default, weaker than a ground reference, because two assumptions compound - the anthropometric constant has population spread, and you're assuming the subject's stature on top of it. It won't give you millimetre accuracy, but it turns "unknown scale" into "probably within a few percent," which is the difference between a projection that holds together on a dolly move and one that slides.

How it works

You mark the face one of two ways: wire a face_mask (a segmenter's mask of the face/head - the intended source is a SAM-based mask with a concept like "human face"), or type a bbox_override of x0,y0,x1,y1 in pixels by hand (which wins if both are set). The node measures the box's span against a known real-world dimension and, from the solved camera, derives the subject distance and camera height.

The metric choice matters more than people expect. A face mask (chin to hairline, 0.185 m) and a head mask (chin to crown, 0.235 m) differ by ~21% - pick the wrong one and you scale the measured subject distance by that much. Camera height moves less, in proportion to how far the anchor sits from lens level, but the error is real.

Crucially, nothing is rescaled unless confirm is on. An automatically detected reference is never auto-promoted - you measure and read the report first. And the node is privacy-conscious by construction: it measures a distance between two image points and nothing else - no face embedding, descriptor, or landmark set is computed or written to the exported solve.

The inputs

solve and metric (default head_chin_to_crown) are required. Then:

• face_mask - a face/head mask whose bounding box is measured.
• bbox_override - mark by hand as x0,y0,x1,y1. Wins over face_mask.
• stature_m (default 1.7) - the assumed standing height of this subject. The docs call it the dominant error term, because it enters the result directly.
• size_override_m - 0 uses the population constant for the chosen metric; set it to use the subject's measured size instead.
• confirm (default off) - on to actually rescale the solve.

Outputs: the (possibly rescaled) solve, camera_height_m as a float, a measurement string, and the report with its uncertainty band.

Install and gotchas

Part of the pack - ComfyUI Manager → search atlas-camera, or git clone https://github.com/mikejamesvfx/atlas-camera.git into custom_nodes, restart. The measurement math is pure numpy; the optional face_mask path needs whatever segmenter you have available. No GPU required.

Gotchas: an empty face_mask raises with a helpful message - SAM3 misses are silent, so check the segmenter's report and try a different concept word. And don't reach for interpupillary distance expecting a precision win: at ~5.6% coefficient of variation it's no better than stature's 4–6%, its only real virtue is being measurable when nothing else is. Use this node when the feet aren't visible; use a ground-based reference when they are.