STARview: A Multiresolution Time Series Data ... - Computer Science

STARview: A Multiresolution Time Series Data Visualizer Andrew Foulks∗ , R. Daniel Bergeron† , and John P. McHugh‡ ∗†

‡

Department of Computer Science Department of Mechanical Engineering

University of New Hampshire, Durham, NH, USA ABSTRACT We present an application case study for visualizing large data sets of time series spatial data. Our application is built on a flexible, object oriented framework that supports the visualization of dynamic internal wave propagation in the earth’s tropopause. Our data model uses a multiresolution hierarchy that integrates spatial and temporal components. The data also includes error information at each level of the hierarchy. The application provides the scientist with tools necessary to examine, query, and interact with visualizations of data of interest. Keywords: Fluid Flow Visualization, Uncertainty Visualization, Object Oriented Frameworks, Wavelets, Multiresolution Data

1. INTRODUCTION Data sets produced by simulation are becoming larger and more complex. Gaining insights from such data is becoming significantly more challenging. In order to understand the nature of the phenomena being studied, an environment is needed that helps the scientist to distill meaning from the vast amounts of data produced by these computational simulations. Fortunately, it is often the case that a scientist can work effectively with large scale low resolution overviews followed by interactive zooming to see smaller scale regions at higher resolutions. Multiresolution data hierarchies are ideal for supporting such multiscale browsing. A multiresolution hierarchy consists of many versions of the data to be studied at different resolutions. We are particularly interested in data sets composed of time series of spatial data such as is generated by computational fluid dynamics simulations. Such data can include many thousands of time steps of either 2D or 3D spatial data with many attributes at each point in the spatial domain. The data can be far too large to visualize at its original resolution in its entirety, but can often be effectively represented at coarser resolutions. The spatial data at each time step can be represented by both multiresolution and adaptive resolution hierarchies. In addition, the time series itself can be represented at different resolutions. We have developed an application that visualizes simulation data for dynamic wave propagation in the earth’s tropopause. The principal focus of this paper is to describe our application, built using our object oriented framework, that supports the visualization of multiresolution time series spatial data. We use Haar wavelets to generate the multiresolution data hierarchy, though, in principle, any multiresolution decomposition technique can be used. The data being visualized is 3000 two-dimensional time steps, each step containing 512x512 data points, for two attributes, each stored as a 32 bit floating point value. This represents 6GB of data, too much to fit into the memory of most modern workstations. A multiresolution representation is an effective way to deal with the size of the data. The scientist can view the data at the highest resolution that can fit into memory, or alternatively view a subset of the highest resolution data, since viewing the entire data set at full resolution would be impossible. This work is supported in part by the National Science Foundation under grants IIS-0082577 and IIS-9871859. ∗

[email protected] [email protected] ‡ [email protected] †

In our model the scientist views the data at low resolution (spatial or temporal), finds interesting phenomena, and “zooms in”, yielding a higher resolution view of a subset of the data. This represents a variant of focusplus-context techniques used in many information visualization applications. 1 Using this technique, we can keep the interesting data in memory at all times. Our application framework supports this approach by giving the application user the power to limit the amount of out-of-core data that will be loaded into memory for visualization purposes. Higher resolutions are available, but only when viewed as a subset in either space or time. We integrate an error model into the application so that visualizations are produced that help to guide the scientist to regions and features of interest. In order to effectively view a subset of the data at high resolution, we feel that one effective strategy to deal with the “missing” data values is to compute them as needed at run time. We use linear interpolation to compute the missing data values. Although linear interpolation does have limitations, it is quite acceptable for coarse resolution areas with low error measures. If the error is high, the user can zoom into a higher resolution representation.

2. PRIOR WORK 2

