A Concept for Time-Dependent Processes

Konrad Polthier and Martin Rumpf


We develop a new concept to extend a static interactive visualization package to a time-dependent animation environment by reusing as many as possible of the existing static classes and methods. The discussion is based on an object-oriented mathematical programming environment and is applied to parameter-dependent structures, time-dependent adaptive geometries and flow computations but most of the ideas apply to other environments in scientific visualization too. We define new classes describing dynamic processes (including e.g. time-dependent adaptive geometries) and specify a protocol mechanism they must understand. This allows the definition of a class TimeNode supervising an arbitrary dynamic processes as a time-dependent node in a formerly static data hierarchy. We discuss mechanisms of such time-dependent hierarchies, and additionally the problem of algorithms on time-dependent geometries in a number of examples.

Full Version: .pdf 776 KB, .ps.gz 927 KB


Time-dependent processes occur in many different areas as for example in the description of natural phenomena and their computer graphical visualization, in computer animation packages, or in mathematics when analyzing parameter-dependent problems. The paper is centered around the question of how to describe such phenomena in a software package and what kind of algorithms operate on such data.

This paper describes a procedure to extend a static graphical programming environment to handle arbitrary time-dependent processes by easily upgrading existing classes and methods working on static data. Although this was our original goal, it turned out that the concept is useful in a more general sense. The restriction of having to start with a static environment and not to start with an animation system right from the beginning turned out to be extremely useful when formulating the principal ideas. This might simply be true because even in animation packages a user usually is not able to work on an animated object during its animation but he stops the animation for modeling objects - meaning that he operates on a static time cut. Surely, this is a simplification and we will later discuss the problem of algorithms working on complete dynamic processes.

We start our paper with a discussion of the term time in chapter . For example, we generalize the meaning of time to be local to an object, which allows us to view the same dynamic process at two different speeds simultaneously. Surely, this is very useful when analyzing dynamic process. A major point is the definition of a new class TimeNode in chapter describing a time-dependent subclass of the class Node in the static case. Using such nodes we extend a static hierarchy to a time-dependent hierarchy. A static node has a pointer to a static geometry. A instance of class TimeNode has (beside other instance variables) additionally a pointer to a dynamic process and reuses the pointer to the static geometry to store the current time cut of the dynamic process. If time does not change the hierarchy behaves as in the static case and all existing tools of the existing static environment may still be used.

Before discussing in chapter time-control in a time-dependent hierarchy with multiple nodes of class TimeNode, we discuss in chapter a number of example classes describing dynamic processes. For example, we extend the classical key-frame technique to allow discretization changes of animated triangulated geometries. Finally, we discuss in chapter a number of mathematical algorithms working on dynamic processes. Such algorithms are not pure extensions of static methods, but may have much more functionality. Consider for instance clipping at a sphere where the algorithm is static but the sphere may have an animated diameter, or algorithms integrating over dynamic processes.

Summarizing, our major points are:

Our concept differs strongly from other concepts available in scientific visualization software [].

The time-concept described in this paper has been implemented in the graphical programming environment GRAPE [] developed at the Sonderforschungsbereich 256 for ''Nonlinear Partial Differential Equations'' at the University of Bonn. GRAPE is an object-oriented, interactive visualization package with a library of classes and methods supporting besides others mainly solutions of problems from continuums mechanics and differential geometry []. It is device independent and runs on a variety of workstations.

The first author wants to thank Charlie Gunn for fruitful comments on the paper.