 |
The Metabuffer Project
|
MULTIDISPLAY
MULTIRESOLUTION PARALLEL IMAGE COMPOSITION
In most computer graphics applications resolution is a tradeoff. Using
low resolution images provide a low quality display, but
typically allow higher frame rates because less data needs to be computed.
High resolution images, on the other hand, give the best
display, yet are hindered by slower refresh times and thus limit user
interactivity. Low image quality and low user interactivity are both
detriments to computer graphics visualization applications. The question
is then what can be done to minimize this impact.
The aim of this project is to explore how to use multiresolution in
order to provide the best balance between image quality and user
interactivity on a parallel multidisplay multiresolution image compositing
system with antialiasing called the Metabuffer. The
architecture of the Metabuffer, a simulator written in C++, and a Beowulf
cluster based emulator have been developed in this
research. Additional supporting hardware and software needed in the
project include an algorithm to partition datasets into
Metabuffer viewports and a wireless visualization control device.
Using the Beowulf cluster based Metabuffer emulator, two multiresolution
techniques have been studied: progressive image composition
and foveated vision applications. Progressive image composition allows
the user to rapidly change viewpoints without immediately
moving data between PCs. Instead, the resolution of each PCs viewport
adjusts in order to cover the visible polygons for which it is
responsible. The larger, low resolution viewports have lower image
quality, but the user sees no drop in frame rate. Over time, the PCs
can readjust their data in order to shrink their viewports and provide
high resolution imagery. Foveated vision applications allow
computing resources to be concentrated only where the user is actually
looking. Human peripheral vision cannot discern high levels
of detail. Rendering the periphery with a low polygon count using a
few low resolution viewports allows the majority of the machines to
render high resolution viewports only where the user (or users) are
looking thus increasing the framerate.
CCV
RELATED PUBLICATIONS
X. Zhang, C. Bajaj, W. Blanke
Scalable Isosurface Visualization of Massive Datasets on COTS-Cluster
To appear in the Symposium on Parallel Visualization and Graphics
2001, San Diego, CA, 2001 (pdf)
W. Blanke, C. Bajaj, X. Zhang,
D. Fussell
A Cluster Based Emulator for Multidisplay, Multiresolution Parallel
Image Compositing
CS & TICAM Technical Report, University of Texas at Austin,
2001 (pdf)
W. Blanke, C, Bajaj, D. Fussell,
X, Zhang
The Metabuffer: A Scalable Multiresolution Multidisplay 3-D Graphics
System Using Commodity Rendering Engines
Technical Report, University of Texas at Austin.(ps, pdf) |
Metabuffer
Architecture
|
|
The architecture of the Metabuffer
presents a number of challenges.The most difficult problem is the large
amount of data that must be processed. Each pixel needs RGB color, Z order,
and alpha information. A single frame will have millions of these pixels.
A real-time rendered animation will need to display approximately 30 frames
per second in order to be fluid and smooth. Multiply all of this by several
rendering engines and several output displays and the large quantities
of data involved are clearly evident.The figure to the left shows how a
Metabuffer architecture using three rendering engines and four output displays
utilizes multiple pipelined data paths and busses to surmount this problem. |
Metabuffer
Simulator
|
|
Because of the complexity of the
Metabuffer a prototype of it has been built in software. This prototype
is modeled as closely as possible to the operation of the Metabuffer architecture
discussed previously in this paper. Since this software prototype will
be the basis for the first hardware implementation of the Metabuffer, all
coding was done strictly with the Metabuffer architecture in mind. By building
the prototype in software first, it is possible to do much more extensive
testing and to try many more design alternatives in the same amount of
time than with hardware. Changing a signal or reworking an algorithm means
only recompiling the source code, instead of rewiring a circuit board or
burning another FPGA.Also, with a software prototype, a Metabuffer consisting
of hundreds or thousands of rendering engines can be simulated. |
Metabuffer
Emulator
|
|
In order to provide an interactive
testbed for writing applications for the Metabuffer system, a emulator
was written in software that would mimic the operations of the Metabuffer
while attempting to run as fast as possible. The Metabuffer emulator essentially
produces the same output as the hardware level simulator, except it is
not constrained to work as the Metabuffer hardware would. Thus it can be
optimized to run as fast as possible on the host architecture.The host
system that we are using for the Metabuffer emulator is a Beowulf cluster
consisting of 128 networked Compaq computers running the Linux OS. Each
machine contains an 800 MHz Intel Pentium III 256K L2 processor and 256
MB RDRAM.32 of these machines are equipped with high performance Hercules
3D Prophet II GTS DVI graphics cards. Furthermore, 10 of these graphics
cards are linked to a 5 by 2 tiled projection screen display in our visualization
lab. |
Load
Balancing
|
|
Given a triangular mesh, it is
very important to distribute the triangles properly in order to achieve
a good load balance among parallel rendering servers. A parallel system
is only as fast as its slowest member, so ensuring that the work is evenly
distributed is paramount to obtaining good timings and therefore good speedups
and processor utilization efficiency. This research explores the problem
of load balanced triangular mesh partitioning for the rendering servers
of the Metabuffer. The goal is to distribute the triangles in a mesh in
such a way so that all the triangles are renderered by one server, they
are evenly balanced, and that each grouping of triangles is located within
a screen sized area in the overall display space. |
Wireless
Control
|
|
When using very large, multiscreen,
tiled displays in conjunction with the visualization of large datasets,
it is important for the user (or users) to be able to interact easily with
the application. In the case of the Metabuffer project, this is especially
true since the aim of using its multiresolution capabilities is to increase
user responsiveness. To create such a mobile user interface, standard COTS
Windows CE Pocket PC devices were selected. Equipped with wireless Ethernet
PCMCIA cards, they are lightweight, small, relatively inexpensive, and
user friendly. While eventually gaze trackers on headsets will provide
foveated vision information, in the meantime the wireless Pocket PC devices
serve in this role. Using mobile computing in conjunction with the Metabuffer
opens up many new possibilities for user interactivity. |
Progressive
Image Composition
|
|
The problem of how to quickly
navigate but still retain high quality image output also exists for rendering
large datasets in parallel on multiple displays. To achieve good user interactivity,
an application must guarantee time-critical rendering of the massive datastream.
However, for the instance of displaying a triangular mesh, though a good
load balanced partition among the parallel machines can be computed for
a given user view point, new computation and data shuffling are required
whenever the view point is significantly changed. Either triangles may
fall out of the viewport because of the movement of the viewing direction
or the viewport cannot cover all the polygons assigned to it because of
zooming. Redistributing primitives or imagelets in order to render all
of the polygons correctly takes time. If the user is simply navigating
the dataset this additional time will result in slower framerates hampering
user interactivity. To solve this problem, we propose adapting the concept of progressivity
to the generation of images via image compositing on the Metabuffer, terming
the technique progressive image composition. |
Foveated
Vision
|
|
Our own eyes can only sense detail
directly where we look. Objects in our peripheral vision appear in low
resolution and lack definition.This basic biological fact is a result of
the concentration of rods and cones in the retina of the human eye. A higher
concentration exists at the center with the density gradually becoming
lower and lower towards the edges. In fact, the human eye even has a blind
spot where nerves exit the eye ball and there are no rods or cones at all.
Our brain processes what we are seeing in order to account for the blind
spot and differing rod and cone densities. As a consquence of human biology,
even though computer visualization systems may render a large display in
high resolution, by the time that information gets to our brain, much of
the information has been lost by the limitations of our vision system.This
is the concept for the foveated vision application for the Metabuffer.
Using the physical characteristics of the eye as an advantage, the computing
resources of the Metabuffer are matched to the areas in the display that
are being examined. |
send inquiries about this page to ccv@ices.utexas.edu.
|
|
|