Doleisch et al. use a feature based approach and other techniques from information visualization to keep the amount of data that is presented to the user manageable. Our goals are similar since we also wish to reduce the amount of data that is presented to the user. Our approach is different in that we have concentrated on multiresolution techniques (in both space and time), and have built an application that demonstrates how our framework supports these techniques effectively. Silver and Wang3 describe visualization algorithms to handle time series computational fluid dynamics data sets. In their approach, they use feature tracking to improve user interaction and enhance the visualization of time series data sets. They do not, however, incorporate the notion of multiresolution into the organization of their data model. Haimes et al.4 developed Visual3, an interactive environment for the visualization of 3D vector scientific data. This program can handle both structured and unstructured grids, as well as scalar and vector data. One of the key aspects of the tool is a graphical user interface tailored specifically to allow the user efficient selection in 3D. Globus5 presents a software model to deal with very large data sets, separating the visualization tool into a data pipeline in which some of the data from earlier stages can be discarded (if not needed). While these techniques are valuable in the visualization process, the framework does not incorporate multiresolution hierarchies in either time or space. Other researchers have addressed the notion of combining temporal and spatial multiresolution data representations for specific applications such as dynamic polygon meshes6 as well as isosurface and direct volume rendering generation for time-varying fields.7–9 Some have tried representing vector fields hierarchically,10 storing error information during decomposition. Their data would fit well into our framework, because our approach is neither application-specific nor does it depend on a particular technique for creating the multiresolution hierarchy. Other object oriented rendering toolkits are available. VTK11 is an excellent toolkit for rendering both structured and unstructured data. The toolkit does not offer the user a graphical user interface. We felt that it would be beneficial to incorporate a graphical user interface in our software framework, but still allow the user to use VTK to do the rendering. Numerous commercial and public domain visualization systems provide extensive support for data manipulation and integration of visualization algorithms (CoVise, Amira, AVS, Explorer, DX and others). None of these provides any direct support for seamlessly integrating multiresolution spatio-temporal data in a manner that is essentially invisible to the rendering algorithms. Many of these systems do support the creation of user modules that could provide this functionality, so the approach we have developed could also be integrated into these systems.

3. SPACE TIME MULTIRESOLUTION HIERARCHIES Our data model integrates spatial and temporal multiresolution hierarchies. Each component of a data hierarchy can consist of either uniform or adaptive resolution data. We call such data Space Time Adaptive Resolution data, or STAR data. Our STAR data model serves as the foundation for a data manipulation tool that allows

a user to generate and access multiresolution data defined by arbitrary combinations of spatial and temporal decomposition. In this section we summarize briefly the principal aspects of our STAR data model and the STARlib library and STARgen program that can be used to generate and access arbitrary STAR data hierarchies.

3.1. Multiresolution spatial data decomposition There has been considerable recent research aimed at developing techniques and tools for representing large data sets at increasingly lower resolutions. Much of this research is aimed at terrain and surface representation 12 with the principal goals of balancing the space and computation costs with the error resulting from using the coarser representations compared to the original surface.13 Some of this research is particularly focused on minimizing the visualization error resulting from using the coarser representations, and thus incorporates viewing parameters as part of the data generation and/or data access strategies. These approaches generally examine data in a small neighborhood to determine whether the existing data points can be deleted or replaced without introducing too much error. Other researchers have developed techniques that apply to uniformly sampled or generated data in a uniform way. A particularly effective approach is to apply wavelet transformations to such data. 14, 15 A wavelet transformation is applied to the entire data set uniformly and results in a new summary data set that is 1/2 d the size of the original where d is the dimensionality of the data. The wavelet transformation also produces a detail component that can be used to estimate the error that results from using the summary data to represent the original.16 Decomposition techniques using wavelets lead to a natural multiresolution hierarchy in which the original (highest resolution) data is the root of the hierarchy and each successive child is the result of applying a wavelet transformation (or other uniform decomposition operation) to its parent. Others have used multiresolution techniques for data visualization. Guthe et al., Westermann, and others 17, 18 use multiresolution representations to achieve high performance volume rendering. Our research is similar in spirit, but we focus on distinguishing between spatial and temporal hierarchies and how they can be effectively integrated into a single software application. Finkelstein et al.19 use some interesting temporal multiresolution techniques, but they focus on video images, where we are more interested in scientific data.

3.2. Multiresolution temporal data decomposition Time series data sets can be very easily represented at multiple resolutions by simply deleting intermediate time steps from the series. This is normally done with output from computational fluid dynamics simulations which must perform the simulation at much higher resolutions than is typically needed for later visualization or analysis. It is common for a simulation to save the data associated with every 100 th or every 1000th time step. Given this saved data, however, it is still often useful to further reduce the time resolution for visualization purposes. At this stage it can be valuable to apply more intelligent data reduction techniques that take into consideration the error that results from removing a given time step, rather than just blindly picking every n th step. Using error as the decision factor results in an adaptive resolution time series where the time between time steps is not uniform. We can compensate for this at rendering time by generating intermediate frames via interpolation in order to maintain a constant animation speed. For some kinds of data, linear interpolation may not be correct. Our framework supports the use of any kind of interpolator. For this case study, however, linear interpolation is adequate because of the nature of the simulation data.

