Ronen Barzel

Interactive pen-and-ink illustration

We present an interactive system for creating pen-and-ink illustrations. The system uses stroke textures—collections of strokes arranged in different patterns—to generate texture and tone. The user “paints” with a desired stroke texture to achieve a desired tone, and the computer draws all of the individual strokes. The system includes support for using scanned or rendered images for reference to provide the user with guides for outline and tone. By following these guides closely, the illustration system can be used for interactive digital halftoning, in which stroke textures are applied to convey details that would otherwise be lost in this black-and-white medium. By removing the burden of placing individual strokes from the user, the illustration system makes it possible to create fine stroke work with a purely mouse-based interface. Thus, this approach holds promise for bringing high-quality black-and-white illustration to the world of personal computing and desktop publishing.

Art-based rendering of fur, grass, and trees

Artists and illustrators can evoke the complexity of fur or vegetation with relatively few well-placed strokes. We present an algorithm that uses strokes to render 3D computer graphics scenes in a stylized manner suggesting the complexity of the scene without representing it explicitly. The basic algorithm is customizable to produce a range of effects including fur, grass and trees, as we demonstrate in this paper and accompanying video. The algorithm is implemented within a broader framework that supports procedural stroke-based textures on polyhedral models. It renders moderately complex scenes at multiple frames per second on current graphics workstations, and provides some interframe coherence. CR

An interface for sketching 3D curves

The ability to specify nonplanar 3D curves is of fundamental importance in 3D modeling and animation systems. Effective techniques for specifying such curves using 2D input devices are desirable, but existing methods typically require the user to edit the curve from several viewpoints. We present a novel method for specifying 3D curves with 2D input from a single viewpoint. The user rst draws the curve as it appears from the current viewpoint, and then draws its shadow on the oor plane. The system correlates the curve with its shadow to compute the curves 3D shape. This method is more natural than existing methods in that it leverages skills that many artists and designers have developed from work with pencil and paper.

Plausible motion simulation for computer graphics animation

Accuracy is the ubiquitous goal of dynamic simulation, in order to yield the “correct” motion. But for creating animation, what is really of interest is “plausible” motion, which is somewhat different. We discuss what we mean by plausible simulation, how it differs from “accurate” simulation, and why we think it’s a worthwhile area to study. The discussion touches on questions of physically plausible vs. visually plausible motion, plausible simulation in a noisy or textured environment, and probability measures for motion, as well as issues for forward and inverse problems.

A framework for geometric warps and deformations

We present a framework for geometric warps and deformations. The framework provides a conceptual and mathematical foundation for analyzing known warps and for developing new warps, and serves as a common base for many warps and deformations. Our framework is composed of two components: a generic modular algorithm for warps and deformations; and a concise, geometrically meaningful formula that describes how warps are evaluated. Together, these two elements comprise a complete framework useful for analyzing, evaluating, designing, and implementing deformation algorithms. While the framework is independent of user-interfaces and geometric model representations and is formally capable of describing any warping algorithm, its design is geared toward the most prevalent class of user-controlled deformations: those computed using geometric operations. To demonstrate the expressive power of the framework, we cast several well-known warps in terms of the framework. To illustrate the frameworks usefulness for analyzing and modifying existing warps, we present variations of these warps that provide additional functionality or improved behavior. To show the utility of the framework for developing new warps, we design a novel 3-D warping algorithm: a mesh warp---useful as a modeling and animation tool---that allows users to deform a detailed surface by manipulating a low-resolution mesh of similar shape. Finally, to demonstrate the mathematical utility of the framework, we use the framework to develop guarantees of several mathematical properties such as commutativity and continuity for large classes of deformations.

Adjustable tools: an object-oriented interaction metaphor

To provide a simpler metaphor for representing, selecting, and adjusting collections of attributes for interactive operations.

Motion blur on graphics workstations

Publisher Summary Lively and dynamic motion can make exciting computer-generating images and animations. Typically, each individual image is rendered at a single instant of time. For a single image of a moving subject, that conveys no sense of motion. For an animation, that can result in extremely objectionable strobing artifacts. Aliasing in time can be reduced by motion blur, that is, by averaging or filtering images at many instants of time to create a result in which moving objects are blurred. Motion blur techniques for ray tracing are relatively well understood and involve the association of different time values for each ray cast. This chapter presents a motion blur technique suitable for graphics workstations having fast z-buffer rendering. Fast, high-quality motion blur is achieved simply by supersampling in time using a temporal box filter and computing images on fields, rather than frames, for video animations.

Patchwork: A fast interpreter for a restricted dataflow language

We have built a system, Patchwork, that allows programs to be organized according to a dataflow model. In our implementation, application programs use Patchwork to assemble complex microcode programs for a graphics processor from a library of microcode modules. We describe a simple and efficient implementation, in which the only overhead incurred is a single extra level of indirection when invoking a module or when a module accesses inputs, outputs, or local storage. The implementation depends on being able to describe a distinct execution tree for the network, which obviates the need both for run-time monitoring of the execution and for movement of data. Thus, neither dataflow hardware nor a dataflow language is needed for the implementation. Patchwork supports flow-of-control constructs such as looping and branching, the assembly of complex modules from simpler ones, modules written in a variety of languages for a variety of different devices, the interleaved execution of several programs on a single processor, and the execution of a single program on a set of processors in parallel. An analysis showed that Patchwork contributed between 2 and 5% to the total running time of sample microcode programs.

Overview of Model Library

This chapter provides an overview of a prototype library for rigid-body modeling. The prototype library supports classical dynamic rigid-body motion with geometric constraints. The prototype library has three major goals: (1) to demonstrate the structured design strategy, (2) to test the feasibility of the design strategy, and (3) to provide a rigid-body modeling library. The library includes the following features for rigid-body modeling: (1) basic Newtonian motion of rigid bodies in response to forces and torques, (2) the ability to measure work done by each force and torque and balance it against the kinetic energy of the bodies; (3) support for various kinds of forces to apply to bodies, including dynamic constraint forces to allow constraint-based control; (4) the ability to handle discontinuities in a model; and (5) the ability to be extended, both by enhancing the modules and by adding additional modules.

A Structured Analysis of Modeling

This chapter presents a structured analysis of modeling. It describes a paradigm and terminology to be applied to modeling, based upon two canonical ways of viewing models: (1) abstraction-representation-implementation (ARI) structure for extant models, and (2) progressive decomposition for the creation of models. These constructs provide the framework for the discussion of issues such as design methodologies, communication of models, and the use of computers as modeling tools. The ARI structure of a model gives a succinct overview and encapsulation of the model. Identifying the abstraction, representation, and implementation of a model is an important aid in understanding the models makeup and function.