Luminance and Radiance in computer screen

Question

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?

Answer 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)

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 2

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.

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 (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.

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 "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 Wyck 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 (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!