Get the rays that hit a certain element

[itsghaniz]

Hi, hope you are well. I am trying to filter only the rays that hit a certain element/object in the scene. Consider the following code below.

# Path tracing function using DR.JIT for paralilisation 
@dr.syntax
def trace_all_paths(max_depth, transmitter,
                num_samples, scene, pattern):
    points =  antenna_type(pattern, num_samples).astype(np.float32)  # Convert to float32
    points = points.T
    transmitter_direction = (0,0,0)
    #ray in local coordinates
    local_ray_direction = dr.normalize(mi.Vector3f(points))
    #ray in world coordinates
    ############## need to add the orientation stuff, but later
    ray_origin = transmitter
    
    #initilizing the paths
    paths = []
        # Create masks for active rays
    # Create masks for active rays
    active = dr.full(dr.mask_t(mi.Float), True, num_samples) 
    positions = []
    normals = []
    distances = [] 

    # Initialize ray objects
    rays = mi.Ray3f(o=ray_origin, d=local_ray_direction)

    for depth in range(max_depth):
        # Intersect rays with the scene
        si = scene.ray_intersect(rays, active)

        # Update active mask: Disable rays that are no longer valid
        active &= si.is_valid()
        **# I know this line is not correct but trying to check if the ray interacted with my_sphere**
        sphere_mask = si.is_valid() & (si.shape.id() == "my_sphere") 
        
        positions.append(si.p) # Shape: (num_samples, 3)
        normals.append(si.n)   # Shape: (num_samples,3)
        distances.append(si.t)  # Shape: (num_samples,)
        # Reflect rays for the next iteration
        rays = si.spawn_ray(si.to_world(mi.reflect(si.wi)))
    return positions

can someone suggest how can I check if the ray interects with the material of the ID "my_sphere"?
in the params = mi.traverse(scene), it can be seen in the params as my_sphere as can also be seen in the figure below.

[njroussel]

Hi @itsghaniz

This is pretty awkward to do.

Here's how I'd go about it, it relies on the fact that we have unique ShapePtr identifiers for each shape object:

import mitsuba as mi
import drjit as dr

mi.set_variant('cuda_ad_rgb')

# Find the `ShapePtr` of the object you're interested in
scene = mi.load_dict(mi.cornell_box())
large_box_ptr = None
for shape in scene.shapes():
    if shape.id() == "large-box": # arbitrary choice
        large_box_ptr = mi.ShapePtr(shape)
assert large_box_ptr is not None


# Trace a bunch of rays
x = dr.linspace(mi.Float, 0, 1, 10)
y = dr.linspace(mi.Float, 0, 1, 10)
points = dr.meshgrid(x, y)
ray, _ = scene.sensors()[0].sample_ray(
    time=0.,
    sample1=0.,
    sample2=points,
    sample3=mi.Vector2f(0.0)
)
si = scene.ray_intersect(ray)

# Keep only those that hit our shape
mask = si.is_valid() & (si.shape == large_box_ptr)
valid_idx = dr.compress(mask)
valid_si = dr.gather(mi.SurfaceInteraction3f, si, valid_idx)

# Check that `valid_si` only has intersections with the large box
assert dr.width(valid_si) > 0
for i in range(dr.width(valid_si)):
    shape_scalar = dr.slice(valid_si.shape, i)
    assert shape_scalar.id() == 'large-box'

[wjakob]

There is also dr.scatter_inc that enables a different way of extracting such sparse data from a rendering process. The documentation contains an example: https://drjit.readthedocs.io/en/latest/reference.html#drjit.scatter_inc

[itsghaniz]

Thanks a lot, It works for me now. really appreciate it.