|
Home
Up
REGISTER ONLINE
Author Information
Dates
Organizers
IEEE Visualization
| |
Monday October 22, 2001
8:45 WELCOME & KEYNOTE ADDRESS
Visualization Challenges for a New Cyberpharmaceutical
Computing
Paradigm
Russell J. Turner, Kabir Chaturvedi, Nathan J. Edwards, Daniel Fasulo, Aaron L.
Halpern, Daniel H. Huson, Oliver Kohlbacher, Jason R. Miller, Kmut Reinert, Karin A.
Remington, Russel Schwartz, Brian Walenz, Shibu Yooseph and Sorin Istrail
Celera Genomics Corporation, USA
In recent years, an explosion in data has been profoundly changing
the field of biology and creating the need for new areas of expertise, particularly in the
handling of data. One vital area that has so far received insufficient attention is
how to communicate the large quantities of diverse and complex information that is being
generated. Celera has encountered a number of visualization problems in the course
of developing tools for bioinformatics research, applying them to our data generation
efforts, and making that data available to our customers. This paper presents
several examples from Celera's experience. In the area of genomics, challenging
visualization problems have come up in assembling genomes, studying variations between
individuals, and comparing different genomes to one another. The emerging area of
proteomics has created new visualization challenges in interpreting protein expression
data, studying protein regulatory networks, and examining protein structure. These
examplies illustrate how the field of bioinformatics is posing new challenges concerning
the communication of data that are often very different from those that have heretofore
dominated scientific computing. Addressing the level of detail, the degree of
complexity, and the interdisciplinary barriers that characterize bioinformatic problems
can be expected to be a sizable but rewarding task for the field of scientific
visualization.
9:45 COFFEE BREAK
10:15 SURFACES
AND PARALLEL RENDERING
Delaunay based shape reconstruction from large data
Tamal K. Dey, Joachim Giesen and James Hudson
The Ohio State University, USA
Surface reconstruction provides a powerful paradigm for modeling shapes from
samples. For point cloud data with only geometric coordinates as input, Delaunay
based surface reconstruction algorithms have been shown to be quite effective both in
theory and practice. However, a major complaint against Delaunay based methods is
that they are slow and cannot handle large data. We extend our COCONE algorithm to
handle supersize data. This is the first reported Delaunay based surface
reconstruction algorithm that can handle data containing more than
a million sample points on a modest machine.
Parallel point reprojection
Erik Reinhard, Peter Shirley and Charles Hansen
University of Utah, USA
Improvements in hardware have recently made interactive ray tracing
practical for some applications. However, when the scene complexity or rendering
algorithm cost is high, the frame rate is too low in practice. Researchers have
attempted to solve this problem by cacheing results from ray tracing and using these
results in multiple frames via reprojection. However, the reprojection can become
too slow when the number of samples that are reused is high, so previous systems have been
limited to small images or a sparse set of computed pixels. To overcome this problem
we introduce techniques to perform this reprojection in a scalable
fashion on multiple processors.
Parallel rendering with K-way replication
Rudrajit Samanta, Thomas Funkhauser and Kai Li
Princeton University, USA
With the recent advances in commodity graphics hardware performance,
PC clusters have become an attractive alternative to traditional high-end graphics
workstations. The main challenge is to develop parallel rendering algorithms that
work well within the memory constraints and communication limitations of a networked
cluster. Previous systems have required the entire 3D scene to be replicated in
memory on every PC. While this approach can take advantage of view-dependent load
balancing algorithms and thus largely avoid the problems of inter-process communication,
it limits the scalability of the system to the memory capacity of a single PC. We
present a k-way replication approach in which each 3D primitive of a large scene is
replicated on k out of n PCs (k<<n). The key idea is to support 3D models
larger than the memory capacity of any single PC, while retaining the reduced
communication overheads of dynamic view-dependent partitioning. In this paper, we
investigate algorithms for distributing copies of primitives among PCs and for dynamic
load balancing under the constraints of partial replication. Our main result is that
the parallel rendering efficiencies achieved with small replication factors are similar to
ones measured with full replication. By storing one fourth of Michelangelo's David
model (800 MB) on each of 24 PCs (each with 256 MB of memory), our system is able to render 40 million polygons/second (65% efficiency).
Sort-last parallel rendering for viewing extremely large
data sets on tile displays
Kenneth Moreland, Bryan Wylie and Constantine Pavlakos
Sandia National Laboratories, USA
Due to the impressive price-performance of today's PC-based graphics
accelerator cards, Sandia National Laboratories is attempting to use PC clusters to render
extremely large data sets in interactive applications. This paper describes a
sort-last parallel rendering system running on a PC cluster that is capable of rendering
enormous amounts of geometry into high-resolution tile displays by taking advantage of the
spatial coherency that is inherent in our data. Furthermore, it is capable of
scaling to larger sized input data or higher resolution displays by increasing the size of
the cluster. Our prototype is now capable of rendering 120 million triangles per
second on a 12 mega-pixel display.
This paper presents a visualization technique based on particle tracking.
The technique consists in defining a set of points distributed on a closed surface and
following the surface deformations as the velocity field changes in time.
Deformations of the surface contain information about dynamics of the flow; in particular,
it is possible to identify zones where flow stretching and foldings occur. Because
the points on the surface are independent of each other, it is possible to calculate the
trajectory of each point concurrently. Two parallel algorithms are studied; the
first one for a shared memory Origin 2000 supercomputer and the second one for a
distributed memory PC cluster. The technique is applied to a fluid moving by natural
convection inside a cubic container.
Case study: visualizing ocean currents with color and
dithering
Patricia Crossno, Edward Angel and David Munich
Sandia National Laboratories, University of New Mexico, and Albuquerque High Performance
Computing Center, USA
This case study presents several related approaches to visualizing flow
information from large vector volumes generated by ocean circulation modeling. Flow
vectors are mapped to colored pixels to enable global views of dense three dimensional
vector fields. Each of the approaches starts by classifying vector direction into a
small number of colors. One approach then uses scaled linear interpolation to blend
between adjacent directional colors. Two other approaches use half-toning and
dithering methods to rapidly display flow information. By using opponent colors for
our directional encoding, we can blend colors, either through linear interpolation or the
user's visual system, into intermediate colors without expressly calculating them by a
conversion to polar coordinates.
Real-time out-of-core visualization of particle traces
Ralph Bruckschen, Falko Kuester, Bernd Hamann and Kenneth I. Joy
University of California, Davis, USA
Visualization of particle traces provides intuitive and efficient means for the
exploration and analysis of complex vector fields. This paper presents a method
suitable for the real-time visualization of arbitrarily large time-varying vector fields
in virtual environments. We describe an out-of-core scheme in which two distrinct
pre-processing and rendering components enable real-time data streaming and
visualization. The presented approach yields low-latency application start-up times
and small memory footprints. The described system was used to implement a
"volumetric fog lance", which can emit up to 60,000 particles into a flow field
while maintaining an interactive frame rate of 60 frames per second. All algorithms
were specifically designed to support commodity hardware. The proof-of-concept
system is running on a low-cost Linux workstation equipped with a 120 GB EIDE RAID
(Redundant Array of Inexpensive Disks) system.
3:15 COFFEE BREAK
3:45 SOFTWARE INFRASTRUCTURE FOR
PARALLEL VISUALIZATION
An application architecture for large data visualization: a
case study
C. Charles Law, Amy Henderson and James Ahrens
Kitware Inc. and Los Alamos National Laboratories, USA
In this case study we present an open-source visualization
application with a data-parallel novel application architecture. The
architecture is unique because it uses the Tcl scripting language to synchronize the user
interface with the VTK parallel visualization pipeline and parallel-rendering
module. The resulting application shows scalable performance, and is easily
extendable because of its simple modular architecture. We demonstrate the
application with a 9.8 gigabyte structured-grid ocean model.
Jupiter: a toolkit for interactive large model visualization
Dirk Bartz, Dirk Staneker, Wolfgang Strasser, Brian Cripe, Tom Gaskins, Kristann
Orton, Michael Carter, Andreas Johannsen and Jeff Trom
University of Tuebingen, Germany, Hewlett-Packard Corporation, USA, and Engineering
Animation Inc., USA
The fast increasing size of data sets in scientific computing,
mechanical engineering, or virtual medicine is quickly exceeding the graphics capabilities
of modern computers. Toolkits for the large model visualization address this problem
by combining efficient geometric techniques, such as occlusion and visibility culling,
mesh reduction, and efficient rendering. In this paper, we introduce Jupiter, a
toolkit for the interactive visualization of large models which exploits the above
mentioned techniques. Jupiter was originally developed by Hewlett-Packard and EAI,
and it was recently equipped with new functionality by the University of Tuebingen, as
being part of the Kelvin project. Earlier this year, an initial version of Jupiter
was also released as open source.
4:45 END OF DAY ONE
-------------------------------------------------------------------
Tuesday October 23, 2001
8:45 ARCHITECTURES FOR STRUCTURED VOLUME RENDERING
Parallel volume rendering on a single-chip SIMD
architecture
M. Meissner, S. Grimm, W. Strasser, J. Packer and D. Latimer
University of Tuebingen, Germany, and PixelFusion Ltd, UK
Volume rendering has great potential for parallelization due to the tremendous
number of computations necessary. Besides the enormous computational power needed,
the memory interface is usually of crucial importance and frequently the bottleneck.
This paper presents an implementation of a parallel ray-casting algorithm for orthogonal
projections on a new single-chip SIMD architecture. Concurrent processing of rays is
scheduled such that redundant memory accesses of the individual processing elements can be
detected by the channel controller. Hence, data can be read efficiently in
block-wise manner. For improved image quality, a permutation of the Shear-Warp
algorithm with trilinear interpolation is used. The steps of the ray casting
algorithm are carefully mapped onto the architecture avoiding expensive floating point
operation, giving superior performance over previously reported results. A detailed
analysis illustrates the timing of the individual computations and memory
accesses, identifying the costliest parts of the implementation.
Scalable interactive volume rendering using
off-the-shelf components
Santiago Lombeyda, Mark Shand, Laurent Moll, David Breen and Alan Heirich
California Institute of Technology, and Compaq Computer Corporation, USA
This paper describes an application of a second generation implementation of the
Sepia architecture (Sepia-2) to interactive volumetric visualization of large rectilinear
scalar fields. By employing pipelined associative blending operators in a sort-last
configuration a demonstration system with 8 rendering computers sustains 24 to 28 frames
per second while interactively rendering large data volumes (1024x256x256 voxels, and
512x512x512 voxels). We believe interactive performance at these frame rates and
data sizes is unprecedented. We also believe these results can be extended to other
types of structured and unstructured grids and a variety of GL rendering techniques
including surface rendering and shadow mapping. We show how to extend our
single-stage crossbar demonstration system to multi-stage networks in order to support
much larger data sizes and higher image resolutions. This requires solving a dynamic
mapping problem for a class of blending operators that includes Porter-Duff compositing
operators.
9:45 COFFEE BREAK
10:15 UNSTRUCTURED VOLUME RENDERING
We present techniques for multiresolution approximation and
hardware-assisted splat based rendering to achieve interactive volume visualization of
large irregular data sets. We examine two methods of generating multiple resolutions
of irregular volumetric grids and a data structure supporting the splatting approach for
volume rendering. These techniques are implemented in combination with a
view-dependent error based resolution selection to maintain accuracy at both low and high
zoom levels. In addition, the error tolerance may be adjusted at run time to obtain
the desired balance between high frame rates and accurate rendering. Along with an
effective way to compute gradients for lighting, we offer an integrated solution for high
quality, interactive volume rendering of irregular-mesh or meshless data, and we
demonstrate our technique on unstructured-grid data sets from aerodynamic
flow simulations.
This paper discusses our efforts to improve the performance of the
high-accuracy (HIAC) volume rendering system, based on cell projection, which is used to
display unstructured scientific data sets for analysis. The parallelization of HIAC,
using the pthreads and MPI APIs, resulted in significant speedup, but interactive frame
rates are not yet attainable for very large data sets.
11:15 PANEL DISCUSSION
Parallelism: Rendering, Visualisation and Large Data
Chair - Alan Chalmers, University of Bristol, England
The bi-ennial IEEE Parallel Rendering Symposium (PRS)
was established in 1993 to provide a publication venue for a small, but active group
of researchers in parallel graphics. After three successful Symposia, in 1999 PRS
changed its name to Parallel Visualisation and Graphics (PVG) to reflect the growing
community of researchers in parallel volume visualisation and also to "link"
with the newly established Eurographics Workshop series on Parallel Graphics and
Visualisation (PGV) which now runs in alternate years to PVG, thus providing two leading
publication venues, one in the US and the other in Europe.
After only one year as PVG, the IEEE Technical Committee on
Visualization and Graphics (TCVG) requested the symposium change its title to Symposium on
Parallel and Large-Data Visualisation and Graphics. This is a significant departure
from the traditional focus on "parallel rendering". The panel will discuss
the basis for this change and what it implies for the future of the symposium. The
question to be answered is: "Has the focus of the Symposium changed so much that
those concerned with photorealism and traditional graphics need to create a separate event
to recapture the original focus on parallel visualisation and graphics, possibly to meet
in conjunction with SIGGRAPH? And what effect would this have on the long term health of
the symposium and its community?"
12:15 Lunch Break
1:45 PARALLEL ISOSURFACE AND VOLUME RENDERING
Our scalable isosurface visualization solution on a commodity
off-the-shelf cluster is an end-to-end parallel and progressive platform, from the initial
data access to the final display. In this paper we focus on the back end scalability
by introducing a fully parallel and out-of-core isosurface extraction algorithm. It
partitions the volume data according to its workload spectrum for load balancing and
creates an I/O-optimal external interval tree to minimize the number of I/O operations of
loading large data from disk. It achieves scalability by using both parallel
processing and parallel disks. Interactive browsing of extracted isosurfaces is
made possible by using parallel isosurface extraction and rendering in conjunction with a
new specialized piece of image compositing hardware called the Metabuffer. We also
describe an isosurface compression scheme that is efficient for
isosurface transmission.
In this paper, we present a unified infrastructure for parallel
out-of-core isosurface extraction and volume rendering of large unstructured grids
on distributed memory parallel machines. We parallelize the out-of-core isosurface
extraction algorithm of [9] and the out-of-core ZSWEEP technique [17] for direct volume
rendering, using the meta-cell technique as a unified underlying building block. Our
one-time preprocessing first partitions the dataset into meta-cells that are stored in
disk. From the meta-cells, we build a BBIO tree in disk, which can be used to speed
up isosurface extraction, and a bounding-box file in disk, which is used for direct volume
rendering. At run-time we use a simple self-scheduling scheme [39] to achieve load
balancing among the processors. We perform several experiments on a sixteen-node
cluster of PCs connected by a gigabit ethernet, using datasets as large as 6.6 million
cells. For the larger datasets, we have found that both our isosurface extraction
and direct volume rendering approaches are perfectly scalable up to
sixteen nodes.
This paper presents a parallel algorithm that can effectively extract
only the visible portion of isosurfaces. The main focus of our research is to devise
a load-balanced and output-sensitive algorithm, that is, each processor will generate
approximately the same amount of triangles, and cells that do not contain the visible
isosurface will not be visited. A novel multi-pass algorithm is proposed in the
paper to achieve these goals. In the algorithm, we first use an octree data
structure to rapidly skip the empty cells. An image space visibility culling
technique is then used to identify the visible isosurface cells in a progressive
manner. To distribute the workload, we use a binary image space partitioning method
to ensure that each processor will generate approximately the same amount of
triangles. Isosurface extraction and visibility update are performed in parallel to
reduce the total computation time. In addition to reducing the size of output
geometry and accelerating the process of isosurface extraction, the multi-pass nature of
our algorithm can also be used to perform time-critical computation.
3:15 CLOSING REMARKS
3:30 SYMPOSIUM ENDS
|
