How to set only light sampling, only BRDF sampling, and multiple importance sampling?

[fzy28]

I am implementing my own BRDF sampling method and pdf calculation for a custom BRDF.

For now, I have tested the cosine weight sampling and my own sampling, with the reflection_flags = ( mi.BSDFFlags.DeltaReflection | mi.BSDFFlags.FrontSide ), I think this is only BRDF sampling right? And those two images converge to the same final results.

But when I set reflection_flags = ( mi.BSDFFlags.Reflection | mi.BSDFFlags.FrontSide ), my output would be different...

Can you help with some of the reflection flags stuff? How to set the mitsuba 3 only do BRDF sampling or do multiple importance sampling?

Here is my code, my brdf already consider the cosine_theta_o.

import mitsuba as mi
import drjit as dr
from utils import *
from tqdm import tqdm
from scipy.spatial.transform import Rotation as R
from model import *
from analytical_brdf_torch import *
from utils.distribution import *
mi.set_variant("cuda_ad_rgb")
dr.set_flag(dr.JitFlag.VCallRecord, False)
dr.set_flag(dr.JitFlag.LoopRecord, False)
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")


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

        self.filename = props["filename"]
        self.albedo = mi.Color3f([1 ,1 ,1])
        reflection_flags = (
         mi.BSDFFlags.Reflection | mi.BSDFFlags.FrontSide
        )
        self.m_components = [reflection_flags]
        self.m_flags = reflection_flags
    
    def sample(self, ctx, si, sample1, sample2, active=True):
        # Compute Fresnel terms

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

        active &= cos_theta_i > 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.UInt32(+self.m_flags)
        bs.sampled_component = 0
        
        wi = cart_to_spher(si.wi.torch())
        wo = cart_to_spher(bs.wo.torch())
        
        brdf = classic_shading_pdf(wi,wo,0.5)
        brdf = mi.Float32(brdf)

         
        value = brdf / bs.pdf  * self.albedo
        
        return (bs, dr.select(active & (bs.pdf > 0.0), value, mi.Vector3f(0)))

    def eval(self, ctx, si, wo, active=True):
        cos_theta_i = mi.Frame3f.cos_theta(si.wi)
        cos_theta_o = mi.Frame3f.cos_theta(wo)
        wi = cart_to_spher(si.wi.torch())
        wo = cart_to_spher(wo.torch())
        
        brdf = classic_shading_pdf(wi,wo,0.5)
        brdf = mi.Float(brdf)
        value = brdf  * self.albedo
        return dr.select(
            (cos_theta_i > 0.0) & (cos_theta_o > 0.0), value, mi.Vector3f(0)
        )
    def pdf(self, ctx, si, wo, active=True):
        
        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((cos_theta_i > 0.0) & (cos_theta_o > 0.0), pdf, 0.0)

    def eval_pdf(self, ctx, si, wo, active=True):
        return self.eval(ctx, si, wo, active), self.pdf(ctx, si, wo, active)

    def to_string(self):
        return "MyBSDF[\n" "    albedo=%s,\n" "]" % (self.albedo)


if __name__ == "__main__":
    mi.set_variant("cuda_ad_rgb")
    import time

    start_time = time.time()

    mi.register_bsdf("mybsdf", lambda props: MyBSDF(props))
    # scene = mi.load_file("./disney_bsdf_test/disney_diffuse.xml")

    scene = mi.load_file("./matpreview/scene.xml")
    
    # print(params)
    SPP = 4
    spp = SPP * 128

    seed = 0
    with torch.no_grad():
        image = mi.render(scene, spp=SPP, seed=seed).numpy()
        print(image.shape)
        for _ in tqdm(range(spp // SPP)):
            image += mi.render(scene, spp=SPP, seed=seed).numpy()
            seed += 1
        image /= (spp // SPP) + 1

        mi.util.write_bitmap("cosine1.png", image)
    end_time = time.time()

    print("Render time: " + str(end_time - start_time) + " seconds")

[Speierers]

Hi @fzy28 ,

The path tracer implemented in Mitsuba 3 (path) uses two sampling strategies: BSDF sampling and Next Event Estimation (NEE).

NEE is only performed if the BSDF of the shading point is "smooth" (e.g. diffuse or glossy). When only setting the BSDFFalgs::DeltaReflection flag, this will effectively prevent NEE from being used with this BSDF. The BSDFFlags::Reflection flag on the other hand will work with both BSDF sampling and NEE, and therefore MIS will be applied too.

I hope this answers your question.

[fzy28]

Thanks for your kind reply! But I am still confused about diffusereflection flag, what's the difference between it and reflection flag ？ Thanks！

[Speierers]

The Reflection flags is a compound flags enabling all reflection lobes (DiffuseReflection + GlossyReflection + DeltaReflection). The DiffuseReflection flag only represents ideally diffuse reflection (e.g. lambertian). On the other end of the spectrum, you have DeltaReflection for perfectly specular surfaces (e.g. mirror), and the in between GlossyReflection e.g. for microfacet models.

[fzy28]

Thanks for your answer!

That's exact what I want to ask. For example, I test on my own BRDF sampling method, and the mitsuba cosine weight sampling, when I set the flag to delta reflection, renderer should only do BRDF sampling, and here, what flag should I set for MIS?

I test on both diffuse reflection and reflection flag, but the diffuse reflection would converge to the same image as the BRDF sampling one, but when I set the reflection flag, the image is different, for both my sampling method and the cosine weight sampling method.

I wonder what exactly the renderer is doing when I set different flag? And how the different flags work? As you said they are different lobes?

Thanks!

[njroussel]

Hi @fzy28

You can find all the flag definitions here:
https://github.com/mitsuba-renderer/mitsuba2/blob/master/include/mitsuba/render/bsdf.h#L38-L124

To get the full answer as to when/how the sampling steps happen and what the flags are doing, I'd suggest you take a closer look at the integrator (assuming you're using path: https://github.com/mitsuba-renderer/mitsuba2/blob/master/src/integrators/path.cpp#L100-L211).
As you can see, with a DeltaReflection flag the em_pdf is set to 0 which is then used to do MIS. As expected, because we can't do emitter sampling with such a BSDF, the weight is zero.

In short, in Mitsuba a BSDF is characterized by certain traits which we have flags for (BSDFFlags). These are only used by the Integrator which will/can use them to request different type of samples. Therefore if you follow the code of the integrator you are using, you should have a complete view of what requests it can make to your BSDF and why it is make them.