3.3. Multiresolution space time data decomposition Given a time series of spatial data, we perform a temporal data reduction by applying a one-dimensional time series data reduction for each spatial position. In other words, for each spatial position and for each attribute at that position, we create a 1D time series for the attribute and apply a wavelet transformation (or some other data reduction technique). All the resulting time series are recombined into a single time series of spatial data of the same dimensionality and size as the original. This process is depicted in Figure 1(a) which shows how the wavelet transformation generates time steps at new time step positions. This time shift is not very important except when data from different resolution levels are combined into an adaptive resolution time series.

Figure 1. (a) Temporal Multiresolution Data, (b) Space Time Multiresolution Data

3.4. Creating space time data hierarchies A time series of spatial data gives the scientist the ability to browse through different resolutions of the data based on time, space, or both. In principle, we could generate all possible combinations of spatial and temporal data resolution levels. A fully generated multiresolution spatial hierarchy for a two dimensional data set with 2 n x 2n data values has n components of sizes 2n x 2n , 2n−1 x 2n−1 , . . . , 1 x 1. A fully generated multiresolution time hierarchy of a time series with 2m time steps has m components of sizes m, m/2, . . ., 1. A fully generated space time multiresolution tree has fully generated multiresolution spatial hierarchies for each component of the temporal hierarchy. That is, given a 2m time series of 2n x 2n data, we can generate n spatial resolutions for each time step. For each spatial resolution, we can also take the corresponding 2m time steps and generate 2m−1 time steps at the next coarser temporal resolution. The process is depicted in Figure 1 (b). In principle, it is convenient to assume that all levels of a multiresolution space time hierarchy are available to a user. In practice, however, only a part of the hierarchy is actually needed at any time.

3.5. STAR Software Support We have developed a utility program that generates an arbitrary STAR data hierarchy and a public C++ class library that provides high level access to the data stored in the hierarchy. The STARgen program provides an interactive interface that allows a user to create an arbitrary STAR data hierarchy from an initial time series. The input time series can consist of any number of time steps of 2D or 3D spatial data of any size with any number of attributes. Given the initial data, the user can choose to generate a coarser resolution version based on either spatial or temporal decomposition using several different orthogonal wavelet transformations. In our application, we simply use Haar wavelets. For either or both of these new time series, the user can generate either a spatial or temporal resampling. This process can be repeated until the coarse data is represented by a single summary value. Our hierarchy starts at the native simulation resolution (512x512) and stops at 16x16 data. The generated STAR data hierarchy is organized in a file directory structure that can be determined by the user. By convention, each level of the hierarchy contains subdirectories named data and error. The data directory contains the time series at the current resolution and the error directory contains a parallel time series in which each data value is an estimate of the error at that point for that attribute. In this case, because a 2D Haar wavelet will produce 3 detail values for each summary value, we simply sum the absolute values of the three detail values to represent the composite error. In principle, the error can be represented in any fashion the user desires. Parallel to the data and error directories, we generate a new subdirectory for each child of the current resolution. Directory names are also user defined. By convention, we use the name to indicate the nature of the child resolution (spatial or temporal), and the size of the data (resolution).

Our STARlib class library provides the application program with a high level interface to a time series data object. The TimeSeries class is the only class in the library that the application must know about. This class encapsulates the key characteristics of the time series, hiding the implementation from the programmer.

4. MOTIVATION AND GOALS Having been convinced of the numerous advantages of using multiresolution hierarchies to deal with large data sets, we set out to build an application that could demonstrate these advantages. There are four key goals in the construction of this tool. 1. Application. We set out to build an application that would demonstrate effective techniques for dealing with very large data sets. We want to show that one way to deal with these large sets is to store fewer data values and compute the missing ones during rendering. To help us put together the application, we have formed a collaboration with our peers in the Mechanical Engineering department. Our visualization system incorporates their dynamic atmospheric fluid flow data. 2. Object Oriented Framework. To build solid software, we want to create a flexible object oriented system, in which new objects can be added to one part of the system with little or no knowledge of the other parts of the system, and renderers can be loaded dynamically into a running program. In addition, we hope to incorporate as many existing libraries as we can, so that renderers can be added “out of the box”. The framework must also support the ability to run multiple renderers simultaneously, all using the same source of data, if desired. 3. Multiresolution Data Model. We want to integrate the notion of multiresolution hierarchies, time series data sets, error representation, and temporal adaptive resolution compression into the framework of the tool itself. In this way, we can shield the renderer writer from these notions, and from interactive changes in the resolution of the data. Since many rendering algorithms use data that is defined on a uniform grid, we transform adaptive resolution or non-uniform data to a uniform mesh to simplify the renderer’s task. 4. Data Browser. We wish to provide the user with a means of browsing for sources of data, and dynamically attaching these data sources to an already running renderer. Our abstract concept of browsing for data includes (1) the ability to search for data on both a remote server as well as the local disk, (2) the ability to change resolutions on demand, and (3) the ability to zoom in to regions of interest at higher resolutions.

