Skip to main content

Module 1 • Lesson 1📐 Scene-Referred, Display-Referred & Gamma

Master-level color starts with a fact most editors never learn: the numbers in your file are not the light in the scene. Understanding the gamma curve — and when to compute in linear light instead — is what makes your blurs, blends, and composites physically correct rather than merely plausible.

📚 What You'll Learn

By the end of this lesson, you will be able to:

  • Explain scene-referred vs display-referred color
  • Read a gamma / transfer curve and why a 50% pixel isn't half the light
  • Say why encoding is perceptual — where the bits are spent and why
  • Identify edits that are wrong in gamma space and right in linear light
  • Switch Photoshop to blend/resize in linear light when it matters

⏱️ Estimated Time: 55 minutes

🎯 Project: A side-by-side proof of one operation (a blur or a defocus composite) done in gamma vs linear light, with a written note on which is correct and why.

In This Lesson

👤 The Goal: The Numbers Aren't the Light

The same tonal ramp, two ways. On the right, the raw linear light values shown directly — the way a sensor records photons, with the shadows crushed together. On the left, the same data gamma-encoded for your eye, so the steps look evenly spaced. Both hold the same information; only one matches human vision. Drag the handle:

Gamma-encoded Linear
A diagram of the principle. Gamma encoding is not a "look" — it is how the same light data is packed so that even steps look even to us, spending more code values in the shadows where our eyes are most sensitive.

🧠 Mental Model: The Transfer Curve

Between the light in a scene and the number in your file sits a transfer function (loosely, "gamma"). sRGB uses roughly a 2.2 power curve. The consequence surprises people: a pixel sitting at 50% on the 0–255 scale is emitting only about 21% of the light of white (0.52.2 ≈ 0.21). Middle-gray light (18%) actually lands near pixel value 118, not 128.

Why encode at all? Human vision is roughly logarithmic — we discriminate far more finely in shadows than in highlights. A gamma curve spends more of the limited code values down in the darks, so an 8-bit file avoids visible banding where we'd notice it most. Encoding is a perceptual compression, not decoration.

