Everything in u

"Don't measure the face in pixels. Measure it in the face."

Pixels Lie, Centimeters Lie

Suppose you want the Loomis ball's radius. Measure it in pixels and your number is glued to the image size — 140 pixels on a 1024-wide photo is wrong the instant the next reference is 512 or 4000 wide. Measure it in centimeters instead and you've traded one problem for another: the same face fills more or fewer centimeters depending only on how close the camera stood. Neither pixels nor centimeters is stable across a deck of a thousand references shot at a thousand distances.

Measure the Face in Its Own Terms

The fix is to stop measuring the face against the outside world and start measuring it against itself. Loomis defines one intrinsic unit — u, the brow-to-nose distance — and expresses every other quantity as a ratio of it. The ball radius isn't 140 pixels; it's some multiple of u. The jaw length, the eye spacing, the depth of the side plane — all in u. Because u is a feature of the face and scales with the face, every ratio built on it is scale-free: crop the photo, resize it, shoot it from twice as far, and the ratios don't move.

Calibrate Once, Fit Forever

This is what makes one human calibration hold across every photo. The multipliers — how big the ball is in u, where the thirds fall — live in a small profile the engine calls LoomisConfig. A human sets it once, tuning it to a particular sense of proportion, and from then on the engine measures u fresh on each new photo and scales the whole construction to match. Calibration is human and one-time; fitting is automatic and every-time. The profile is deliberately exposed and documented, never buried in the code — it is the one honest knob, and honest knobs stay visible.

The General Move: Intrinsic Units

This trick is far bigger than faces. Physicists pick natural units so equations lose their arbitrary constants; figure artists measure the body in "heads tall" so a giant and a child share one proportion language; machine-learning pipelines normalize features so scale stops dominating the math. Every one of them is the same move: choose a unit intrinsic to the system, and scale cancels out of everything downstream. Loomis's u is that idea aimed at a human face.

Code

Pixels break; u holds·python

# BROKEN: hard-code the ball radius in pixels.
# Fine on one photo, wrong on the next.
ball_radius_px = 140          # ok at 1024px wide ... wrong at 512px or 4000px

# ROBUST: express the radius as a ratio of u = brow-to-nose distance.
u = distance(landmarks[BROW], landmarks[NOSE_BASE])   # measured on THIS photo
ball_radius = 1.9 * u          # 1.9 is a property of the FACE, not the image

# The multiplier 1.9 lives in LoomisConfig -- a human calibrates it ONCE.
# u is re-measured automatically on EVERY photo. Scale cancels; the profile holds.

Exercise

Take a photo of a face and measure two things in pixels: the brow-to-nose distance (call it u) and the width of one eye. Now compute eye-width ÷ u. Resize the photo to half size and measure all three again. The pixel numbers halve — but does the eye-width ÷ u ratio change? Explain what just stayed constant and why that's the property Loomis is built on.

Hint

The raw pixel measurements all scale with the image; the ratio of two of them does not, because the scale factor appears in both the numerator and the denominator and cancels. That cancellation is scale-invariance — the exact reason expressing the whole construction in u lets one calibration survive a thousand differently-sized references.