Eval attribute of custom BSDF

[Frollo24]

Hi again! I'm trying to model a custom BSDF which allows me to use a specular reflectance texture for a Principled Disney BSDF. Before implementing my custom Principled BSDF, I have implemented a very simple custom diffuse BSDF in order to see if it works correctly with my custom integrators. The problem with that comes when I try to evaluate some attributes from my BSDF, which gives me the following error message:

RuntimeError: ​[object.cpp:74] The `put_parameter` methods must be overriden!

This is my custom BSDF so far:

class CustomBSDF(mi.BSDF):
    def __init__(self, props):
        mi.BSDF.__init__(self, props)

        self.tint = props['tint']

        self.m_flags = mi.BSDFFlags.DiffuseReflection | mi.BSDFFlags.FrontSide
        self.m_components = [self.m_flags]

    def eval(self, ctx: mi.BSDFContext, si: mi.SurfaceInteraction3f, wo: mi.Vector3f,
             active: bool = True) -> mi.Color3f:
        if not ctx.is_enabled(mi.BSDFFlags.DiffuseReflection):
            return mi.Color3f(0.0)

        return mi.Color3f(self.tint)

    def pdf(self, ctx: mi.BSDFContext, si: mi.SurfaceInteraction3f, wo: mi.Vector3f,
            active: bool = True) -> float:
        if not ctx.is_enabled(mi.BSDFFlags.DiffuseReflection):
            return 0.0

        cos_theta_i = mi.Frame3f.cos_theta(si.wi)
        cos_theta_o = mi.Frame3f.cos_theta(wo)

        pdf = mi.warp.square_to_cosine_hemisphere_pdf(wo)

        return dr.select(dr.and_(cos_theta_i > 0.0, cos_theta_o > 0.0), pdf, 0.0)

    def sample(self, ctx: mi.BSDFContext, si: mi.SurfaceInteraction3f, sample1: float, sample2: mi.Point2f,
               active: bool = True) -> tuple[mi.BSDFSample3f, mi.Color3f]:
        cos_theta_i = mi.Frame3f.cos_theta(si.wi)
        active &= cos_theta_i > 0.0

        bs = mi.BSDFSample3f()
        bs.wo = mi.warp.square_to_cosine_hemisphere(sample2)
        bs.pdf = mi.warp.square_to_cosine_hemisphere_pdf(bs.wo)
        bs.eta = 1.0
        bs.sampled_type = +mi.BSDFFlags.DiffuseReflection
        bs.sampled_component = 0

        value = mi.Color3f(self.tint)
        return bs, dr.select(active & (bs.pdf > 0.0), value, mi.Color3f(0.0))

    def traverse(self, callback: mi.TraversalCallback):
        callback.put_parameter('tint', self.tint, mi.ParamFlags.Differentiable)

    def to_string(self) -> str:
        return ('CustomBSDF[\n'
                '   tint=%s,\n'
                ']' % (self.tint))

Searching through the code I've found that the implementation that I would like to be used for this case is the same as the implementation of the class AttributeCallback. Is there a way to indicate that I want to use that implementation when rendering from a custom integrator?

An example of a custom integrator could look like this:

class Roughness(mi.SamplingIntegrator):
    def __init__(self, props):
        mi.SamplingIntegrator.__init__(self, props)

    def sample(self, scene: mi.Scene, sampler, ray: mi.RayDifferential3f, medium: mi.Medium = None,
               active: bool = True) -> tuple[mi.Color3f, bool, List[float]]:
        si = scene.ray_intersect(ray=ray, active=active)
        bsdf = si.bsdf(ray)
        col_eval = bsdf.eval_attribute('roughness', si=si, active=active)

        valid = si.is_valid()
        color = dr.select(valid, col_eval, mi.Color3f(0.0, 0.0, 0.0))

        return color, valid, [dr.select(valid, 1.0, 0.0)]

Note: I'm okay with the eval_attribute() method outputting black if that attribute is not found, I want the attribute to be evaluated if found and outputting some default value (for example, black) if that attribute is not found.

Thanks in advance!

[njroussel]

