How to get irradiance in case of directional emitter and sensor? ptracer and irradiancemeter don't seem to work

[aantg]

Hello mitsubers.

I would really appreciate if someone could help.

I need to measure an irradiance on a shape which it gets from directional light source and also irradiance reflected by this shape in particular direction (to detector). I need such measurements for different source-shape-detector angles (phase angles). Well, there is irradiancemeter sensor in Mitsuba that seems suitable for my needs. But I've examined some discussions here and learned that path tracer is not good choice for my scenario, because it is (almost) impossible to connect sensor(s) with emitter with correct directions or something like this and that it is better to use ptracer. But I found that there's some problems.

Firstly I made different test script based on test_irradiancemeter.py script from Mitsuba sources:

Test script 1 (sphere and constant emitter)

import mitsuba as mi

mi.set_variant('scalar_rgb')
#mi.set_variant('cuda_ad_rgb')

scene_description_test = {
    'type': 'scene',
    'emitter': {
        'type': 'constant',
        'radiance': {
            'type': 'uniform',
            'value': 1.0
        }
    },
    'target': {
        'type': 'sphere',
        'radius': 1.0,
        # 'bsdf': {
        #     'type': 'diffuse',
        #     'reflectance': {
        #         'type': 'spectrum',
        #         'value': 1.0
        #     }
        # },
        'sensor': {
            'type': 'irradiancemeter',
            'film': {
                'type': 'hdrfilm',
                'width': 1,
                'height': 1,
                'filter': {'type': 'tent', 'radius': 0.5},
                # 'filter': {'type': 'box'},
                'pixel_format': 'luminance'
            },
        }
    },
    'integrator': {
        'type': 'path',
        # 'type': 'ptracer',
        # 'hide_emitters': True
    }
}

scene = mi.load_dict(scene_description_test)
out = mi.render(scene, sensor=scene.sensors()[0])
print(out.array)

What I got from this:

1. With path integrator irradiancemeter returns expected ingoing irradiance value of $\pi * L_s$, $L_s$ - emitter radiance. And this result is the same for scalar_rgb and cuda_ad_rgb variants.
2. With path integrator I didn't find any BSDF-dependency of ingoing irradiance value as it should be conceptually.
3. With path integrator increasing spp makes result just slightly worser (I mean increase difference with expected value). I tried spp = 4, 40, 400, 4000, 40000, 400000, 4000000 and got irradiance values 3.1415927410125732 -> 3.0622384548187256 respectively (scalar_rgb), 3.1415927410125732 -> 3.145853281021118 respectively (cuda_ad_rgb).
4. With ptracer irradiance value is absolutely wrong (for example = 473.826 with scalar_rgb, = 488.633 with cuda_ad_rgb). Changing spp causes relatively small irradiance value changes (scalar_rgb: 473.826 (spp = 4) -> 479.035 (spp = 4000000), cuda_ad_rgb: 503.440 with spp = 4 -> 481.093 with spp = 4000000), so irradiancemeter values stays wrong. This is very bad for my goals.
5. With ptracer and scalar_rgb variant I didn't find any BSDF-dependency of ingoing irradiance, but with cuda_ad_rgb there's dependency. For example, diffuse BSDF with reflectance = 0.0 gives irradiancemeter value of 473.826 (just like scalar_rgb variant with any reflectance value), with reflectance = 0.5 it gives irradiance value of 488.633, and 503.440 with reflectance = 1.0. This is bad too.
6. Setting hide_emitters parameter to True works as I expected with path integrator (irradiancemeter returns zero value), but with ptracer it doesn't (irradiancemeter returns smaller, but non-zero value: for example 479.03509521484375 with False -> 5.655997276306152 with True).

BTW with cuda_ad_rgb I get:

