Volume rendering

Volumetric models are 3D datasets from:

• Computed sources (e.g., simulations)

• Measured sources (e.g., CT or MRI scans)

Built from a stack of 2D image slices

• Each slice = cross-section (cutting plane)

Naïve rendering: slice-by-slice display

• Limitation: only works well when view aligns with slicing direction

Better: use volume rendering

• A form of image-based rendering

• Techniques: alpha blending, texture mapping, etc.

• Allows full 3D perspective

A transfer function maps scalar data (e.g., density) to RGBA values

Used to control:

• Color (RGB)

• Opacity (alpha)

Example: Map CT scan density values to

• Low density (air) → transparent

• Medium density (fat, muscle) → semi-transparent

• High density (bone) → opaque

Can be defined by:

• Simple lookup tables

• Complex mathematical functions

Voxel: Single discrete sample in a volumetric dataset (homogeneous)

Voxels come from stacked 2D slices sampled at fixed spacing

Cell: Connects 8 neighboring voxels, used for interpolation (inhomogeneous)

Intermediate values inside a cell are estimated using trilinear interpolation

Enables smooth transitions between discrete samples

Interpolates values at intermediate points inside a voxel cell

Uses 8 voxel values at the corners of a unit cube

Steps:

• Interpolate along x → get 4 values

• Interpolate those along y → get 2 values

• Interpolate final 2 along z → get interpolated value

Leads to smoother results and less aliasing than nearest neighbor

Image-order rendering (or ray-casting) is a pixel-by-pixel rendering technique for volumetric datasets.

For each pixel, a ray is cast through the volume.

As the ray traverses the volume (back-to-front), it accumulates color (C) and opacity (α) values.

The accumulation is iterative, allowing the final color to reflect absorption and emission effects.

Initially, α and C can be set to 1.

Ray-casting traces a single ray per pixel in one direction (orthographic projection), unlike ray-tracing which may recurse.

To match the image plane’s perspective, the volume can be:

1. Volume-transformed: warp the voxel grid in 3D.

2. Ray-transformed: transform rays to match the original volume.

This transformation allows flexible view alignment for proper sampling.

In ray transform, the volume stays fixed and rays are inversely transformed to traverse the volume grid.

Rays are sampled at uniform intervals; each point is located within a cell.

For each sample, color (C) and opacity (α) are computed via trilinear interpolation.

Accumulation is performed along the ray (like in image-order rendering).

Ray-cell intersections vary, requiring interpolation per cell.

The step size must be chosen carefully:

• Too large: detail is missed

• Too small: rendering is slow

Adaptive step-width may improve performance and quality.

In volume transform, the volume is pre-transformed while rays remain untransformed.

The transformation is done via a series of shear operations (typically 9: 3 per axis), which are hardware-friendly.

After each shear, the volume must be resampled (interpolated) to align voxel data with the rendering grid.

Grid stays fixed, but voxels shift position, often requiring interpolation to compute new voxel values.

This method allows for easier adjustment of constant step width along rays.

Unlike ray transform, transformation effort is applied to data rather than rays.

Compositing Functions: Combine voxel values using methods like average, maximum intensity projection (MIP), distance, or alpha blending.

Opacity (alpha): Each sample has an alpha value; e.g., alpha = 0.3 means 30% opacity.

Early Stopping: Stop ray traversal when accumulated opacity reaches 1 (fully opaque).

Empty Space Skipping: Regions with alpha below a threshold are ignored—no sampling needed.

Space Skipping: Use data structures like octrees to cluster regions of similar opacity and skip them.

Bricking: If volume is too large for memory, split into bricks (smaller blocks) and render sequentially.

Also called voxel projection, object/voxel space traversal, or forward projection

Traverses voxel planes and projects them to the image plane

Accumulates the frame buffer during traversal

Differs from ray-casting (image-order) which traces rays per pixel from image to volume

Front-to-back traversal

• Enables early stopping when opacity (alpha) reaches 1

• Faster but may skip hidden details

Back-to-front traversal

• Accumulates all voxel contributions

• Shows full detail, even if later occluded

Projects one voxel center to a single pixel

• Can cause holes on the image plane

Uses a 3D filter (e.g., Gaussian) around each voxel

Projects to a 2D circular region (footprint of a voxel)

Spreads voxel values across multiple pixels (splatting)

Splatting = convolve voxel value with 2D filter weights

Precomputable footprint for orthographic projections

Uses 3D volume textures for volume rendering

Hardware-accelerated via 3D texture mapping

Parallel polygons are assigned 3D texture coordinates and used as slices

Rendered in back-to-front order

Requires alpha texture mapping for transparency

Polygons can be:

• Axis-aligned (static, constant sampling)

• Viewpoint-aligned (dynamic, requires re-mapping)

Gradients alone don’t capture occlusions or the actual surface location

Isosurfaces can be recovered using the marching cubes algorithm

Steps in the process:

• Divide volume data into a grid of cubes

• Process each cube individually to detect surface intersections

• Determine how surface intersects based on field values at cube corners

Fit polygon(s) through each cube to approximate the surface

Polygon type and placement depends on voxel density values at the 8 corners

Separates cube corners based on a user-defined threshold

• Field values above → in front of surface

• Field values below → behind surface

Polygons are placed to separate the two corner sets

2⁸ = 256 corner configurations exist

• Only 15 distinct cases remain after symmetry reduction

Polygon positions and orientations determined via interpolation between corner values

Final polygons form surface mesh fragments

• Normals are computed for each fragment for shading

Enables extraction of isosurfaces from volumetric data (e.g., CT, MRI)

Produces polygon meshes suitable for rendering and ray tracing

Used for extracting isosurfaces from volumetric datasets (e.g., CT, MRI scans)

Generates polygon meshes that can be:

• Ray-traced for realistic rendering

• Displayed as rendered 3D models

Produces smoother results with increasing resolution of the input volume

Supports surface-based visualization of internal structures (e.g., anatomy, scientific data)

Enables real-time interaction with complex 3D surfaces when combined with acceleration techniques