In part one of this dissertation, we present a scheme for rendering higher-order isosurfaces. Animation and visualization of rectilinear data require interpolation schemes for smooth image generation. Piecewise trilinear interpolation, the de facto standard for interpolating rectilinear data, usually leads to significant visual artifacts in the resulting imagery. These artifacts reduce the fidelity of the resulting visualization, and may even lead to false interpretations of the data. This part is concerned with the generation of smooth isosurface image sequences, obtained by casting rays through the image plane and computing their intersections with an isosurface. We describe a novel solution to this problem: We replace trilinear interpolation by tricubic interpolation, smoothing out the artifacts in the images; and we simplify the ray-isosurface intersection calculations by rotating and resampling the original rectilinear data onto a second rectilinear grid- a grid with one family of grid planes parallel to the image plane. In part two of this dissertation, we discuss multiresolution techniques for hardware-accelerated, texture-based visualization of very large data sets. We discuss both volume visualization and cutting-planes techinques and how we have implemented them. In general, these methods use an adaptive scheme that renders the volume in a region-of-interest at a high resolution and the volume away from this region at progressively lower resolutions. The developed algorithm is based on the segmentation of texture space into an octree, where the leaves of the tree define the original data and the internal nodes define lower-resolution approximations. Rendering is done adaptively by selecting high-resolution cells close to a center of attention and low-resolution cells away from this area. We discuss four items particular to multiresolution volume visualization: (a) the special attention that must be paid to the transfer functions; (b) the proxy geometry; (c) indexed texture maps to allow for quick changes to the tranfer function; and (d) error evalutation in the context of index texture maps. We discuss a method for removing artifacts in multiresolution cutting planes.

Animation and visualization of rectilinear data require interpolation schemes for smooth image generation. Piecewise trilinear interpolation, the de facto standard for interpolating rectilinear data, usually leads to significant visual artifacts in the resulting imagery. These artifacts reduce the confidence in the resulting visualization, and may even lead to false interpretations of the data. This paper is concerned with the generation of smooth isosurface image sequences, obtained by casting rays through the image plane and computing their intersections with an isosurface. We describe a novel solution to this problem: We replace trilinear interpolation by tricubic interpolation, smoothing out the artifacts in the images; and we simplify the ray-isosurface intersection calculations by rotating and resampling the original rectilinear data in a second rectilinear grid -- a grid with one family of grid planes parallel to the image plane. Our solution significantly reduces artifacts in individual images and leads to smooth animations.

We present a multiresolution technique for interactive texture based rendering of arbitrarily oriented cutting planes for very large data sets. This method uses an adaptive scheme that renders the data along a cutting plane at different resolutions: higher resolution near the point-of-interest and lower resolution away from the point-of-interest. The algorithm is based on the segmentation of texture space into an octree, where the leaves of the tree define the original data and the internal nodes define lower-resolution versions. Rendering is done adaptively by selecting high-resolution versions. Rendering is done adaptively by selecting high-resolution cells close to a center of attention and low-resolution cells away from it. We limit the artifacts introduced by this method by blending between different levels of resolution to produce a smooth image. This techinique can be used to produce a viewpoint-dependent renderings.

We present a multiresolution technique for interactive texture- based volume visualization of very large data sets. This method uses an adaptive scheme that renders the volume in a region-of- interest at a high resolution and the volume away from this region at progressively lower resolutions. The algorithm is based on the segmentation of texture space into an octree, where the leaves of the tree define the original data and the internal nodes define lower-resolution versions. Rendering is done adaptively by selecting high-resolution cells close to a center of attention and low-resolution cells away from this area. We limit the artifacts introduced by this method by modifying the transfer functions in the lower-resolution data sets and utilizing spherical shells as a proxy geometry. It is possible to use this technique to produce viewpoint-dependent renderings of very large data sets.

