Andrew C. Beers

The two-user Responsive Workbench: support for collaboration through individual views of a shared space

We present the two-user Responsive Workbench: a projectionbased virtual reality system that allows two people to simultaneously view individual stereoscopic image pairs from their own viewpoints. The system tracks the head positions of both users and computes four images one for each eye of each person. To display the four images as two stereo pairs, we must ensure each image is correctly presented to the appropriate eye. We describe a hardware solution to this display problem as well as registration and calibration procedures. These procedures ensure that when two users point to the same location on a virtual object, their fingers will physically touch. Since the stereo pairs are independent, we have the option of displaying specialized views of the shared virtual environment to each user. We present several scenarios in which specialized views might be useful. CR

Rendering from compressed textures

We present a simple method for rendering directly from compressed textures in hardware and software rendering systems. Textures are compressed using a vector quantization (VQ) method. The advantage of VQ over other compression techniques is that textures can be decompressed quickly during rendering. The drawback of using lossy compression schemes such as VQ for textures is that such methods introduce errors into the textures. We discuss techniques for controlling these losses. We also describe an extension to the basic VQ technique for compressing mipmaps. We have observed compression rates of up to 35 : 1, with minimal loss in visual quality and a small impact on rendering time. The simplicity of our technique lends itself to an efficient hardware implementation. CR categories: I.3.7 [Computer Graphics]: 3D Graphics and Realism Texture; I.4.2 [Image Processing]: Compression Coding

3D painting on scanned surfaces

We present an intuitive interface for painting on unparameterized three-dimensional polygon meshes using a 6D Polhemus space tracker as an input device. Given a physical object we first acquire its surface geometry using a Cyberware scanner. We then treat the sensor of the space tracker as a paintbrush. As we move the sensor over the surface of the physcial object we color the corresponding locations on the scanned mesh. The physical object provides a natural force-feedback guide for painting on the mesh, making it intuitive and easy to accurately place color on the mesh.

Model-based motion estimation for synthetic animations

Maneesh Agrawala Andrew C. Beers Navin Chaddhay Computer Science Department yComputer Systems Laboratory Stanford University Stanford University ABSTRACT One approach to performing motion estimation on synthetic animations is to treat them as video sequences and use standard image-based motion estimation methods. Alternatively, we can take advantage of information used in rendering the animation to guide the motion estimation algorithm. This information includes the 3D movements of the objects in the scene and the projection transformations from 3D world space into screen space. In this paper we examine how to use this high level object motion information to perform fast, accurate block-based motion estimation for synthetic animations. The optical ow eld is a 2D vector eld describing the translational motion of each pixel from frame to frame. Our motion estimation algorithm rst computes the optical ow eld, based on the object motion information. We then combine the per-pixel motion information for a block of pixels to create a single 2D projective matrix that best encodes the motion of all the pixels in the block. The entries of the 2D matrix are determined using a least squares formulation. Our algorithms are more accurate and much faster in algorithmic complexity than many image-based motion estimation algorithms.

Model-based compression for synthetic animations

As heterogenous computing environments become ubiquitous, the demand for viewing synthetic 3D animations across a wide variety of platforms is increasing. In this paper we present the framework of a compression system for synthetic animations which can be used to view such animations in these environments. While the system is flexible enough to take advantage of any rendering capabilities that may be available at the decoder, it is designed with the intention of viewing such animations on low end computers or set top boxes that may not contain rendering hardware. Our approach takes advantage of the information generated during rendering to guide the compression of it. Our model-based approach to compression for synthetic animations is faster and produces better quality as well as higher compression rates than video compression algorithms, while maintaining the portability of a cheap software based solution. Compressing animations using our system results in both a 25-50% lower bitrate and a 1.5-3.0 dB higher PSNR than using MPEG.

Monitoring data-structure evolution in distributed message-passing programs

Monitoring the evolution of data structures in parallel and distributed programs, is critical for debugging its semantics and performance. However, the current state-of-art in tracking and presenting data-structure information on parallel and distributed environments is cumbersome and does not scale. We present a methodology and tool that automatically tracks memory bindings (not the actual contents) of dynamic data-structures of message-passing C programs, and inter-processor data-structure movement, using PVM on distributed environments. With the help of a number of examples we show that in addition to determining the impact of memory allocation overheads on program performance, graphical views can help in debugging many memory access errors. Traditional debuggers in distributed environments rely on existing sequential debuggers on each machine and simply provide an interface for querying and controlling each processors debugging session. However, to quickly locate the processor and to explain reasons for the error, we resort to run-time checking and trace based visualizations of memory access behavior across all processors. In an effort to reduce trace file size, only updates of pointer values and memory management functions are captured.