5. STARVIEW FRAMEWORK 5.1. Overview STARview is a C++ application designed to provide visualizations of time series data existing in an adaptive multiresolution hierarchy. The architecture of STARview consists of four primary subsystems built on top of two visualization libraries and a graphical user interface library, as shown in Figure 2. Each subsystem is represented by a “manager” class. The Controller subsystem is responsible for mediating and dispatching messages to and from objects in the other subsystems. The Rendering subsystem is responsible for the visualizations, whether they are written in OpenGL or use another library such as VTK.

5.2. DataSource Subsystem The DataSource subsystem contains the classes needed to interpret, filter, and specify the structure of raw data. The DataSourceManager class is responsible for loading data at the request of the user and maintaining a list of all data sources available. The DataSourceManager is also responsible for allowing the user to change resolutions on a particular dataset attached to a particular renderer, and notify the renderer of the change. Conceptually, data can be either local or remote. In our system, the class RemoteDataSource inherits the API of a DataSource, but hides the fact that the data is stored on a remote server. We use standard TCP/IP sockets to send and receive data over the network.

Rendering DataSource VTK OpenGL

Controller

UserInterface Qt

Figure 2. STARview Architecture

In our application, we have used uniform data for demonstration purposes. However, our DataSource subsystem can handle both uniform as well as non-uniform data using an adaptive resolution data source, which presents the user with an interface that suggests that the data is uniform, but internally is non-uniform. For this case study, we render uniform data since the output of the numerical simulation is uniform data on a 512x512 grid.

5.3. Data Organization STARview understands the notion that any given piece of data can be decomposed from its “native” resolution into a hierarchy of successively lower resolutions in both space and time. This is our data hierarchy generated by the STARgen utility. DataSource objects automatically know how to deal with STAR data hierarchies and the UserInterface contains a multiresolution navigation widget. Since our framework is general, it does not matter how the multiresolution hierarchy is generated, nor even the algorithms used. STARview includes an interface that allows the user to dynamically switch resolutions for a given multiresolution hierarchy. The data may be viewed either at lower spatial resolution (in which each file in the time series has 1/2d the size of the next highest resolution), or at lower temporal resolution (in which each time step retains its size compared to the next higher resolution, but there are half as many time steps in the series). This combination of both spatial and time based multiresolution representations constitutes one of the unique features of our environment.

5.4. Error Model Our error model is incorporated directly into our data model. Error is viewed as simply another kind of data. The error can be visualized simultaneously with the data, giving the user a representation of the authenticity of the data being visualized. Lower resolution data usually shows higher error.

5.5. Object Oriented Framework Our STAR framework makes it easy for the user of the system to add renderers. After subclassing Renderer, one only has to reimplement 5 methods. Access to the RenderInteractorInterface gives the user the ability to display widgets for the rendering application without having to understand the implementation details of the graphical user interface library. By reimplementing one method, the renderer writer can easily deal with any multiresolution DataSource that a scientist is interested in rendering. Data can be retrieved from the data source with only a couple of lines of code, and can be accessed as Blocks or as individual elements. The renderer writer need not worry about details concerning the structure of the data, which are concealed by the DataSource subsystem. The interface to this subsystem presents the user with a uniform interface to the data. The implementation of that interface may in fact represent non-uniform or adaptive data. By shielding the renderer writer, we help make it easier to get to the “interesting” tasks – creating visualizations.

Our framework also helps the renderer writer because of its built-in support for multiresolution representations. The multiresolution nature of the data is concealed from the renderer writer, who only must be notified when the user switches resolutions. When this happens, the system automatically changes the renderer’s reference from the current data source to point to the data at the new resolution.

