Energy units in different emitter types

[UNakade]

Hi. I am trying to use Mitsuba 3 to simulate light in real world scenes. It's important that the power and the spectral distribution of the light sources used are accurately represented. I'm a bit confused about the units used for the various types of emitters.

• In some of the emitters, images can be specified instead of a radiance/intensity values (e.g., environment map). How are the 8 bit RGB values converted to the light intensity?
• If a wavelength dependent spectrum is specified, how is it translated to radiance/intensity? In spectral rendering modes,

mi.load_dict({'type': 'spectrum', 'value': [(360, 10), (830, 50)]})

returns:

RegularSpectrum[
  distr = ContinuousDistribution[
    size = 2,
    range = [360, 830],
    integral = [14100],
    pdf = [10, 50]
  ]
]

but

mi.load_dict({'type': 'point', 'intensity': {'type': 'spectrum', 'value': [(360, 10), (830, 50)]}})

returns:

PointLight[
  position = [0, 0, 0],
  intensity = RegularSpectrum[
  distr = ContinuousDistribution[
    size = 2,
    range = [360, 830],
    integral = [132,084],
    pdf = [0,0936766, 0,468383]
  ]
],
  medium = none]

Why did the distr change between the two if the spectrum was specified identically? (Mitsuba is using commas instead of decimal points, probably because I'm in Germany) The ratio between the integrals is 106.75, which is not a multiple of pi or pi².

• The constant emitter always seems to turn out brighter than point/area lights, even if the same radiance is used.

• Also, what exactly is returned in the final .exr file in spectral mode? Is it the weighted photon count for each channel or the irradiance on the area of each pixel or something else?

I could simply run some experiments to figure out how Mitsuba handles these units, but I think knowing the whys and hows will be instructive.

I would highly appreciate your help. Thanks in advance!

[Speierers]

Hi @UNakade,

Those are good questions actually. Let me highlight two things:

• As stated in the plugin documentation, the area emitter's radiance property is defined in units of power per unit area per unit steradian. On the other hand the intensity property of the point emitter is defined in units of power per unit steradian.

• Moreover, when emitter properties are defined using the spectrum type, its value will be multiplied by the D65 illuminant (see doc). But this behavior is going to change in the next release as we find it confusing for users. But for the time being that probably explain the strange differences you where seeing when inspecting the actual values.

I will notify you on this thread when we make this change.

[UNakade]

Hi. Thank you for your response.

I still have a doubt about defining the emitter spectrum. The distr of the intensity is still a ContinuousDistribution with only 2 values in the pdf. Shouldn't that mean that the spectrum is still defined by a straight line? The D65 spectrum is as follows:

>>> mi.load_dict({'type': 'd65'})
RegularSpectrum[
  distr = ContinuousDistribution[
    size = 95,
    range = [360, 830],
    integral = [3.70309],
    pdf = [0.00441316, 0.00467105, 0.00492895, 0.00482895, 0.00472895, .. 85 skipped .., 0.00491663, 0.00517598, 0.00543533, 0.00557121, 0.00570709]
  ]
]

It seems to me that the intensity of the point source is getting multiplied by a constant number, not a spectrum. Also, 106.75 is not a multiple of the integral of the D65 spectrum, which is 3.70309. Also, the D65 spectrum is only defined between the wavelengths of 360 and 830. But this scaling occurs even if you use wavelength values outside this range.

>>> mi.load_dict({'type': 'point', 'intensity': {'type': 'spectrum', 'value': [(150, 10), (200, 50)]}})
PointLight[
  position = [0, 0, 0],
  intensity = RegularSpectrum[
  distr = ContinuousDistribution[
    size = 2,
    range = [150, 200],
    integral = [14.0515],
    pdf = [0.0936766, 0.468383]
  ]
],
  medium = none]

[Speierers]

Looking at the parser code in xml.cpp, this is what's happening when defining a spectrum as a pair of wavelengths and values (see create_texture_from_spectrum():

/* Values are scaled so that integrating the spectrum against the CIE curves
    and converting to sRGB yields (1, 1, 1) for D65. */
Float unit_conversion = 1;
if ((within_emitter && !spectral_unbounded) || !is_spectral_mode)
    unit_conversion = Float(MI_CIE_Y_NORMALIZATION);

/* Detect whether wavelengths are regularly sampled and potentially
    apply the conversion factor. */
Float min_interval = std::numeric_limits<Float>::infinity(),
      max_interval = 0.0;

for (size_t n = 0; n < wavelengths.size(); ++n) {
    values[n] *= unit_conversion;

I suppose this explains the constant number.