Hi @Frollo24

This should just work? I litterally ran your code and couldn't reproduce the same error message.

Here's a test where we use a custom BSDF and test that we can evaluate its custom attribute: https://github.com/mitsuba-renderer/mitsuba3/blob/master/src/render/tests/test_bsdf.py#L30-L66

Could you send a full reproducer if you're still seeing this issue?
One thing you should be careful about is casting your tint parameter in the custroctor of the BSDF (self.tint = mi.Color3f(props['tint']))). In short, an attribute is expected to be of the correct type, or else it will not be detected.

[Frollo24]

Sorry for a late response. The code I'm working on is private and I cannot post it here, but I've created a very simple example using the same BSDF and Integrator:

import mitsuba as mi
import drjit as dr

mi.set_variant('cuda_ad_rgb')


class CustomBSDF(mi.BSDF):
    def __init__(self, props):
        mi.BSDF.__init__(self, props)

        self.tint = props['tint']

        self.m_flags = mi.BSDFFlags.DiffuseReflection | mi.BSDFFlags.FrontSide
        self.m_components = [self.m_flags]

    def eval(self, ctx: mi.BSDFContext, si: mi.SurfaceInteraction3f, wo: mi.Vector3f,
             active: bool = True) -> mi.Color3f:
        if not ctx.is_enabled(mi.BSDFFlags.DiffuseReflection):
            return mi.Color3f(0.0)

        return mi.Color3f(self.tint)

    def pdf(self, ctx: mi.BSDFContext, si: mi.SurfaceInteraction3f, wo: mi.Vector3f,
            active: bool = True) -> float:
        if not ctx.is_enabled(mi.BSDFFlags.DiffuseReflection):
            return 0.0

        cos_theta_i = mi.Frame3f.cos_theta(si.wi)
        cos_theta_o = mi.Frame3f.cos_theta(wo)

        pdf = mi.warp.square_to_cosine_hemisphere_pdf(wo)

        return dr.select(dr.and_(cos_theta_i > 0.0, cos_theta_o > 0.0), pdf, 0.0)

    def sample(self, ctx: mi.BSDFContext, si: mi.SurfaceInteraction3f, sample1: float, sample2: mi.Point2f,
               active: bool = True) -> tuple[mi.BSDFSample3f, mi.Color3f]:
        cos_theta_i = mi.Frame3f.cos_theta(si.wi)
        active &= cos_theta_i > 0.0

        bs = mi.BSDFSample3f()
        bs.wo = mi.warp.square_to_cosine_hemisphere(sample2)
        bs.pdf = mi.warp.square_to_cosine_hemisphere_pdf(bs.wo)
        bs.eta = 1.0
        bs.sampled_type = +mi.BSDFFlags.DiffuseReflection
        bs.sampled_component = 0

        value = mi.Color3f(self.tint)
        return bs, dr.select(active & (bs.pdf > 0.0), value, mi.Color3f(0.0))

    def traverse(self, callback: mi.TraversalCallback):
        callback.put_parameter('tint', self.tint, mi.ParamFlags.Differentiable)

    def to_string(self) -> str:
        return ('CustomBSDF[\n'
                '   tint=%s,\n'
                ']' % (self.tint))


class Roughness(mi.SamplingIntegrator):
    def __init__(self, props):
        mi.SamplingIntegrator.__init__(self, props)

    def sample(self, scene: mi.Scene, sampler, ray: mi.RayDifferential3f, medium: mi.Medium = None,
               active: bool = True) -> tuple[mi.Color3f, bool, list[float]]:
        si = scene.ray_intersect(ray=ray, active=active)
        bsdf = si.bsdf(ray)
        col_eval = bsdf.eval_attribute('roughness', si=si, active=active)

        valid = si.is_valid()
        color = dr.select(valid, col_eval, mi.Color3f(0.0, 0.0, 0.0))

        return color, valid, [dr.select(valid, 1.0, 0.0)]


mi.register_integrator('roughness', lambda props: Roughness(props))
mi.register_bsdf('custom', lambda props: CustomBSDF(props))