6. APPLICATION CASE STUDY As part of our case study, we have implemented and incorporated several renderers into our framework. The first is a dynamic vector field particle tracer written in OpenGL. The other renderers treat the time series data as slices in a 3D volume – one is an isosurface renderer, and the other is a direct volume renderer. These use VTK renderers to visualize pressure data output from the numerical simulation. The volume renderings did not yield satisfactory insights from this particular data set. However, we feel the value of providing a framework in which renderers can easily be integrated from other toolkits enhances the value of our application. For the remainder of the paper, we focus on the flow rendering visualizations.

6.1. Simulations of Atmospheric Waves The data being visualized is taken from a numerical simulation of atmospheric internal waves. The atmosphere is a stratified medium that can support wave activity. Observations of the atmospheric motion often indicate significant wave activity, which is responsible for turbulence and other phenomena. The numerical simulations that are performed here are solutions to the anelastic equations, which is an approximation of the Navier-Stokes equations that govern fluid flow. The anelastic equations assume incompressible flow, but at the same time allow the density to vary with position, and account for adiabatic expansion and compression of air without allowing sound waves to exist. The suppression of sound waves avoids serious restriction of the time step in the computation. The numerical method reduces the equations to a simpler set of equations in terms of the vertical component of velocity and vertical vorticity. The vertical velocity and vorticity fields are then expanded in a Fourier series for horizontal directions, and a series of Langrange interpolants for the vertical direction. The Lagrange interpolants are collocated on the Chebyshev-Gauss-Lobatto points. The equations are integrated in time using the AdamsBashforth method for nonlinear terms, and the Crank-Nicolsen method for linear terms. (See 20, 21 for more information.) Waves are forced in the simulations by imposing vertical velocity at the bottom of the domain. This velocity is forced to oscillate with a chosen temporal and horizontal frequency, which is then maintained for the duration of the simulations. Waves propagate away from the bottom boundary, retaining the imposed frequency and horizontal wavenumber, but choosing a vertical wavenumber so that mass and momentum are conserved. The wave amplitude grows exponentially with altitude as the air density decreases with altitude. Finally, the wave amplitude becomes so large that nonlinear phenomena dominate the dynamics. Many different effects can result, such as wave breaking, where heavy fluid is above lighter fluid, resulting in overturning. The present simulations consider a two dimensional case with a constant Brunt-Vaisala frequency, which means that density decreases exponentially with a constant exponent. During the simulation, temperature, vorticity, and two dimensional velocity data (u and v vector directions) were recorded at every simulation time step until the 3000th time step had been saved. Each time slice consists of a 512x512 uniform grid of 32 bit floating point values (with a time slice for each attribute). The total size of the data for this simulation is 12GB, although we only use 6GB (u and v velocity) for our visualizations.

6.2. STARview Application We used our framework to implement a rendering application for two-dimensional unsteady flow visualization as shown in Figure 3. The visualization application supports a STARdata multiresolution hierarchy generated from the simulation defined above. The root of the hierarchy is the initial data saved from the simulation. If every time step is saved, we say that the data is stored with a time step increment of 1. The application determines from the data what the actual time step increment is, but the user can modify that value interactively. For example, if the simulation only saved every 10th time step, the default rendering generates a new frame for

Figure 3. Velocity Field Flow Rendering at (a) 512x512, (b) 256x256 (showing error)