Multiresolution texture-based volume visualization is an excellent technique to enable interactive rendering of massive data sets. Interactive manipulation of a transfer function is necessary for proper exploration of a data set. However, multiresolution techniques require assessing the accuracy of a resulting images, and re-computing the error after each change in a transfer function is very expensive. We extend our existing multiresolution volume visualization method by introducing a method for accelerating error calculations for multiresolution volume approximations. Computing the error for an approximation requires adding individual error terms. One error value must be computed once for each original voxel and its corresponding approximating voxel. For byte data, i.e., data sets where integer function values between 0 and 255 are given, we observe that the set of ''error pairs'' can be quite large, yet the set of unique error pairs is small. Instead of evaluating the error function for each original voxel, we construct a table of the unique combinations and the number of their occurrences. To evaluate the error, we add the products of the error function for each unique error pair and the frequency of each error pair. This approach dramatically reduces the amount of computation time involved and allows us to re-compute the error associated with a new transfer fucntion quickly.

Volume visualization of large data sets suffers from the same problem that many other visualization modalities suffer from: either one can visualize the entire data set and loose small details or visualize a small region and loose the context. In this paper, we present a magnification lens technique for volume visualization. While the notion of a magnification-lens is not new, and other techniques attempt to simulate the physical properties of a magnifying lens, our contribution is in developing a magnification lens that is fast, can be implemented using a fairly small software overhead, and has a natural, intuitive appearance. The issue with magnification lens is the border, or transition, region. The lens center and exterior have a constant zoom factor, and are simple to render. It is the border region that blends between the external and interior magnification, and has a nonconstant magnification. We use the perspectivecorrect textures capability, available in most current graphics systems, to produce a lens with a tessellated border region that approximates linear compression with respect to the radius of the magnification lens. We discuss how a cubic border can mitigate the discontinuities resulting from the use of a linear function, without significant performance loss. We discuss various issues concerning development of a three-dimensional magnification lens.

We present a method for efficient computation and storage of approximations of error tables used for error estimation between different time steps in time-varying datasets. The error between time steps is defined as the distance between the data of these time steps. Error tables are used to look up the error between different time steps of a time-varying dataset, their generation itself can be expensive. For n time steps, the exact error look-up table has a memory complexity and preprocessing time complexity of O(n^2). Our approximate error table approach uses trees, where leaf nodes represent original time steps, and interior nodes contain an approximation of the children nodes. The error computed on an edge of a tree describes the distance between the two nodes on that edge. Evaluating the error between two different time steps requires traversing a path between the two leaf nodes, accumulating the errors on the traversed edges. For n time steps, this scheme has a memory complexity and preprocessing time complexity of O(n log(n)), a significant improvement over the exact scheme. As we do not need to calculate all possible n^2 error terms, our approach is a fast way to generate the approximation.

We extend the notion of multiresolution spatial data approximation of static datasets to spatio-temporal approximation of time-varying datasets. By including a temporal component, we allow a region from one time-step to approximate a congruent region at another time-step. While approximations of static datasets are generated by refining the representation if a given error-bound is not met, for approximations of time-varying datasets we use data from another time-step, if that data meets a given error-bound for the current time-step. Thus, our technique exploits the fact that time-varying datasets typically do not change uniformly over time, and by only loading data from rapidly changing regions, much less data need be loaded to generate an approximation. Regions that don't change, or change slowly, are not loaded and are approximated by regions from another time-step. Prior techniques only permit binary classifications between consecutive time-steps. Our technique allows a run-time error-criterion between non-temporally consecutive time-steps. Error between time-steps is calculated in a pre-processing step and stored in error-tables. These error-tables are used to calculate error at run-time, so no data is touched. User movements in time are not restricted to unidirectional, successive changes - movement can be forward, backward, or to any arbitrary time-step.

We present a multiresolution technique for interactive texture based rendering of arbitrarily oriented cutting planes for very large data sets. This method uses an adaptive scheme that renders the data along a cutting plane at different resolutions: higher resolution near the point-of-interest and lower resolution away from the point-of-interest. The algorithm is based on the segmentation of texture space into an octree, where the leaves of the tree define the original data and the internal nodes dene lower-resolution versions. Rendering is done adaptively by selecting high-resolution cells close to a center of attention and low-resolution cells away from it. We limit the artifacts introduced by this method by blending between different levels of resolution to produce a smooth image. This technique can be used to produce viewpointdependent renderings.