getting the properties of the rays traversed

[itsghaniz]

Hi team, hope you are well. I am trying to make a python program in which I can give the position of a camera, and give the position of the light source, (receiver and transmitter) to get the properties of the rays = between these 2. This includes type interaction with the material, i.e. reflection, diffraction scattering or simple line of sight, the distance between each interactons of each ray, normals of the surfaces and the points of interactions. moreover I would want to keep on updating the positions of the transmitter and the receiver. can you please suggest me a sample code for something similar and the functions that I should be using to achieve this. thanks in advance.

note: It is something similar to nvidia's instant RM, but i dont want the radio maps just the properties of the rays.

[njroussel]

Hi @itsghaniz

Something like this is definitely achievable with Mitsuba. The main components would be scene.ray_intersect and then access the intersection information that is stored in a SurfaceInteraction3f object.

This tutorial is pretty good starting point to see how to put together some of these primitives: https://mitsuba.readthedocs.io/en/stable/src/rendering/scripting_renderer.html

[itsghaniz]

Hello, Thanks alot for the reply, I came up with the following code, through which I was able to create rays in all directions from an origin (transmitter) with a certain number of reflections, I want to ask, if there is a way that I can adjust it such that I get only the rays which reach my receiver and if there is a way to make a certain shape of that receiver?

# 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()
        
        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

thanks in advance.

[njroussel]

I've shared some code on this thread to identify when your rays hit a specific object: #1488. You can make that shape whatever you want.