jit_shutdown(): detected variable leaks:
 - variable r22 is still being referenced! (ref=1, ref_se=0, type=float32, size=95, stmt="<null>", dep=[19, 1, 16, 0])
 - variable r21 is still being referenced! (ref=1, ref_se=0, type=float32, size=95, stmt="<null>", dep=[18, 1, 15, 0])
 - variable r2 is still being referenced! (ref=4, ref_se=0, type=float32, size=95, stmt="
Process finished with exit code -1073741819 (0xC0000005)

Secondly, despite of my findings I decided to test something close to my scenario so I changed scene by replacing constant emitter to directional with relevant irradiance value and added rectangular shape with another irradiancemeter attached to register reflected irradiance (though I found 3 additional problems here: 1. it will also recieve irradiance directly from directional light source and this irradiance should be excluded/blocked; 2. it will act as light occluder at small phase angles (possible solution: mask with zero opacity or null BSDF?); 3. It may itself act as reflector (possible solution: mask with zero opacity or null BSDF?)). Here is script for this scenario (I added some parameters and calculations to "rotate" light and rectangular detector around the sphere):

Test script 2 (sphere, directional emitter, rectangle)

import mitsuba as mi
import numpy as np

mi.set_variant('scalar_rgb')
# mi.set_variant('cuda_ad_rgb')

# from mitsuba import ScalarTransform4f as T

# Distance to detector from origin
detector_distance = 10e0

# Angles of detector position: 
detector_zenith_angle = 0
detector_azimuth_angle = 0

theta = np.deg2rad(detector_zenith_angle)
phi = np.deg2rad(detector_azimuth_angle)

detector_world_x = (detector_distance * np.clip(np.sin(theta), -1, 1) * np.clip(np.cos(phi), -1, 1))
detector_world_y = detector_distance * np.clip(np.cos(theta), -1, 1)
detector_world_z = (detector_distance * np.clip(np.sin(theta), -1, 1) * np.clip(np.sin(phi), -1, 1))

detector_position = [detector_world_x, detector_world_y, detector_world_z]
# detector_position = T.rotate([0, -1, 0], detector_azimuth_angle).rotate([0, 0, -1], detector_zenith_angle) @ mi.ScalarPoint3f([0, detector_distance, 0])
print("Detector x, y, z: {0:g}, {1:g}, {2:g}".format(*detector_position))

# Angles of light position
light_zenith_angle = 45
light_azimuth_angle = 0

theta = np.deg2rad(light_zenith_angle)
phi = np.deg2rad(light_azimuth_angle)

# Components of light direction vector
light_direction_x = -np.clip(np.sin(theta), -1, 1) * np.clip(np.cos(phi), -1, 1)
light_direction_y = -np.clip(np.cos(theta), -1, 1)
light_direction_z = -np.clip(np.sin(theta), -1, 1) * np.clip(np.sin(phi), -1, 1)

light_direction = [light_direction_x, light_direction_y, light_direction_z]
print("Light direction: {0:g}, {1:g}, {2:g}".format(*light_direction))

phi1 = np.deg2rad(90 - light_zenith_angle)
phi2 = np.deg2rad(90 - detector_zenith_angle)
theta = np.deg2rad(light_azimuth_angle - detector_azimuth_angle)
cos_pha = np.cos(phi1) * np.cos(phi2) * np.cos(theta) + np.sin(phi1) * np.sin(phi2)

phase_angle = np.acos(np.clip(cos_pha, -1, 1))

print("Phase angle: {}".format(np.rad2deg(phase_angle)))

scene_description_direct = {
    'type': 'scene',
    'light': {
        'type': 'directional',
        'direction': light_direction,
        'irradiance': {
            'type': 'spectrum',
            'value': 1000.0
        }
    },
    'target': {
        'type': 'sphere',
        'radius': 1.0,
        'bsdf': {
            'type': 'diffuse',
            'reflectance': {
                'type': 'spectrum',
                'value': 1.0
            }
        },
        'sensor': {
            'type': 'irradiancemeter',
            'film': {
                'type': 'hdrfilm',
                'width': 1,
                'height': 1,
                'filter': {'type': 'tent', 'radius': 0.5},
                # 'filter': {'type': 'box'},
                'pixel_format': 'luminance'
            },
        }
    },
    'integrator': {
        'type': 'ptracer',
        # 'type': 'path',
        # 'hide_emitters': True
    },
    # 'detector': {
    #     'type': 'rectangle',
    #     'to_world': mi.ScalarTransform4f.look_at(
    #         origin=detector_position,
    #         target=[0, 0, 0],
    #         up=[0, 1, 0]) @ mi.ScalarTransform4f.scale([1.1, 1.1, 1]),
    #     'material': {
    #         # 'type': 'mask',
    #         # 'bsdf': {
    #         #     'type': 'diffuse'
    #         # },
    #         # 'opacity': {
    #         #     'type': 'spectrum',
    #         #     'value': 0
    #         # }
    #         # 'type': 'null'
    #     },
    #     # 'flip_normals': True,
    #     'sensor': {
    #         'type': 'irradiancemeter',
    #         'film': {
    #             'type': 'hdrfilm',
    #             'width': 1,
    #             'height': 1,
    #             'filter': {'type': 'tent', 'radius': 0.5},
    #             'pixel_format': 'luminance'
    #         }
    #     }
    # }
}

scene = mi.load_dict(scene_description_direct)
out = mi.render(scene, sensor=scene.sensors()[0])
print(out.array)

Here I started from measuring ingoing irradiance on the sphere, so I commented out detector part of dictionary to exclude its potential influence. As far as I understand theoretically in this scenario ingoing irradiance on the sphere should be equal to $E_s * A_{eff} / A_{sensor} = E_s * \pi * r^2/ (4 * \pi * r^2) = 0.25 * E_s$, where $E_s$ - is light source (emitter) irradiance, $A_{eff}$ - is effective illuminated area (in case of a sphere $A_{eff} = \pi * r^2$, $r$ - radius of the sphere), $A_{sensor}$ - sensor's surface area (in this case $A_{sensor} = 4 * \pi * r^2$). So this ingoing irradiance depends on light source irradiance only, with $E_s = 1000$ expected value is 250. This shouldn't depend on sphere radius and light direction. As I mentioned above, conceptually, I think, measures of irradiancemeter shouldn't depend on BSDF of a shape it is attached, because "This sensor plugin implements an irradiance meter, which measures the incident power per unit area over a shape which it is attached to". There're problems with all this:

1. With path integrator inrradiancemeter returns zero, so, yes, it doesnt't work.
2. With ptracer integrator all corresponding abovemensioned problems persists (wrong irradiance values, BSDF dependency, render variant dependency, hide_emitters doesn't work...).
3. Also with ptracer there's light direction dependency.
4. With ptracer there's sphere radius (i.e. sensor area, I think) dependency.

I've made this table with some results for irradiance value on sphere (spp = 1000000 here):

Source angles		Light vector	Value of irradiancemeter
zenith	azimuth		scalar_rgb	cuda_ad_rgb
90	0	(-1,0,0)	446.940	395.889
270	0	(1,0,0)	446.940	387.768
0	0	(0,-1,0)	404.357	352.887
180	0	(0,1,0)	404.357	320.238
90	90	(0,0,-1)	446.940	290.895
90	270	(0,0,1)	446.940	256.059
45	0	(-0.707107,-0.707107,0)	691.245	565.347
225	0	(0.707107,0.707107,0)	693.002	565.641
135	0	(-0.707107,0.707107,0)	693.541	564.735
315	0	(0.707107,0.707107,0)	693.599	563.676

Irradiance varies with light direction which I believe shouldn't be, and it noticeably differ for scalar_rgb and cuda_ad_rgb.

As for my reflected irradiance detector (rectangle with irradiancemeter).

1. Without sphere in the scene, rectangle irradiancemeter returns non-zero values if it and has diffuse BSDF with reflectance > 0, with null BSDF or mask BSDF with opacity = 0 it returns zero value (of course with rectangle normal properly oriented). Looks like with null BSDF or mask BSDF with opacity = 0 irradiancemeter doesn't register irradiance that comes directly from light source whish is what I need.
2. If sphere is in the scene, rectanglular irradiancemeter returns non-zero values even with null BSDF or mask BSDF and even if its normal is pointing to the sphere. At same time irradiancemeter attached to the sphere returns non-zero value even if this rectangle-detector is between sphere and light source (btw, sides of rectangle = sphere diameter). Looks like with null BSDF or mask BSDF with opacity = 0 my rectangle-detector doesn't occlude light which is what I need. Moreover if it is in between light source and sphere and I set sphere reflectance to zero, then rectangular irradiancemeter returns zero which may indicate that it indeed capture reflected irradiance only and since nothing is reflected it returns zero. The problem is that in this case sphere's irradiancemeter returns zero too, on the contrary to the previous scene where irradiance on the sphere was non-zero even with zero reflectance, ans so maybe that's the reason. Anyways irradiancemeters' values don't seem to be correct and shows strange behaviour IMO. For example, without rectangular shape in the scene, sphere's iradiancemeter returns 446.834 and with rectangular shape (with null BSDF), placed between sphere and light source, sphere's irradiancemeter returns 349.402 and rectangular irradiancemeter returns 1916.448. I don't know how to interpret this.

It seems that it won't be possible to achieve what I need with ptracer and irradiancemeters (because of incorrect values in particular) and I should follow another approach. Actually, I more interested in getting irradiance that is reflected in particular direction and I suspect that irradiancemeter sensor accounts for all directions (not what I want). Maybe I could use path integrator and/or other sensor like othorgraphic and derive irradiance from its output (integrate over solid angle?)?

Any suggestions? I hope I didn't confuse much anyone (including myself) with this text bedsheet.

[njroussel]

Hi @aantg

I'd need to go over the ptracer code in more detail to understand the failure cases you mentioned. Everything you've written leads me to believe there is a bug when combining the irradiancemeter and ptracer.

One thing to be noted: the constant emitter is a bit weird. When used in ptracer it will start tracing rays from a large sphere (encapsulates the entire scene) towards the scene origin (0, 0, 0), so it is somewhat "directional". Whereas with a ptracer, any ray that escapes the scene will get the full radiance contribution,. That fundamentally creates a difference between both integrators in such a setup.

Getting back to your original problem. If you want the following type of light paths: directional source -> shape -> directional sensor. We don't have anything that could support it - creating such light paths requires more advanced techniques that aren't implemented in Mitsuba 3. For convex shapes, the problem comes simpler: you can just integrate over the surface area and call the shape's bsdf's eval method as part of the integrand.

[aantg]

Hello @njroussel

Thank u for the answer.

If you want the following type of light paths: directional source -> shape -> directional sensor. We don't have anything that could support it

What do u mean? That it's impossible to render scene with directional emitter and orthographic sensor using path integrator? There will be zero radiance => black image or incorrect non-zero radiance or what?

creating such light paths requires more advanced techniques that aren't implemented in Mitsuba 3

Like integration angle? Can u, please, reference such techniques?

For convex shapes, the problem comes simpler: you can just integrate over the surface area and call the shape's bsdf's eval method as part of the integrand.

Are there any examples?