every 10th time step. If the user changes the time step increment to 5 (for example), the renderer will generate interpolated time steps from the available data. This means that it is possible for the user to request that the renderer display images from time steps that were not produced directly via simulation. The “missing” time steps can be cached in memory by the DataSource, if the memory is available. Since memory is scarce for large data sets, we compute individual data points as necessary but do not store the result. We also use interpolated time steps to accommodate temporal adaptive resolution data sources into the renderings. In an adaptive resolution time series, we do not keep time slices in which the data does not “significantly change”. The amount of change that we wish to define as significant is represented by a tolerance factor δ. The final time series may, therefore, have many missing slices. During rendering, this adaptively compressed series is expanded into a uniform time series via interpolation. Since the time slices that were removed from the series did not have much change in them, the newly interpolated slices should, in principle, represent a fairly good approximation of the original data, whose accuracy depends only on the tolerance value δ. For example, δ could represent the maximum error of any individual value that would occur by interpolating to recreate the slice. The STARview application includes a file dialog (shown on the left side of the screen shot in Figure 3(a)) that allows a user to browse through the multiresolution hierarchy to select a desired node for rendering. The user also specifies the number of particles to take part in the rendering. The particles are placed randomly on a 2D continuous viewport. Because multiresolution navigation is built into the application, the size of the data may vary during rendering. Therefore, the location of the particles are normalized and rendered in a continuous space from [0,1] on both the x and y axes. After the particles are placed randomly in the 2D space, the nearest grid points are retrieved from the data source and the particle’s vector (magnitude and direction) is interpolated from the four closest data points using bi-linear interpolation. A number of line segments are generated along the path the particle takes. The total number of line segments drawn for each pathline is determined by the user interactively. The number of segments in the pathline is kept constant during the rendering by dropping the first segment of the pathline and adding a new segment to the end, causing it to move across the screen in the flow direction. The particle lives for a random amount of time, after which it and its pathline are removed from the visualization. Once a particle dies, a new particle comes into existence at a random position, keeping the total number of

particles constant. In our application we use an animated dynamic flow rendering to visualize the simulation data. For an unsteady rendering, the entire time series of data slices is needed to produce the visualization. However, it is usually the case that not all of the data will fit into memory. In our application, the user can limit the temporal resolution so that the data will always remain in the user specified memory limit. If the user requests a resolution that will not fit into memory, then a subset of the data may be viewed at a reduced temporal resolution, such that the total number of time steps will fit into memory. The user can also switch to lower spatial resolutions if performance is inadequate. Our visualization reveals both the movement of particles as well as the sources and sinks of the flow field. The sinks, or the wave nodes, are inflection points at which particles experience little or no motion. The lines that develop in the image are lines of constant phase at wave nodes, where the velocity remains near zero. These lines move with the wave speed rather than the local velocity, as can be seen in the dynamic renderings. The lines of constant phase in the high resolution case (Figure 3) show that the they are fairly well defined. The same line at the lowest resolution (Figure 5), however, looks dispersed and somewhat weaker. These differences are only somewhat noticeable as the resolution increases (Figure 4).

6.3. Authenticity Visualization

Figure 4. Velocity Data at resolution (a) 128x128, (b) 64x64

Including error in the multiresolution visualizations of the data can help the scientist to understand the authenticity of the visualization at different resolutions. There is some recent research aimed at addressing the problem of uncertainty visualization (for example, see Shen et al.22 and others23–25 ). In this application, we simply use a technique that maps error to color. Greens indicate low relative error, and reds highlight areas of high uncertainty. We need to identify a maximum error value in order to define the range of error values that map to the range of available colors. If we are visualizing a single resolution level, it might make sense to use the maximum error of that resolution as the maximum error color. Such a local mapping allows the user to identify areas of the data that are least reliable at that level, but it is difficult to compare error visualizations at different resolutions. Consequently, it is also useful to provide a single global mapping that is consistent across all resolutions. The

system supports both mappings and the user can set the global maximum error to be a constant or any one of the local maximum error values. For all the images shown here, we have defined the global error to be the maximum error of the highest resolution decomposition. This choice overemphasizes the error at lower resolutions, but makes the error easier to see. Our error visualization technique is demonstrated in Figures 4 and 5, which show lower resolution versions of the data presented in Figure 3 at the same simulation time step. For our steady state visualization algorithm running with this particular data set, it is challenging to see the differences between Figure 3 (256x256) and the next three lower resolutions (Figure 4 (128x128) and (64x64), and Figure 5(a) (32x32)). Only when looking at the lowest resolution, 16x16 (Figure 5(b)), do differences become obvious. Using color to show uncertainty in the data (relative to the high resolution data), reveals striking differences among different resolutions. In particular, Figure 5 shows that the error is highest (showing the most red color) along the wavefronts, which have visibly lost cohesion. In Figure 4 we can see that there is very little high (red) uncertainty along the wavefronts. While viewing data at lower resolutions, it is important to be able to identify regions of high uncertainty easily. These images support the idea of combining the data and the error in both the model as well as the example implementation. The lower resolution images can thus provide valuable insights for the scientist despite the loss of information.

Figure 5. Velocity Data at resolution (a) 32x32, (b) 16x16

