How to use cubeMap in mitsuba?

[ioissss]

I want to generate Shadow Map for a point light source which is a cubeMap, how do I do it? Is there a cubeMap class that can be used directly?

[shinyoung-yi]

I'm not sure whether mitsuba3 already contains any useful functions handling cubemap images (though I guess not).

However, cubemap images can be rendered using a batch sensor with six subsensors, each with a 90-degree FOV.

import numpy as np
import matplotlib.pyplot as plt
import mitsuba as mi
mi.set_variant('scalar_rgb') # Both works
# mi.set_variant('cuda_ad_rgb') # Both works

def cubemap_to_world_list(to_world):
    """
    [Up Left Front(to_world) Right Back Down]
    """
    front = mi.ScalarTransform4f(to_world)
    R = mi.ScalarTransform4f.rotate
    x, y = [1,0,0], [0,1,0]
    return [front @ R(axis=x, angle=-90.), front @ R(axis=y, angle=90.), front,
            front @ R(axis=y, angle=-90.), front @ R(axis=y, angle=180.), front @ R(axis=x, angle=90.)]

def cubemap_sensor(sensor_to_world: mi.ScalarTransform4f, cube_edge: int):
    subsensor_dict = \
    {f"sensor{i}": {'type': 'perspective',
                    'fov': 90,
                    'to_world': to_world
    } for i,to_world in enumerate(cubemap_to_world_list(sensor_to_world))}
    return  mi.load_dict({
        'type': 'batch',
        **subsensor_dict,
        'film': {'type': 'hdrfilm',
                 'width' : cube_edge*6,
                 'height': cube_edge,
                 'pixel_format': 'rgb',
                 'component_format': 'float32'},
        'sampler': {'type': 'independent',
                    'sample_count': 64}
    })

def cubemap_long2cube(img: mi.TensorXf) -> np.ndarray:
    img = np.asarray(img)
    edge = img.shape[0]
    assert edge*6 == img.shape[1]
    cube = np.zeros((3*edge, 4*edge) + img.shape[2:], dtype=img.dtype)

    cube[:edge, edge:2*edge] = img[:, :edge]
    cube[edge:2*edge, :] = img[:, edge:-edge]
    cube[2*edge:, edge:2*edge] = img[:, 5*edge:6*edge]
    return cube

def render_cubemap(scene: mi.Scene, sensor_to_world: mi.ScalarTransform4f, cube_edge: int,
                   integrator: mi.Integrator = None,spp: int = 0) -> np.ndarray:
    batch_sensor = cubemap_sensor(sensor_to_world, cube_edge)
    img_long = mi.render(scene, sensor=batch_sensor, integrator=integrator, spp=spp)
    return cubemap_long2cube(img_long)

scene = mi.load_dict(mi.cornell_box())
to_world = mi.ScalarTransform4f.translate([0, 0, -0.9]) # You can change it to the position of a point source.

cubemap = render_cubemap(scene, to_world, 256)
plt.imshow(cubemap**(1/2.2)); plt.show()

This script gives the following image:

For shadow mapping, you might need the depth integrator:

integ_depth = mi.load_dict({'type': 'depth'})
cubemap_depth = render_cubemap(scene, to_world, 512, integrator=integ_depth)
plt.imshow(cubemap_depth); plt.show()

When I need to generate synthetic environment maps, I use a script like this. If anyone knows of a shorter way, I'd like to hear about it.

[ioissss]

thank you for your reply!!! It helps me a lot !