Presenter: Martin Kraus, Purdue University

Abstract:

Interactive volume rendering has always been one of the most challenging techniques in computer graphics; therefore, algorithms suited for a hardware-accelerated implementation have been and still are of particular interest. For example, the linear interpolation provided by triangle rasterization is exploited by the Shirley-Tuchman cell projection and hardware-accelerated texture mapping is exploited by texture-based volume rendering.

Today, programmable graphics hardware is available that allows us to implement much more complex algorithms on the graphics hardware, thus removing the bottleneck of the communication between the graphics hardware and the CPU. Moreover, modern graphics hardware offers a high degree of parallelism that makes it particular suited for certain algorithms. For example, an efficient parallel implementation of the visibility sorting required for cell projection is rather difficult to achieve. In contrast, the fragments of slices for texture-based volume rendering are processed independently; therefore, this technique benefits directly from the parallelism of graphics hardware.

Ray casting is an efficient volume rendering technique, which is particular well suited for parallel implementations since the rays are processed independently. However, the basic algorithm requires certain optimizations (e.g., early ray termination, empty space skipping, adaptive step length, etc.) in order to work efficiently. Unfortunately, hardware-based implementations of these optimizations are usually impossible. (In fact, texture-based volume rendering may be thought of as a very simple ray casting algorithm with constant step length, no empty space skipping, and no early ray termination.) Therefore, ray casting in volume rendering was restricted to software-based, non-interactive implementations in the past. This situation, however, has dramatically changed recently.

Modern programmable graphics hardware does allow us to implement many of the most important ray casting optimizations, in particular early ray termination, empty space skipping, and adaptive step length. It also allows us to employ improved ray integration schemes, e.g., pre-integrated classification. Moreover, ray casting on programmable graphics hardware is not restricted to uniform grids but may also be applied to unstructured meshes, e.g., tetrahedral meshes.

My talk will summarize three approaches to the implementation of ray casting on programmable graphics hardware, published in [1], [2], and [3]. The common concept is to trace all rays in parallel by rasterizing many screen-filling polygons. Several optimization techniques are implemented in very similar ways, e.g., early ray termination by early depth tests, while other techniques are implemented differently, e.g., the computation of the step length. Furthermore, ray casting in tetrahedral meshes offers several additional challenges, e.g., non-convex mesh boundaries and non-trivial mesh topology.

Not only is ray casting on programmable graphics hardware an interesting way of exploiting the parallel architecture of modern graphics hardware; but the almost simultaneous publication of the discussed implementations also indicates that the programmability of graphics hardware has reached a critical level, which allows us to implement many more parallel algorithms on modern graphics hardware.

[1] Stefan Roettger, Stefan Guthe, Daniel Weiskopf, Thomas Ertl, and Wolfgang Strasser. "Smart Volume Rendering". In Proceedings of Symposium on Visualization VisSym 2003, pages 231-238, 2003.

[2] Jens Krueger and Ruediger Westermann, "Acceleration Techniques for GPU-based Volume Rendering." In Proceedings of Visualization 2003.

[3] Manfred Weiler, Martin Kraus, Markus Merz, and Thomas Ertl. "Hardware-Based Ray Casting for Tetrahedral Meshes." In Proceedings of Visualization 2003.