scene light (linear) → encoded value → linear (no encoding) gamma (sRGB ≈ 2.2) 21% light… …is 50% value
Figure 1: The gamma curve. A little scene light climbs the encoded value fast (the curve's steep start), which is exactly what packs detail into the shadows. The red marker shows the key fact: 21% of white's light is stored as a 50% value. The straight dashed line is what "no encoding" would look like.

🔁 Scene- vs Display-Referred

Two philosophies of what your pixels mean. Display-referred (the everyday JPEG/8-bit world) says a pixel is an instruction to the monitor: 255 = "as bright as this screen goes". Values are bounded 0–1 and already tuned for a display. Scene-referred says a pixel is a measurement of light in the scene, in linear units, unbounded — a bright sky might be 12.0, the sun 10,000. You grade in that space and only map to a display at the very end.

Two pipelines
Scene-referred linear scene grade (linear) display transform to screen unbounded light kept until the end · the master way to grade & composite Display-referred display look baked in edit (clipped) to screen bounded 0–1, highlights already clipped · fine for finished JPEGs
Figure 2: Scene-referred keeps real, unbounded light until a final display transform — which is why film and HDR pipelines grade there. Display-referred is where most 8-bit editing lives, with the highlights already clipped.

⚠️ Clipped highlights never come back

Once a display-referred file has driven the highlights to 255, the information above "white" is gone. Scene-referred grading (and 32-bit, Lesson 1.3) keeps those values alive, which is why you can pull a blown sky back only when you preserved the scene light in the first place.

🧮 When Linear Light Is Correct

Any operation that simulates physical light mixing is only correct in linear space, because in the real world light adds linearly — gamma-encoded numbers do not. In gamma space these operations produce subtly wrong, usually too-dark results:

  • Blur & defocus — a bokeh highlight blurred in gamma space dims and turns gray; in linear it stays bright and glowing, like a real lens.
  • Downscaling / resizing — averaging pixels in gamma darkens fine detail (thin bright lines vanish); linear averaging preserves brightness.
  • Blending & opacity — a 50% blend of black and white should be middle-gray light, not middle-gray value.
  • Adding light — glows, lens flares, and additive composites sum correctly only in linear.

Photoshop gives you two linear switches, and they do different jobs:

  • 32 Bits/Channel (Image ▸ Mode ▸ 32 Bits/Channel). Photoshop stores 32-bit documents in linear light, so filters like Gaussian Blur and resampling in Image Size run on linear values. This is the switch for blur, defocus, and resize. Convert a copy, do the operation, then convert back.
  • Blend RGB Colors Using Gamma: 1.00 (Edit ▸ Color Settings, in the Advanced Controls section). This changes only how layers composite: opacity and blend modes between layers. It does not change filters or resampling.

For scene-referred grading proper, you also work in 32-bit (Lesson 1.3).

✅ You don't do everything in linear

Contrast curves, most color grading, and painting feel right in the perceptual (gamma) space — that's what our eyes expect to push against. Reach for linear specifically for light-simulation math: blur, resize, additive glows, and physically-based composites.

🛠️ Guided Build: Gamma vs Linear

You'll prove the difference on one operation so the theory becomes muscle memory.

Step 1: Make a torture test · 6 min

  1. File ▸ New: RGB Color, 16 bit, sRGB, about 2000 × 1200 px, black background.
  2. On a new layer, add small pure-white dots (a hard brush, 10–20 px) and thin 1–2 px white lines. Bright highlights on dark are the worst case for gamma math.
  3. Layer ▸ Flatten Image, then save as torture_test.psd. This is your untouched source.

Step 2: Blur in gamma · 6 min

  1. Image ▸ Duplicate and name the copy gamma. Apply Filter ▸ Blur ▸ Gaussian Blur at a strong radius (try 25 px) and write the radius down.
  2. Note how the white dots spread into dim gray smudges and the halo fades quickly.

Step 3: Blur in linear · 8 min

  1. Return to torture_test.psd, Image ▸ Duplicate again and name it linear.
  2. Image ▸ Mode ▸ 32 Bits/Channel. The document is now linear light.
  3. Apply Gaussian Blur with the same radius, then Image ▸ Mode ▸ 16 Bits/Channel. In the HDR Toning dialog choose Method Exposure and Gamma with Exposure 0 and Gamma 1.00 so nothing is re-toned.
  4. Put the two copies side by side (Window ▸ Arrange ▸ 2-up Vertical). The linear highlights stay bright and glow, like real bokeh.

Step 4: Prove resizing too · 8 min

  1. Make two more copies of torture_test.psd. Resize the first to 25% with Image ▸ Image Size (Resample on).
  2. Convert the second to 32 Bits/Channel, resize it to 25% the same way, then convert back to 16 Bits/Channel as in Step 3.
  3. Compare at 100%: the gamma version's thin lines darken and drop out; the linear version holds their brightness. 🏆

✅ Project Completion Checklist

  • ☐ A highlights-on-black torture test built and saved
  • ☐ Blur compared gamma vs 32-bit linear (bokeh stays bright in linear)
  • ☐ Downscale compared gamma vs 32-bit linear (lines survive in linear)
  • ☐ A written note on which is correct and why
  • ☐ Know which switch does what: 32-bit for filters and resize, Blend RGB Colors Using Gamma for layer blending

🧗 Now You: Solo Variation

🌟 Your challenge

  1. Composite a defocused string of fairy lights over a night scene in gamma vs linear. The linear version's bokeh will look like a real lens; the gamma one muddy.
  2. Build a soft glow/bloom on a bright sign both ways and feel which reads as emitted light.
  3. Fill a small document with RGB 128/128/128, then convert it to 32 Bits/Channel and read the Info panel (if it still shows 0–255, switch the RGB readout to 32-bit from the Info panel's eyedropper menu). The float value is about 0.21, not 0.5: a 128 gray is roughly a fifth of white's light. Seeing the number cements the idea.

Going further: read up on OETF/EOTF (the camera's and display's transfer functions) and how HDR standards like PQ differ from sRGB gamma. It's the same idea, extended to far brighter light.

🍳 Recipe Card: Linear Light

Compute light where light lives

  1. Remember: pixel value ≠ light (sRGB ≈ 2.2 gamma; 50% value ≈ 21% light)
  2. Encoding is perceptual — bits spent in the shadows on purpose
  3. Do blur, resize, glows, additive composites in linear light
  4. Do contrast, grading, painting in perceptual (gamma) space
  5. Switches: 32 Bits/Channel for linear blur and resize; Blend RGB Colors Using Gamma 1.00 for linear layer blending only

Mantra: the file is an encoding of the light, not the light itself.

📓 Learning Journal

Add to your journal after this lesson:

  • Key concepts you learned
  • Techniques that clicked for you
  • Questions or confusion points to revisit
  • Ideas you want to try
  • Your progress and feelings about learning this

✍️ This lesson's prompt: Where in your past work might a "too dark when blurred/resized" result actually have been a gamma-space error? Now you have the vocabulary to name it.

📝 Lesson Summary

🎓 Key Takeaways

  • Pixel values are a gamma-encoded record of light: a 50% value is only about 21% of white's light.
  • Encoding is perceptual. It spends code values in the shadows, where our eyes are most sensitive.
  • Scene-referred data keeps unbounded light until a final display transform; display-referred data is clipped early.
  • Light-simulating operations (blur, resize, glows, additive composites) are correct in linear. Use 32 Bits/Channel for filters and resize, and Blend RGB Colors Using Gamma only for layer blending.

🎉 What You've Accomplished

You proved, on your own test file, that the same blur and the same resize give different answers in gamma and in linear light, and you can say which one is physically right. That vocabulary lets you diagnose a whole class of "why does this look muddy?" problems.

❓ Common Questions at This Stage

Is "gamma" the same as "contrast"?

No, though people conflate them. Gamma here is the encoding transfer function that maps light to code values. A contrast curve is an artistic adjustment on top. You can change contrast without changing the underlying encoding, and vice versa.

Do I need to think about this on every edit?

No. Most perceptual edits are fine as they are. This matters when an operation simulates light (blur, resize, glows, additive composites) or when you grade in HDR/32-bit. Knowing when is the mastery; the rest of the time, edit normally.

Why didn't the Color Settings gamma checkbox change my blur?

Because Blend RGB Colors Using Gamma only affects how layers composite with each other (opacity and blend modes). Filters and resampling ignore it. For a linear blur or resize, convert a copy to 32 Bits/Channel.

🔭 Looking Ahead

You now know what the numbers mean. Next you master the tool that turns real captured light into those numbers on your terms: Lesson 1.2: Camera Raw / ACR at Depth, the develop stage where a flat capture becomes a graded master.

✅ Before the Next Lesson

  • Finish the gamma vs linear comparison for both blur and resize.
  • Write your note on which result is correct and why.
  • Have a raw file (or a flat JPEG) ready for Lesson 1.2.
  • Write your Learning Journal entry.

📚 Additional Resources

🌟 Encouragement for the Journey

This is the most abstract lesson in the course, and you just turned it into something you can see on screen. Every later lesson that says "do this in linear" now has a reason behind it. Keep your torture test; it is a quick way to check any new tool you meet.