<blockquote>
  <p>1, 1, 1, the output value is white. If this represents radiance than the output should be green, because when the signal radiance is the same, the pixel should be perceived as green. Am I correct?</p>
</blockquote>

<p>This is not correct. Your frame buffer most likely contains sRGB values. Of which 1,1,1 is used to represent white. Standard displays do not use spectral radiance values in the frame buffer. sRGB does not map directly or make any guarantees about the spectral power distribution (SPD) of the display. So "G" of 1 does not guarantee some wave with amplitude using W⋅sr−1⋅m−2 centered on the 550nm. Part of the problem is that different type of displays have different SPDs that map to the same perceived color. </p>

<p>[Evaluation of an organic light-emitting diode display for precise visual stimulation, Ito et. al]
(<a href="https://jov.arvojournals.org/article.aspx?articleid=2121657" rel="nofollow noreferrer">https://jov.arvojournals.org/article.aspx?articleid=2121657</a>)
<a href="https://i.sstatic.net/GD4E2.jpg" rel="nofollow noreferrer"><img src="https://i.sstatic.net/GD4E2.jpg" alt="SPDs for different display types"></a></p>

<p>Now if you want to physically accurate rendering, you could store all of your lighting values as Radiance with SPDs. As L.C. mentioned, Physically Based Rendering describes that this is done with piece-wise linear functions with like 16+ channels per color. However even if you can get this to be performant, good luck converting all your RGB data into SPDs (there's an infinite # of SPDs for a given RGB value).</p>

<p>Instead what most renderers try to do is to treat the RGB as pseudo-radiance values for the purposes of lighting calculation. This isn't accurate, hence your lighting result changes if you are using Rec.709 or Rec.2020 primaries for instance (if you notice they have different values for mapping to luminance), but it's good enough for real time and even offline in most cases. At this point you can convert RGB Rec709 and Rec2020 values to a single scalar luminance using the Y values of it's primaries.</p>

<p>The Y values of the RGB primaries for Rec709 are:</p>

<pre><code>    R       G       B
Y   0.2126  0.7152  0.0722
</code></pre>

<p><a href="https://en.wikipedia.org/wiki/SRGB" rel="nofollow noreferrer">https://en.wikipedia.org/wiki/SRGB</a></p>

<p>Thus Rec709 Linear has the following nits conversion:</p>

<pre><code>nits = dot(linear709Rgb, float3(0.2126, 0.7152,0.0722));
</code></pre>

<p>Probably one of the results of doing our calculations in RGB is that G and B add at equal weights, so it's likely to get some color shifting. There was a presentation at SIGGRAPH 2015 from Weta digital that had some examples, but it doesn't seem like the slides are available. As far as I know they are the only ones using a spectral renderer.</p>

CC BY-SA 4.0
2018-12-02T03:33:50.673Z
2018-12-04T07:44:53.527Z
2018-12-04T07:44:53.527Z
Calvin
<p><strong>About screens:</strong></p>

<p>Short answer: yes, it SHOULD, it would be nice. But the technology currently used does not make that possible.</p>

<p>The long answer: it's complicated. First, the signal that your computer sends to the screen is an electric signal. To make it easy to understand, take a look at this <a href="https://electronics.stackexchange.com/questions/93078/soldering-a-vga-cable-number-of-wires-doesnt-match">post about the old VGA connector</a>.</p>

<p>The signal still contains R G and B channels, that's what lights your pixels in a given color. So to try to answer your question: the conversion from RGB electric signal to light (meaning radiance) depends on the screen, not on your PC. Different screens and brands behave differently, that's why they don't all look the same. The technology used for the pixels also matters: LED, LCD, cathodic, OLED, plasma... all behave in different ways.</p>

<p>The signal coming from your computer tells the screen the color and the intensity of each pixel. The intensity is transmitted using a <a href="https://www.researchgate.net/figure/Two-measures-of-electrical-power-signals-for-LED-control-with-D-Type-flip-flop-register_fig6_224222964" rel="nofollow noreferrer">pulse</a> (the leds blink fast enough so the human eye can't see it and the % of time it's on determines how bright it looks... to human eye). </p>

<p>Even if that was not the case, and the pixels were analogic, you would still send an electric signal: some ampères at a given voltage, in other words some watts. And that's why it's all about radiance: it's a <a href="https://en.wikipedia.org/wiki/Radiance" rel="nofollow noreferrer">radiometric measure</a>. </p>

<p>In simple words, your computer sends current to pixels. The way the current is transformed into light (meaning luminance) is related to the pixels technology, quality, age, heat: there are too many factors that are not under the screen's control. </p>

<p><strong>Luminance vs Radiance:</strong></p>

<p>(following your comment)</p>

<p>The difference is that when you speak about luminance, you need to take into consideration the spectrum of the light. RGB is not a good discretisation of the full spectrum, it's just 3 channels for the visible light and 0 for non-visible. When you speak about radiance, you're working with watts (energy): as shown f.ex. on this <a href="https://socratic.org/questions/5348556b02bf347bedff8fed" rel="nofollow noreferrer">page</a> "short wavelenghts carry more energy". In other words, if you wanted to convert luminance to radiance you would need to know the light spectrum (a slope) and convert it into watts (a quantity - energy has no color, so to speak). But it is not feasible at the time of writing to render light sources that have a spectrum, all you can get is RGB... also because RGB is what screens are able to display.</p>

<p>The screens are calibrated so that (1,1,1) appears white, (x,x,x) appears as a gray shade and so on. This somehow compensates the fact that short wavelengths <em>have</em> more energy.</p>

<p>You probably understood: it's quite a mess. You can only get as near to physically based as the technology allows you (as pointed by Wyck in his comment). To do so, I can suggest you to read <strong><em>"Physically based rendering - From theory to implementation" by M. Pharr and G. Humphreys</em></strong> (The second edition ISBN: 978-0-12-375079-2 , I think there's also a third edition). It is unfortunately not feasible to go through all the aspects of the problem in an answer on StackExchange (moreover because I won't rewrite the 1000 pages with my own words, sorry). The book is definitely worth reading.</p>

<p>Last, but not least, in your comment you spoke about "perceived light": you probably also want to read something about <a href="https://en.wikipedia.org/wiki/Tone_mapping" rel="nofollow noreferrer">tonemapping</a> (a.k.a. the methods/algorithms to mimic the human eye perception of luminance). It really depends if you're trying to display lumiance or human perceived brightness.</p>

<p>I hope this helps you seeing how deep the rabbit hole is... up to you to decide how deep you want to go into it!</p>

CC BY-SA 4.0
2018-11-28T09:58:28.083Z
P.S.: your question goes far beyond physically based rendering, I would even say it's not about rendering...
L.C.
CC BY-SA 4.0
2018-11-29T09:45:42.343Z
The detail is actually not that important to me. What I need to know is what I have to store in the final framebuffer of openGL. My assumption is that the value should be proportional to luminance, because when you set it to 1, 1, 1, the output value is white. If this represents radiance than the output should be green, because when the signal radiance is the same, the pixel should be perceived as green. Am I correct?
kevinyu
CC BY-SA 4.0
2018-11-29T22:04:30.423Z
Simulating radiance or luminance is up to you. Are you simulating the energy received on solar panels? You probably want to use radiance. Do you want to know the lux on surfaces? Use luminance. Sorry, your question is not clear.. for example about your goals: what's the graphic engine for? you tagged the question pbr so it's more usual to work with radiance than with luminance.
L.C.
CC BY-SA 4.0
2018-11-28T09:53:33.253Z
2018-11-29T14:22:53.010Z
2018-11-29T14:22:53.010Z
L.C.
<p>I am currently building a graphics engine. I have a slight confusion on the imaging pipeline of computer screen. My question is how does computer transform the colour in the final frame buffer to radiance on the screen. My assumption is that the final colour in the render target should be proportional to luminance instead of radiance. Then, there is some function in the pipeline that will apply transform inverse of the photometric curve of this value to get the radiance of each RGB value. Am I correct?</p>

CC BY-SA 4.0
2018-11-28T15:45:48.487Z
I think the "good-enough" answer for most of us is that as long as you take into consideration the linearity of light and convert to the gamma curve of your display, you've done as much as most people expect you to do.  Colour calibration and monitor profiles may factor into the answer you seek.  If you just look at "gamma", and in particular [sRGB](https://en.wikipedia.org/wiki/SRGB) you might get most of your questions answered.  Is that what you're looking for?
Wyck
CC BY-SA 4.0
2018-11-29T09:51:58.127Z
@Wyck If I want to use physically based light unit, should I use radiance or luminance before doing the tone mapping step and gamma correction? My assumption is luminance.
kevinyu
CC BY-SA 4.0
2018-11-29T14:39:54.623Z
It depends what physical properties you are trying to model, how physically correct you are trying to be, and if this is a question of modelling physical properties of a scene and then displaying an image of it (rendering), vs the radiometric properties of your display itself (calibrating to get two displays to show the same colours).  In short: radiance talks about light before it reaches your eye, so that's probably what you want to model.  Luminance talks about how a standard eye responds to various frequencies of light.  Take that into consideration late in the pipeline.
Wyck
<pbr>
Luminance and Radiance in computer screen
kevinyu
# Luminance and Radiance in computer screen

(Asked by: username_0 on 2018-11-19)

I am currently building a graphics engine. I have a slight confusion on the imaging pipeline of computer screen. My question is how does computer transform the colour in the final frame buffer to radiance on the screen. My assumption is that the final colour in the render target should be proportional to luminance instead of radiance. Then, there is some function in the pipeline that will apply transform inverse of the photometric curve of this value to get the radiance of each RGB value. Am I correct?

**Tags:** pbr

> **Comments:**
> **username_1**: I think the "good-enough" answer for most of us is that as long as you take into consideration the linearity of light and convert to the gamma curve of your display, you've done as much as most people expect you to do.  Colour calibration and monitor profiles may factor into the answer you seek.  If you just look at "gamma", and in particular [sRGB](https://en.wikipedia.org/wiki/SRGB) you might get most of your questions answered.  Is that what you're looking for?  
> **username_0**: @username_1 If I want to use physically based light unit, should I use radiance or luminance before doing the tone mapping step and gamma correction? My assumption is luminance.  
> **username_1**: It depends what physical properties you are trying to model, how physically correct you are trying to be, and if this is a question of modelling physical properties of a scene and then displaying an image of it (rendering), vs the radiometric properties of your display itself (calibrating to get two displays to show the same colours).  In short: radiance talks about light before it reaches your eye, so that's probably what you want to model.  Luminance talks about how a standard eye responds to various frequencies of light.  Take that into consideration late in the pipeline.  

---

## 2 answers

### Answer by username_2 on 2018-12-02. Score: 1

> 1, 1, 1, the output value is white. If this represents radiance than the output should be green, because when the signal radiance is the same, the pixel should be perceived as green. Am I correct?

This is not correct. Your frame buffer most likely contains sRGB values. Of which 1,1,1 is used to represent white. Standard displays do not use spectral radiance values in the frame buffer. sRGB does not map directly or make any guarantees about the spectral power distribution (SPD) of the display. So "G" of 1 does not guarantee some wave with amplitude using W⋅sr−1⋅m−2 centered on the 550nm. Part of the problem is that different type of displays have different SPDs that map to the same perceived color.

[Evaluation of an organic light-emitting diode display for precise visual stimulation, Ito et. al]
(<https://jov.arvojournals.org/article.aspx?articleid=2121657>)
[![SPDs for different display types](https://i.sstatic.net/GD4E2.jpg)](https://i.sstatic.net/GD4E2.jpg)

Now if you want to physically accurate rendering, you could store all of your lighting values as Radiance with SPDs. As L.C. mentioned, Physically Based Rendering describes that this is done with piece-wise linear functions with like 16+ channels per color. However even if you can get this to be performant, good luck converting all your RGB data into SPDs (there's an infinite # of SPDs for a given RGB value).

Instead what most renderers try to do is to treat the RGB as pseudo-radiance values for the purposes of lighting calculation. This isn't accurate, hence your lighting result changes if you are using Rec.709 or Rec.2020 primaries for instance (if you notice they have different values for mapping to luminance), but it's good enough for real time and even offline in most cases. At this point you can convert RGB Rec709 and Rec2020 values to a single scalar luminance using the Y values of it's primaries.

The Y values of the RGB primaries for Rec709 are:

```
    R       G       B
Y   0.2126  0.7152  0.0722

```

<https://en.wikipedia.org/wiki/SRGB>

Thus Rec709 Linear has the following nits conversion:

```
nits = dot(linear709Rgb, float3(0.2126, 0.7152,0.0722));

```

Probably one of the results of doing our calculations in RGB is that G and B add at equal weights, so it's likely to get some color shifting. There was a presentation at SIGGRAPH 2015 from Weta digital that had some examples, but it doesn't seem like the slides are available. As far as I know they are the only ones using a spectral renderer.


---

### Answer by username_3 on 2018-11-28. Score: 0

**About screens:**

Short answer: yes, it SHOULD, it would be nice. But the technology currently used does not make that possible.

The long answer: it's complicated. First, the signal that your computer sends to the screen is an electric signal. To make it easy to understand, take a look at this [post about the old VGA connector](https://electronics.stackexchange.com/questions/93078/soldering-a-vga-cable-number-of-wires-doesnt-match).

The signal still contains R G and B channels, that's what lights your pixels in a given color. So to try to answer your question: the conversion from RGB electric signal to light (meaning radiance) depends on the screen, not on your PC. Different screens and brands behave differently, that's why they don't all look the same. The technology used for the pixels also matters: LED, LCD, cathodic, OLED, plasma... all behave in different ways.

The signal coming from your computer tells the screen the color and the intensity of each pixel. The intensity is transmitted using a [pulse](https://www.researchgate.net/figure/Two-measures-of-electrical-power-signals-for-LED-control-with-D-Type-flip-flop-register_fig6_224222964) (the leds blink fast enough so the human eye can't see it and the % of time it's on determines how bright it looks... to human eye).

Even if that was not the case, and the pixels were analogic, you would still send an electric signal: some ampères at a given voltage, in other words some watts. And that's why it's all about radiance: it's a [radiometric measure](https://en.wikipedia.org/wiki/Radiance).

In simple words, your computer sends current to pixels. The way the current is transformed into light (meaning luminance) is related to the pixels technology, quality, age, heat: there are too many factors that are not under the screen's control.

**Luminance vs Radiance:**

(following your comment)

The difference is that when you speak about luminance, you need to take into consideration the spectrum of the light. RGB is not a good discretisation of the full spectrum, it's just 3 channels for the visible light and 0 for non-visible. When you speak about radiance, you're working with watts (energy): as shown f.ex. on this [page](https://socratic.org/questions/5348556b02bf347bedff8fed) "short wavelenghts carry more energy". In other words, if you wanted to convert luminance to radiance you would need to know the light spectrum (a slope) and convert it into watts (a quantity - energy has no color, so to speak). But it is not feasible at the time of writing to render light sources that have a spectrum, all you can get is RGB... also because RGB is what screens are able to display.

The screens are calibrated so that (1,1,1) appears white, (x,x,x) appears as a gray shade and so on. This somehow compensates the fact that short wavelengths *have* more energy.

You probably understood: it's quite a mess. You can only get as near to physically based as the technology allows you (as pointed by username_1 in his comment). To do so, I can suggest you to read ***"Physically based rendering - From theory to implementation" by M. Pharr and G. Humphreys*** (The second edition ISBN: 978-0-12-375079-2 , I think there's also a third edition). It is unfortunately not feasible to go through all the aspects of the problem in an answer on StackExchange (moreover because I won't rewrite the 1000 pages with my own words, sorry). The book is definitely worth reading.

Last, but not least, in your comment you spoke about "perceived light": you probably also want to read something about [tonemapping](https://en.wikipedia.org/wiki/Tone_mapping) (a.k.a. the methods/algorithms to mimic the human eye perception of luminance). It really depends if you're trying to display lumiance or human perceived brightness.

I hope this helps you seeing how deep the rabbit hole is... up to you to decide how deep you want to go into it!

> **Comments:**
> **username_3**: P.S.: your question goes far beyond physically based rendering, I would even say it's not about rendering...  
> **username_0**: The detail is actually not that important to me. What I need to know is what I have to store in the final framebuffer of openGL. My assumption is that the value should be proportional to luminance, because when you set it to 1, 1, 1, the output value is white. If this represents radiance than the output should be green, because when the signal radiance is the same, the pixel should be perceived as green. Am I correct?  
> **username_3**: Simulating radiance or luminance is up to you. Are you simulating the energy received on solar panels? You probably want to use radiance. Do you want to know the lux on surfaces? Use luminance. Sorry, your question is not clear.. for example about your goals: what's the graphic engine for? you tagged the question pbr so it's more usual to work with radiance than with luminance.  

---