6.4. Discussion The manner in which our application deals with very large data sets shows promise. When the data is too large to fit into memory, the user can limit the amount of memory devoted to the data storage. It is often the case, however, that the scientist is interested in viewing the highest resolution possible despite the memory limitations. To accommodate these contradictory needs, we store a limited number of time slices, and use interpolation to get data from the “missing” slices. Table 1 shows that we can achieve interactive renderings at the highest resolution using these techniques. Our visualizations are being run on a modest machine (Pentium III 750MHz, with 1GB memory). We first ran the application loading the full data set at highest resolution (6GB), but, as expected, we could not even get an image, and our machine locked up. However, by viewing a subset of the available time slices, we were able to achieve interactive frame rates, interpolating the missing data values during

the rendering. In our second run we limited memory usage to 650MB (leaving 350MB for the OS). This represents approximately 300 of the 3000 time slices. In all runs we used 1000 particles. The resulting visualization shows interactive, smoothly rendered dynamic images. In these cases, computation is cheaper than storage. A problem that our model must address concerns the accuracy of the computed data. Is the interpolated data accurate enough to be useful to the scientist? Our adaptive resolution time series data model, combined with our error model, help to solve this problem. An adaptive resolution time series does not store slices in which the maximum error value of one slice does not significantly differ from the adjacent slices. This error tolerance δ is user defined, and represents what the scientist is willing to tolerate in terms of data loss. Since the time slices that are not stored are not significantly different from the ones that are stored, it is reasonable to conclude that computing the missing values (either via interpolation or another method appropriate for the data being visualized) will give acceptable results. The visualization of error represents an important aid to the scientist who is aware of the adaptive resolution time series data model and wishes to understand the authenticity of the visualization. The benefit, of course, is that large data sets that might only be visualized on very large, very expensive mainframes, or perhaps may not be rendered on any existing hardware, might instead be viewed on common off the shelf hardware using our techniques. Data Size 512x512x3000 512x512x3000 256x256x3000x2 256x256x3000x2 128x128x3000x2 64x64x3000x2

Show Error? N N Y Y Y Y

Memory Used for Data Storage No Limit 650MB Limit No Limit 750MB Limit No Limit No Limit

Average Frame Rate ∅ 14 fps ∅ 10 fps 12 fps 30 fps

7. CONCLUSIONS AND FUTURE WORK The principle goal of our research was to show that combining space and time multiresolution decomposition in a unified application is useful for interactively visualizing large flow field data sets that are too large to fit into memory. We are able to achieve interactive visualizations of very large data sets by using computation to create data values at run time. The use of adaptive resolution data and error representations reduce the danger of misinterpretations caused by interpolation error. To create the application, we have developed an object oriented framework to implement a visualizer that renders vector flow data from numerical simulations. The application allows a user to easily view and interact with 2D dynamic flow renderings and 3D volume renderings of multiresolution data compressed in time and space using wavelets. Our visualization framework supports interactive browsing through arbitrary multiresolution data hierarchies that incorporate both spatial and temporal decompositions, and error representations. A major goal of the framework is to minimize the difficulty in creating renderers that interface to the framework. In particular, a renderer can be developed that does not need to understand the nature of the multiresolution data hierarchies, and does not need to implement complicated user interaction widgets. The renderer only needs to know how to render a uniform resolution 2D or 3D data set. The framework is completely responsible for interacting with the user to identify the data to be rendered, extracting the appropriate data from the multiresolution hierarchy, transforming that data into a uniform resolution format and successively invoking the renderer to generate frames of the visualization. The framework is integrated with both OpenGL as well as VTK, providing the scientist a powerful base of code on which to build and tailor visualization applications for specific types of data. We have successfully integrated VTK volume renderers into our application. We feel that this tool provides us with a solid foundation for producing more sophisticated renderers with more sophisticated techniques for handling multiresolution data, especially adaptive resolution spatial data. Of key interest is exploring other models of data computation that may help the scientist to visualize data sets too large to fit into memory. We feel that our model extends naturally to three dimensions, and we have begun developing support for 3D rendering of dynamic numerical simulation data.

