get the radiance at a single surface point

[boringfish]

Hi, everyone.
I want get the accurate outgoing radiance at single surface point with the scene including translucent objects.
I use the sampler and integrator like that:

sampler = mi.load_dict({'type': 'independent', 'sample_count': 16})
integrator = mi.load_dict({'type': 'path'})

Since the accurate outgoing radiance need a lot of rays which have bad performance in CPU, I tried to use ray batch with drjit to accelerate it (with cuda). However, the problem is that, the ray batch returns the same radiance for each ray in this batch. I did a single test with the following code:

    sampler = mi.load_dict({'type': 'independent', 'sample_count': 16})
    integrator = mi.load_dict({'type': 'path'})

    offset = mi.Point3f(0.5, 0.5, 0.5)

    origin = mi.Point3f(3, 0.5, 0.5)
    direction = mi.Vector3f(-1, 0, 0)

    # normalize direction
    normalized_direction = dr.normalize(direction)

    # single ray
    ray = mi.Ray3f(origin, normalized_direction)
    for i in range(10):
        radiance_single = integrator.sample(scene, sampler, ray)
        print(f"single radiance: {radiance_single}")

    # ray batch，with the same origin and direction
    ray_count = 10
    origins = dr.tile(origin, ray_count)
    directions = dr.tile(normalized_direction, ray_count)
    rays = mi.Ray3f(origins, directions)


    radiance_batch = integrator.sample(scene, sampler, rays)
    # result output
    print(f"batch radiance: {radiance_batch[0]}")

And the result is:

single radiance: ([[0.0, 0.0, 0.0]], [True], [])
single radiance: ([[0.7443874478340149, 0.35405880212783813, 0.22368210554122925]], [True], [])
single radiance: ([[1.1785880327224731, 0.5683591961860657, 0.36596259474754333]], [True], [])
single radiance: ([[0.6534830927848816, 0.2531842887401581, 0.08734329789876938]], [True], [])
single radiance: ([[0.0, 0.0, 0.0]], [True], [])
single radiance: ([[0.59184330701828, 0.23521432280540466, 0.09449844807386398]], [True], [])
single radiance: ([[0.0, 0.0, 0.0]], [True], [])
single radiance: ([[0.0, 0.0, 0.0]], [True], [])
single radiance: ([[0.534591555595398, 0.30031347274780273, 0.22118785977363586]], [True], [])
single radiance: ([[0.0, 0.0, 0.0]], [True], [])
batch radiance: [[0.7507643103599548, 0.36572954058647156, 0.23455645143985748],
 [0.7507643103599548, 0.36572954058647156, 0.23455645143985748],
 [0.7507643103599548, 0.36572954058647156, 0.23455645143985748],
 [0.7507643103599548, 0.36572954058647156, 0.23455645143985748],
 [0.7507643103599548, 0.36572954058647156, 0.23455645143985748],
 [0.7507643103599548, 0.36572954058647156, 0.23455645143985748],
 [0.7507643103599548, 0.36572954058647156, 0.23455645143985748],
 [0.7507643103599548, 0.36572954058647156, 0.23455645143985748],
 [0.7507643103599548, 0.36572954058647156, 0.23455645143985748],
 [0.7507643103599548, 0.36572954058647156, 0.23455645143985748]]

One can be observed is that, single ray can show random results in each integrator.sample(), but the ray batch returns the same radiance. So, how can I make the ray batch return random results following random walking. Or, Is there any other way to quickly obtain the accurate outgoing radiance (with a lot of ray samples) at a surface intersection point?

[merlinND]

Hello @boringfish,

When using mi.render(), the sampler is automatically seeded with the correct wavefront size.
In your test script, you have used integrator.sample() directly, which does not take care of seeding for you.

By first rendering 1 ray at a time, I assume that you have seeded the sampler with a wavefront size of 1.
This means that from that point on, the sampler will generate only 1 random number. You can check this with sampler.next_1d().
When you switch to a bundle of ray_count, that 1 random number gets broadcaast (copied) over all ray_count lanes, which is why you get the same result for each lane.

Also, don't forget to schedule the state of the sampler after each call to integrator.sample() (that's also something that gets taken care of automatically when using mi.render()).

Here is a fixed example:

import mitsuba as mi
import drjit as dr

mi.set_variant("cuda_ad_rgb")

scene = mi.load_dict(mi.cornell_box())
sampler = mi.load_dict({'type': 'independent', 'sample_count': 16})
integrator = mi.load_dict({'type': 'path'})


# origin = mi.Point3f(3, 0.5, 0.5)
origin = mi.Point3f(0, 0, 3.90)
direction = mi.Vector3f(0, 0, -1)

# normalize direction
normalized_direction = dr.normalize(direction)

# --- single ray
sampler.seed(1234, wavefront_size=1)
ray = mi.Ray3f(origin, normalized_direction)
for i in range(10):
    radiance_single = integrator.sample(scene, sampler, ray)
    sampler.schedule_state()  #  <- important!
    print(f"single radiance: {radiance_single}")

# --- ray batch，with the same origin and direction
ray_count = 10
origins = dr.tile(origin, ray_count)
directions = dr.tile(normalized_direction, ray_count)
rays = mi.Ray3f(origins, directions)
sampler.seed(1234, wavefront_size=ray_count)

radiance_batch = integrator.sample(scene, sampler, rays)
sampler.schedule_state()  #  <- important!

# result output
print(f"batch radiance: {radiance_batch[0]}")