Computed Tomography with Mitsuba

[roflmaostc]

Hi,

thanks for doing this great work!

Context

I'm trying to set up a Computed Tomography problem with the Mitsuba renderer.
In principle, it is close to this example.

However, in CT we usually have a fix, collimated illumination and rotate the sample (or illumination & detector). Hence, the constant environment illumination is not suited.

We want to reconstruct a 3D volume of absorbers. There is no scattering.

My questions are:

General Setting

As far as I understood, if we have N angles, we have N different scenes with each a single camera and a single emitter. This is different to the volume optimization tutorial where a single scene with multiple sensors is used.

What emitter would be suited? For a parallel beam CT it would be the distant directional emitter, wouldn't it?

However, I couldn't find how we use the same params for the different scenes. Is it enough to extract the parameters from the first scene and use them for all scenes?
We only want to optimize with respect to the volume of the sample

For the optimization, would we do something like this?

params = mi.traverse(scenes[0])
#. ...
for it in range(10):
    total_loss = 0.0
    for is in range(scenes):
        img = mi.render(scenes[is], params, sensor=sensors[is], spp=spp, seed=it)

Adapt Absorption

Is there a way to assign voxels an absorbing value? So different voxel with differently strong absorption.

Any help would be greatly appreciated!

Felix

[njroussel]

Hi Felix (@roflmaostc)

From my little knowledge of CT, I agree that the directional emitter is what seems the most appropriate here.

The good news is that you can use a single scene, and just move your sensor and emitter around by "editing" the scene. Take a look at this tutorial for a concrete example. So instead of having N scenes, you'll have a single one but during the optimization you'll need to edit it N times to match each angle.
(What you suggest in your message is possible but rather delicate to implement correctly. I'd strongly suggest sticking to a single scene which you edit.)

I'm confused about your last question regarding adaptive absorption. Yes? This is the whole point of the heteogenous plugin -- every grid cell/voxel is adressable. This is exactly what's happening in the volume optimization tutorial.

[roflmaostc]

Thank, I'll check that out and come back next week (probably)!

So the optimization optimizes the sigma_t for each voxel?

Taking the example from there, if I set albedo=0 the scattering is turned off. How do I tell the optimization to keep them constant? That's not specified by this config, is it?

# Declare a heterogeneous participating medium named 'smoke'
'smoke': {
    'type': 'heterogeneous',

    # Acquire extinction values from an external data file
    'sigma_t': {
        'type': 'gridvolume',
        'filename': 'frame_0150.vol'
    },

    # The albedo is constant and set to 0.9
    'albedo': 0.9,

    # Use an isotropic phase function
    'phase': {
        'type': 'isotropic'
    },

    # Scale the density values as desired
    'scale': 200
},

# Attach the index-matched medium to a shape in the scene
'shape': {
    'type': 'obj',
    # Load an OBJ file, which contains a mesh version
    # of the axis-aligned box of the volume data file
    'filename': 'bounds.obj',

    # Reference the medium by ID
    'interior': 'smoke',
    # If desired, this shape could also declare
    # a BSDF to create an index-mismatched
    # transition, e.g.
    # 'bsdf': {
    #     'type': 'isotropic'
    # },
}

Is it done to changing the flags of the params?

SceneParameters[
  ------------------------------------------------------------------------------------------------
  Name                                         Flags    Type  Parent
  ------------------------------------------------------------------------------------------------
  emitter.radiance.value                       ∂        Float UniformSpectrum
  object.interior_medium.scale                          float HeterogeneousMedium
  object.interior_medium.albedo.value.value    ∂        Float UniformSpectrum
  object.interior_medium.sigma_t.data          ∂        TensorXf GridVolume
  object.vertex_count                                   int   Cube
  object.face_count                                     int   Cube
  object.faces                                          UInt  Cube
  object.vertex_positions                      ∂, D     Float Cube
  object.vertex_normals                        ∂, D     Float Cube
  object.vertex_texcoords                      ∂        Float Cube
]
``

[njroussel]

Yes, the sigma_t is a 3D grid, and every voxel is being optimized at the same time.

Keep what constant? The albedo? Unless you're optimizing it, it won't change.

[roflmaostc]

Ok, got it. Specified by this:

key = 'object.interior_medium.sigma_t.data'
opt = mi.ad.Adam(lr=0.02)
opt[key] = params[key]
params.update(opt);

For the scene updating, is that what you described before? The params I can extract once?

for it in range(iteration_count):
    total_loss = 0.0
    for sensor_idx in range(sensor_count):
           # update scene_dict to change light source
           ........
           # 
           scene = mi.load_dict(scene_dict)
           img = mi.render(scene, params, sensor=sensors[sensor_idx], spp=8*spp, seed=it)

[njroussel]

No, what I was describing was using the mi.traverse() mechanism to update the scene.
Something more like this:

scene = mi.load_dict(scene_dict)
params = mi.traverse(scene)
for it in range(iteration_count):
    total_loss = 0.0
    for sensor_idx in range(sensor_count):
           params['light.position'] = compute_light_position(sensor_idx)
           params.update()
           img = mi.render(scene, params, sensor=sensors[sensor_idx], spp=8*spp, seed=it)