Fourier Volume Rendering on the GPU

Using a Split-Stream-FFT

Thomas Jansen, Bartosz von Rymon-Lipinski, Nils Hanssen, Erwin Keeve

Research center caesar

Surgical Systems Lab

 

Источник: http://www.cta.ru/cms/f/366642.pdf

 

 

Abstract

 

The Fourier volume rendering technique operates in the frequency domain and creates line integral projections of a 3D scalar field. These projections can be efficiently generated in ) log O( 2 N N time by utilizing the Fourier Slice-Projection theorem. However, until now, the mathematical difficulty of the Fast Fourier Transform prevented acceleration by graphics hardware and therefore limited a wider use of this visualization technique in state-of-theart applications. In this paper we describe how to utilize current commodity graphics hardware to perform Fourier volume rendering directly on the GPU. We present a novel implementation of the Fast Fourier Transform: This Split-Stream-FFT maps the recursive structure of the FFT to the GPU in an efficient way. Additionally, highquality resampling within the frequency domain is

discussed. Our implementation visualizes large volumetric data set in interactive frame rates on a mid-range computer system.

 

1 Introduction

 

Most volume rendering techniques fall into one of two classes:

·          In the screen-space approach, a ray is cast for each pixel on the screen, with uniform sampling and composition of the volumetric data along the ray, e.g. Raycasting and Shear-Warp.

·          In the object-space approach, the volume is traversed either back-to-front or front-toback, blending each scalar into the projection plane, e.g. 3D texture mapping and Splatting.

It can be seen, that both approaches operate in the spatial domain and somehow have complexity ) O( 3 N for a volume of size 3 N , as each voxel needs to be visited.

Instead of working in the spatial domain, Fourier Volume Rendering (FVR) is based on the frequency spectrum of the 3D scalar field by utilizing the Fourier Slice-Projection theorem. This theorem allows us to compute integrals over volumes by extracting slices from the frequency domain representation.

In detail, FVR generates line integral projections of a set of 3 N scalars – using the inverse 2D Fast Fourier Transform (FFT) – with complexity ) log O( 2 N N . The application of the Fourier Projection-Slice theorem to image synthesis has been independently proposed by Dunne and Malzbender. An application to MR angiography is described by Napel. Solutions for depth cueing and illumination where proposed by Totsuka and Levoy. Additionally, frequency domain based algorithms, using the wavelet transform were presented by Westenberg and Gross.

However, even the most recent implementations of FVR are realized on the CPU only. In contrast, most spatial domain volume rendering algorithms make use of current graphics hardware features, such as programmability. This leads to faster implementations, even for a worse computational complexity. The mathematical structure of FVR – especially the use of the FFT – has prevented its adaptation to modern graphics hardware.

Such hardware, also known as the Graphics Processing Unit (GPU), nowadays implements a stream architecture, which uses a kernel to operate on one or multiple input streams to produce one or

multiple output streams. Using this paradigm, it became popular to use the GPU for problems it was not designed for, e.g. to compute Voronoi diagrams, generate interactive caustics, or simulate crystal growth.

The mathematical obstacle of FVR is the inverse FFT that transforms scalar values from the frequency spectrum to the spatial domain. The adaptation of the recursive structure of the FFT to the GPU is likely to be the major difficulty of the full FVR pipeline. Moreland et al. proposed a FFT implementation, however, the algorithm does not make efficient use of the graphics hardware and a special texture format is used, which might be useful for image processing but is not applicable for the FVR approach.

In this paper we describe how to take advantage of the features of commodity graphics hardware to realize FVR. As a major part, this includes a novel implementation of the FFT on the GPU: The Split-Stream-FFT was designed to efficiently map the recursive structure of the FFT to the stream architecture of a GPU. This leads to superior speed performance for DSP applications in general, and to the FVR in special. In addition, we deal with resampling in the frequency domain, which is essential to accomplish proper image quality.