Q: evaluating multiple brdfs in one go

[rajeshsharma-ai]

Hello,
In the tutorials, there is a nice way to eval a brdf over an entire range of directions in one go.
Is there something similar to do the reverse? i.e.
Given a set of directions eval the bsdf for a range of param values.
Right now, I am doing this in a loop:

  -- instantiate the bsdf
  -- get the direction (wi, wo)
  -- for paramValue 0.0 to 1.0
           params[paramKey] = paramValue
           params.update()
           bsdf.eval.(si.wi, wo....)

and it is extremely slow.
Thanks!

[njroussel]

HI @rajeshsharma-ai

You can make vectorized calls to all BSDFs at the same time.
Building a BSDFPtr (vectorized pointers to BSDFs) is a bit finicky in Python. I've put together a tiny snippet that gives you some idea how this could work:

import mitsuba as mi
import drjit as dr

mi.set_variant('cuda_ad_rgb')

bsdfs = [
    mi.load_dict({
        'type': 'roughplastic',
        'diffuse_reflectance': {
            'type': 'rgb',
            'value': param_value
        }
    }) for param_value in [0.1, 0.4, 0.8]
]

# Build vectorized pointer type of BSDFs
bsdfs_unique_ptr = dr.zeros(mi.BSDFPtr, 3)
for i in range(3): # Use recorded loop if many BSDFs
    dr.scatter(bsdfs_unique_ptr, mi.BSDFPtr(bsdfs[i]), i)

direction_pair_count = 2 # Evalutate 2 (wi, wo) pairs per BSDF
direction_pairs = [
    (mi.Vector3f(0, 0, 1),                    mi.Vector3f(0, 0, 1)),
    (dr.normalize(mi.Vector3f(0, 0.8, 0.1)),  mi.Vector3f(0, 0, 1)),
]

# Duplicate/repeat pointers `direction_pair_count` times
bsdfs_ptr = dr.zeros(mi.BSDFPtr, direction_pair_count * dr.width(bsdfs_unique_ptr))
for i in range(direction_pair_count): # Use recorded loop if many directions
    idx = dr.arange(mi.UInt32, dr.width(bsdfs_unique_ptr)) * direction_pair_count + i
    dr.scatter(bsdfs_ptr, bsdfs_unique_ptr, idx)

# Write si (duplicate si.wi)
si = dr.zeros(mi.SurfaceInteraction3f, dr.width(bsdfs_ptr))
for i in range(direction_pair_count): # Use recorded loop if many directions
    idx = dr.arange(mi.UInt32, dr.width(bsdfs_unique_ptr)) * direction_pair_count + i
    dr.scatter(si.wi, direction_pairs[i][0], idx)

# Write wo
wo = dr.zeros(mi.Vector3f, dr.width(bsdfs_ptr))
for i in range(direction_pair_count): # Use recorded loop if many directions
    idx = dr.arange(mi.UInt32, dr.width(bsdfs_unique_ptr)) * direction_pair_count + i
    dr.scatter(wo, direction_pairs[i][1], idx)

values = bsdfs_ptr.eval(mi.BSDFContext(), si, wo)
print(f"{values=}")

[rajeshsharma-ai]

Thanks @njroussel
I couldn't run the code because of 'RecursionError: maximum recursion depth exceeded while calling a Python object' error on the first scatter call. I am using mitsuba version 3.2.1.
But your code gave me an idea to try and it seems to work! It turns out that params can be arrays and for my use case, I don't need the entire combinatorics of params, wi, wo but it's a triplet for which I want to eval the bsdf (i.e. a different param set per wi, wo pair).
Do you see any issues with the following?

import mitsuba as mi
import drjit as dr
import numpy as np

mi.set_variant('cuda_ad_rgb')

bsdf = mi.load_dict({
        'type': 'roughplastic',
        'diffuse_reflectance': {
            'type': 'rgb',
            'value': 0.1
        }})

pcount = 2
params = mi.traverse(bsdf)

# param values as array
pvalues = mi.Color3f(np.array([[0.2, 0.2, 0.2], [0.6, 0.6, 0.6]])) 

# wo
wo = mi.Vector3f(np.array([[0, 0, 0.7], [0, 0, 0.8]]))
print(f"{wo=}")

# si and wi
si = dr.zeros(mi.SurfaceInteraction3f, pcount)
si.wi = mi.Vector3f(np.array([[0, 0, 0.6], [0, 0.8, 0.1]]))
print(f"{si.wi=}")

# update the param values
params['diffuse_reflectance.value'] = pvalues
params.update()
print(f"{params['diffuse_reflectance.value']=}")

# eval the bsdf
values = bsdf.eval(mi.BSDFContext(), si, wo)
print(f"{values=}")

[ziyi-zhang]

Hi,

I can run @njroussel's code with both llvm & cuda.

I think your code should give the correct result in your use case, but it is more like a hack.
diffuse_reflectance has type rgb, which creates a SRGBReflectanceSpectrum texture. Since we are not in the spectral mode, the stored value (diffuse_reflectance.value) is supposed to be a scalar color3f: just 3 scalar numbers, not an array of colors. This is checked in the constructor.
However, we expose that value through traverse and we do not check the validity of the changed value, which allows us to replace it by a vector of colors. Now the BSDF is in an invalid state: the reflectance color of it is simultaneously color A and color B. It happens that in your case, your query si has the same width as the color vector width so drjit is happy with the computation. This would all crash if you have more query angles or more reflectance colors.
Also, this hack would lead to a wrong specular_sampling_weight since it depends on the mean of the reflectance color. But now we are computing the mean of not only the RGB channels, but also across the array of colors: https://github.com/mitsuba-renderer/mitsuba3/blob/8033a807091f8315c5cef25f4f1a36a3766fb223/src/spectra/srgb.cpp#L121C13-L121C48.

[rajeshsharma-ai]

Thank you for your thorough answer and verifying my hunch!