scene = mi.load_dict({
    'type': 'scene',
    'integrator': {
        'type': 'roughness'
    },
    'sensor': {
        'type': 'perspective',
        'fov': 39.3077,
        'to_world': mi.ScalarTransform4f.look_at(
            origin=[0.0, 1.0, 5.0],
            target=[0.0, 1.0, 0.0],
            up=[0.0, 1.0, 0.0]
        ),
        'film': {
            'type': 'hdrfilm',
            'width': 1080,
            'height': 720
        }
    },
    'shape0': {
        'type': 'sphere',
        'bsdf': {
            'type': 'custom',
            'tint': {
                'type': 'rgb',
                'value': [0.1, 1, 0.3]
            }
        }
    }
})

image = mi.render(scene, spp=1024)
mi.util.write_bitmap('custom_plugins.png', image, quality=1)

And here is the result of the execution:

C:\Users\***\PycharmProjects\mitsubaRenders\venv\Scripts\python.exe C:/Users/***/PycharmProjects/mitsubaRenders/test_custom_plugins.py
Traceback (most recent call last):
  File "C:\Users\***\PycharmProjects\mitsubaRenders\test_custom_plugins.py", line 109, in <module>
    image = mi.render(scene, spp=1024)
            ^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "C:\Users\***\PycharmProjects\mitsubaRenders\venv\Lib\site-packages\mitsuba\python\util.py", line 522, in render
    return dr.custom(_RenderOp, scene, sensor, params, integrator,
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "C:\Users\***\PycharmProjects\mitsubaRenders\venv\Lib\site-packages\drjit\router.py", line 5586, in custom
    output = inst.eval(**{ k: _dr.detach(v) for k, v in kwargs.items() })
             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "C:\Users\***\PycharmProjects\mitsubaRenders\venv\Lib\site-packages\mitsuba\python\util.py", line 377, in eval
    return self.integrator.render(
           ^^^^^^^^^^^^^^^^^^^^^^^
  File "C:\Users\***\PycharmProjects\mitsubaRenders\test_custom_plugins.py", line 67, in sample
    col_eval = bsdf.eval_attribute('roughness', si=si, active=active)
               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "C:\Users\***\PycharmProjects\mitsubaRenders\test_custom_plugins.py", line 51, in traverse
    callback.put_parameter('tint', self.tint, mi.ParamFlags.Differentiable)
RuntimeError: ​[object.cpp:74] The `put_parameter` methods must be overriden!

Process finished with exit code 1

Here is the system info of Mitsuba (I'm using w11, but w10 is detected):

System information:

  OS: Windows-10
  CPU: Intel64 Family 6 Model 165 Stepping 3, GenuineIntel
  GPU: NVIDIA GeForce RTX 3060 Ti
  Python: 3.11.0 (main, Oct 24 2022, 18:26:48) [MSC v.1933 64 bit (AMD64)]
  NVidia driver: 531.14
  CUDA: 12.1.66
  LLVM: -1.-1.-1

  Dr.Jit: 0.4.3
  Mitsuba: 3.4.0
     Is custom build? False
     Compiled with: MSVC 19.37.32822.0
     Variants:
        scalar_rgb
        scalar_spectral
        cuda_ad_rgb
        llvm_ad_rgb

And I'm using PyCharm Community Edition 2021.3.1

[rtabbara]

Hi @Frollo24 ,

I think the main problem is that you should be using callback.put_object rather than callback.put_parameter as tint corresponds to a plugin type - namely, a Mitsuba texture.

Additionally, a few small things I had to modify to get your example to work

• In the Roughness class, the return for sample should be return color, valid, [] The latter argument correspond to a list of AOVs which in this instance should be empty.
• Additionally, in the same sample function, the BSDF attribute you're evaluating would be tint rather than roughness.

Also, please keep in mind that I tested this with latest version of Mitsuba (3.5.0) so you may also want to consider upgrading if you're still encountering issues.

[Frollo24]

Thanks for your response! I'm testing the simpler case with Mitsuba version 3.5.0 and it works, but I would also like to discuss how to add a parameter which can be a texture or a float (like roughness) with the same flexibility as the Mitsuba Principled BSDF offers. In other words, I would like to achieve something like this:

'float_bsdf': {
    'type': 'custom',
    'roughness': 0.5,
    'tint': {
        'type': 'rgb',
        'value': [0.1, 1, 0.3]
    }
},
'texture_bsdf': {
    'type': 'custom',
    'roughness': {
        'type': 'bitmap',
        'filename': 'roughness.png'
    },
    'tint': {
        'type': 'rgb',
        'value': [0.1, 1, 0.3]
    }
},

Where those two BSDFs could be evaluated with the same roughness integrator I've shown.

Thanks in advance for any response!

[rtabbara]

Hi @Frollo24 ,

I think the simplest thing here is to wrap your float as a uniform spectrum, which internally is initialised as a (spatially-invariant) texture object.

'roughness': { 'type': 'uniform', 'value': 0.5 }

For the existing BSDFs written in C++, we internally do this kind of conversion during initialisation when the property type is a float. You could certainly similarly do this manual type checking and conversion in Python if you strictly wanted to maintain the same interface.

[Frollo24]

Thanks again for your response! I think I'm going to wrap my float as a uniform spectrum, which I think is cleaner than converting the float to a texture.

For anyone reading this, I'm going to mark this comment as the answer because I'm going to include some example working code about this discussion, but I want to mention both @njroussel and @rtabbara for helping me out with this question I had.

Here is the code that I have now:

import mitsuba as mi
import drjit as dr

mi.set_variant('cuda_ad_rgb')


# A Custom BSDF, this example works like a perfectly diffuse BSDF
# which also has a monochromatic attribute that does nothing to the
# actual rendering
class CustomBSDF(mi.BSDF):
    def __init__(self, props):
        mi.BSDF.__init__(self, props)

        self.tint = props['tint']
        self.roughness = props['roughness']

        self.m_flags = mi.BSDFFlags.DiffuseReflection | mi.BSDFFlags.FrontSide
        self.m_components = [self.m_flags]

    def eval(self, ctx: mi.BSDFContext, si: mi.SurfaceInteraction3f, wo: mi.Vector3f,
             active: bool = True) -> mi.Color3f:
        if not ctx.is_enabled(mi.BSDFFlags.DiffuseReflection):
            return mi.Color3f(0.0)

        cos_theta_o = mi.Frame3f.cos_theta(wo)
        return self.tint.eval(si, active) * dr.inv_pi * cos_theta_o

    def pdf(self, ctx: mi.BSDFContext, si: mi.SurfaceInteraction3f, wo: mi.Vector3f,
            active: bool = True) -> float:
        if not ctx.is_enabled(mi.BSDFFlags.DiffuseReflection):
            return 0.0

        cos_theta_i = mi.Frame3f.cos_theta(si.wi)
        cos_theta_o = mi.Frame3f.cos_theta(wo)

        pdf = mi.warp.square_to_cosine_hemisphere_pdf(wo)

        return dr.select(dr.and_(cos_theta_i > 0.0, cos_theta_o > 0.0), pdf, 0.0)

    def sample(self, ctx: mi.BSDFContext, si: mi.SurfaceInteraction3f, sample1: float, sample2: mi.Point2f,
               active: bool = True) -> tuple[mi.BSDFSample3f, mi.Color3f]:
        cos_theta_i = mi.Frame3f.cos_theta(si.wi)
        active &= cos_theta_i > 0.0

        bs = mi.BSDFSample3f()
        bs.wo = mi.warp.square_to_cosine_hemisphere(sample2)
        bs.pdf = mi.warp.square_to_cosine_hemisphere_pdf(bs.wo)
        bs.eta = 1.0
        bs.sampled_type = +mi.BSDFFlags.DiffuseReflection
        bs.sampled_component = 0

        value = self.tint.eval(si, active)
        return bs, dr.select(active & (bs.pdf > 0.0), value, mi.Color3f(0.0))

    def traverse(self, callback: mi.TraversalCallback):
        callback.put_object('tint', self.tint, mi.ParamFlags.Differentiable)
        callback.put_object('roughness', self.roughness, mi.ParamFlags.Differentiable)

    def to_string(self) -> str:
        return ('CustomBSDF[\n'
                '   tint=%s,\n'
                '   roughness=%s,\n'
                ']' % (self.tint, self.roughness))


# Roughness integrator, it evaluates the roughness of a BSDF as a monochromatic
# attribute and returns 0 if the BSDF does not have a roughness attribute
class Roughness(mi.SamplingIntegrator):
    def __init__(self, props):
        mi.SamplingIntegrator.__init__(self, props)

    def sample(self, scene: mi.Scene, sampler, ray: mi.RayDifferential3f, medium: mi.Medium = None,
               active: bool = True) -> tuple[mi.Color3f, bool, list[float]]:
        si = scene.ray_intersect(ray=ray, active=active)
        bsdf = si.bsdf(ray)
        col_eval = bsdf.eval_attribute_1('roughness', si=si, active=active)

        valid = si.is_valid()
        color = dr.select(valid, col_eval, mi.Color3f(0.0, 0.0, 0.0))

        return color, valid, []


# Roughness integrator, it evaluates the tint of a BSDF as a spectrum
# attribute and returns black if the BSDF does not have a tint attribute
class Tint(mi.SamplingIntegrator):
    def __init__(self, props):
        mi.SamplingIntegrator.__init__(self, props)

    def sample(self, scene: mi.Scene, sampler, ray: mi.RayDifferential3f, medium: mi.Medium = None,
               active: bool = True) -> tuple[mi.Color3f, bool, list[float]]:
        si = scene.ray_intersect(ray=ray, active=active)
        bsdf = si.bsdf(ray)
        col_eval = bsdf.eval_attribute('tint', si=si, active=active)

        valid = si.is_valid()
        color = dr.select(valid, col_eval, mi.Color3f(0.0, 0.0, 0.0))

        return color, valid, []


# Registering custom integrators and the custom BSDF
mi.register_integrator('roughness', lambda props: Roughness(props))
mi.register_integrator('tint', lambda props: Tint(props))
mi.register_bsdf('custom', lambda props: CustomBSDF(props))

# Creating a sample scene which uses different BSDFs.
# Modify the BSDF reference and the integrator as desired
scene = mi.load_dict({
    'type': 'scene',
    'integrator': {
        'type': 'tint'
    },
    'sensor': {
        'type': 'perspective',
        'fov': 39.3077,
        'to_world': mi.ScalarTransform4f.look_at(
            origin=[0.0, 1.0, 5.0],
            target=[0.0, 0.0, 0.0],
            up=[0.0, 1.0, 0.0]
        ),
        'film': {
            'type': 'hdrfilm',
            'width': 1080,
            'height': 720
        }
    },
    'principled_bsdf': {
        'type': 'principled',
        'base_color': {
            'type': 'rgb',
            'value': [0.1, 1, 0.3]
        },
        'roughness': 0.5
    },
    'texture_bsdf': {
        'type': 'custom',
        'roughness': {
            'type': 'bitmap',
            'filename': 'roughness.png'
        },
        'tint': {
            'type': 'bitmap',
            'filename': 'tint.png'
        }
    },
    'color_bsdf': {
        'type': 'custom',
        'roughness': {
            'type': 'uniform',
            'value': 0.5
        },
        'tint': {
            'type': 'rgb',
            'value': [0.1, 1, 0.3]
        }
    },
    'shape0': {
        'type': 'sphere',
        'bsdf': {
            'type': 'ref',
            'id': 'texture_bsdf'
        }
    },
    'emitter': {
        'type': 'point',
        'position': [3.0, 5.0, 2.0],
        'intensity': {
            'type': 'rgb',
            'value': 100.0,
        }
    },
    'ambient': {
        'type': 'constant',
        'radiance': {
            'type': 'rgb',
            'value': 0.05,
        }
    }
})

# Render the scene and save it to an image
image = mi.render(scene, spp=1024)
mi.util.write_bitmap('custom_plugins.png', image, quality=1)