Interactive Progressive Arbitrary Slicing of Volumetric Data

Exploration and visualization of large volumetric data sets is a challenging problem that arises when analyzing results from simulation or scanning procedures. Often, the data is stored on a three-dimensional rectilinear grid like, for example, (bio-) medical imaging data or numerically simulated time-dependent hydrodynamics data. A powerful tool for visualization of three-dimensional data is a slicer that renders planes, which cut the volumetric data domain in arbitrary direction. The position and orientation of the cutting plane can be modified interactively to explore the whole data set.
We developed a progressive arbitrary slicing tool that is capable of visualizing cutting planes through large-scale volumetric data sets with interactive frame rates. To achieve interactivity, the algorithms are based on a three-dimensional hierarchical data representation. Exploiting the hierarchy, a progressive visualization tool starts with displaying an arbitrary slice at a coarsest resolution and refines the resolution when more data is available. Since we are dealing with large-scale data that does not fit into the main memory, out-of-core techniques have to be applied and the data loading from external storage media becomes the main bottle neck in terms of
computation time.
Out-of-core computations require a redesign of the data storage scheme to enable fast data access. Reordering the data according to a three-dimensional Lebesgue-space-filling-curve scheme can speed up data traversal. The z-order of the space-filling curve ensures spatial locality of data on disk. Since we want to render slices progressively, we use a hierarchy of space-filling curves.
An additional major speed-up can be achieved by using distributed computing, i.e., by running the algorithms in parallel on a low-cost Linux PC cluster. Considering the original data to be stored on some data servers and the slices to be rendered by one or multiple image-generating servers, called view servers, we use a homogeneous cluster of PCs to get the data from the data servers, explore the data, extract the desired portion of a slice, and send the relevant data to the view servers. The view and data servers are embedded into a client/server-architecture.
To exploit computational resources as much as possible, all the computers of the cluster should be kept equally busy, i.e., a request should be split up among and distributed to all available computers such that all of them finish their computations in about the same amount of time. To ensure this, we use a simple and fast load-balancing scheme for homogeneous clusters.