REFERENCES 1. S. K. Card, J. D. Mackinlay, and B. Shneiderman, “Focus + context,” pp. 306–309, 1999. 2. H. Doleisch, M. Gasser, and H. Hauser, “Interactive feature specification for focus+context visualization of complex simulation data,” in Proceedings of the symposium on Data visualisation 2003, pp. 239–248, Eurographics Association, 2003. 3. D. Silver and X. Wang, “Visualizing evolving scalar phenomena,” Future Generation Computer Systems 15(1), pp. 99–108, 1999. 4. R. Haimes and D. Darmofal, “Visualization in computational fluid dynamics: A case study,” in Visualization ’91, pp. 392–397, 1991. 5. A. Globus, “A Software Model for Visualization of Large Unsteady 3-D CFD Results,” tech. rep., NASA, 92. 6. A. Shamir and V. Pascucci, “Temporal and spatial level of details for dynamic meshes,” in Proc. ACM Symposium on Virtual Reality Software and Technology, pp. 77–84, ACM Press, 2001. 7. H.-W. Shen, “Isosurface extraction in time-varying fields using a temporal hierarchical index tree,” in Proceedings IEEE Visualization ’98, pp. 159–166, IEEE Computer Society Press, 1998. 8. P. Sutton and C. D. Hansen, “Isosurface extraction in time-varying fields using a temporal branch-on-need tree (t-bon),” in Proceedings IEEE Visualization ’99, pp. 147–154, IEEE Computer Society Press, 1999. 9. H.-W. Shen, L.-J. Chiang, and K.-L. Ma, “A fast volume rendering algorithm for time-varying fields using a time-space partitioning (TSP) tree,” in Proc. IEEE Visualization ’99, pp. 371–378, 1999. 10. B. Heckel, G. H. Weber, B. Hamann, and K. I. Joy, “Construction of vector field hierarchies,” in IEEE Visualization ’99, D. Ebert, M. Gross, and B. Hamann, eds., pp. 19–26, (San Francisco), 1999. 11. W. Schroeder, K. Martin, and B. Lorensen, The Visualization Toolkit, Prentice Hall, Upper Saddle River, NJ, 1998. 12. M. Garland, “Multresolution modeling: Survey and future opportunities,” Eurographics 99, State of the Art Report , pp. 111–131, September 1999. 13. P. Cignoni, C. Rocchini, and R. Scopigno, “Metro: Measuring error on simplified surfaces,” Computer Graphics Forum 17, pp. 167–174, June 1998. 14. I. Daubechies, Ten Lectures on Wavelets, SIAM, Philadelphia, Pennsylvania, 1992. 15. S. G. Mallat, “A theory for multiresolution signal decomposition: The wavelet representation,” IEEE Transactions on Pattern Analysis and Machine Intelligence 11, pp. 674–693, July 1989. 16. P. C. Wong and R. D. Bergeron, “Authenticity analysis of wavelet approximations in visualization,” in Proceedings of IEEE Visualization ’95, G. M. Nielson and D. Silver, eds., pp. 184–191, IEEE Computer Society Press, (Los Alamitos, California), October 1995. 17. S. Guthe, M. Wand, J. Gonser, and W. Straer, “Interactive rendering of large volume data sets,” in Proceedings IEEE Visualization 2002, pp. 53–60, IEEE Computer Society Press, 2002. 18. R. Westermann, “A multiresolution framework for volume rendering,” in 1994 Symposium on Volume Visualization, A. Kaufman and W. Krueger, eds., pp. 51–58, 1994. 19. A. Finkelstein, C. E. Jacobs, and D. H. Salesin, “Multiresolution video,” Computer Graphics 30(Annual Conference Series), pp. 281–290, 1996. 20. J. S. Turner, Buoyancy effects in fluids, Cambridge, 1979. 21. C. Canuto, Y. Hussaini, A. Quarteroni, and T. Zang, Spectral methods in fluid dynamics, Springer-Verlag, 1987. 22. Q. Shen, A. Pang, and S. Uselton, “Data level comparison of wind tunnel and computational fluid data dynamics data,” in IEEE Visualization ’98, pp. 415–418, 1998. 23. S. K. Lodha, A. Pang, R. E. Sheehan, and C. M. Wittenbrink, “Uflow: Visualizing uncertainty in fluid flow,” in IEEE Proceedings of the Conference on Visualization, pp. 249–254, (Los Alamitos), 1996. 24. A. Pang and J. Furman, “Data quality issues in visualization,” in SPIE Proceedings on Visual Data Exploration and Analysis, 2178, pp. 12–23, (Los Alamitos), 1994. 25. C. M. Wittenbrink, A. T. Pang, and S. K. Lodha, “Glyphs for visualizing uncertainty in vector fields,” IEEE Transactions on Visualization and Computer Graphics 2, pp. 266–279, September 1996.