a programming approach for complex animations. …...a programming approach for complex animations....

A programming approach for complex animations. Part I. Methodology

C. Bajaja, C. Baldazzib, S. Cutchina, A. Paoluzzib,* , V. Pascuccia, M. Vicentinob

aDepartment of Computer Sciences and TICAM, University of Texas, Austin, TX 78712, USAbDipartimento di Informatica e Automazione, Universita` di Roma Tre, Via Vasca Navale 79, Rome 00146, Italy

Received 28 August 1998; received in revised form 15 June 1999; accepted 12 July 1999

Abstract

This paper gives a general methodology for symbolic programming of complex 3D scenes and animations. It also introduces a minimal setof animation primitives for the functional geometric languagePLaSM. The symbolic approach to animation design and implementationgiven in this paper goes beyond the traditional two-steps approach to animation, where a modeler is coupled, more or less loosely, with aseparate animation system. In fact both geometry and motion design are performed in a unified programming framework. The representationof the animation storyboard with discrete action networks is also introduced in this paper. Such a network description seems well suited foreasy animation analysis, maintenance and updating. It is also used as the computational basis for scheduling and timing actions in complexscenes.q 1999 Elsevier Science Ltd. All rights reserved.

Keywords: Graphics; Animation; Design language; Collaborative design; Geometric programming;PLaSM

1. Introduction

This work introduces a high-level methodology orientedtowards building, simulating and analyzing complexanimated 3D scenes. Our first goal is the creation ofcompact and clear symbolic representations of complexanimated environments. Our second goal is to allow foreasy maintenance and update of such environments, sothat different animation hypotheses can be analyzed andcompared. The construction of complex animations usingminimal man-hours and low-cost hardware also motivatedthe present approach.

The contributions of the present paper can be summarizedas follows: (i) definition of a methodology for symbolicprogramming of complex 3D scenes; (ii) introduction of aminimal set of animation primitives for a geometriclanguage; (iii) development of two experimental animationframeworks, both local and web-based. This approach goesbeyond the traditional two-steps approach to animation,where a modeler is coupled, more or less loosely, with aseparate animation system.

A programming approach to animation that provides

simple but powerful animation capabilities as an extensionof a geometric design language is discussed here. Henceboth geometry design and animation can be performed ina unified framework where animations are programmed justlike any other geometric information. In this way a designeror scientist may quickly define and simulate complexdynamic environments, where movements can be describedby using well-established methods of mathematical physicsand solid mechanics.

We show that using a functional language is serviceableboth in quickly implementing complex animations and intesting new animation methods. For this purpose, look at thesolution proposed for describing the storyboard of verycomplex animations and computing the relative timeconstraints between different animation segments. Noticethat a full “choreographic control” is achieved by imple-menting a “fluidity constraint” of the whole animation,which holds for any possible choice of expected durationsof animation segments.

For very complex animation projects, where several userscooperate to design an animated environment, we are devel-oping a collaborative web-based interface where multipleclient applications can interact with the same scene. Due tothe compactness of the shared information, multiple clientapplications, possibly distributed in a wide area network,can interact with the same animated scene either synchro-nizing their views or working with independent focus ondifferent aspects of interest or competence. This provides

Computer-Aided Design 31 (1999) 695–710

COMPUTER-AIDEDDESIGN

0010-4485/99/$ - see front matterq 1999 Elsevier Science Ltd. All rights reserved.PII: S0010-4485(99)00062-7

www.elsevier.com/locate/cad

* Corresponding author. Tel.:139-06-5517-3214.E-mail addresses:[email protected] (C. Bajaj), baldazzi@dia.

uniroma3.it (C. Baldazzi), [email protected] (S. Cutchin), [email protected] (A. Paoluzzi), [email protected] (V. Pascucci),[email protected] (M. Vicentino)

a shared workspace that makes easy the animation processand reduces its production time and cost.

We are experimenting the methodology in two settings.Firstly we have been using a simple Open Inventor-basedanimation server to allow local display of the animations onany system including low-cost PCs. Also, we are developinga web-based visualization framework, where the compact-ness of the language representation turns out to be usefulwhen transmitting geometry and animation informationover the network.

For this purpose we have extended the geometriclanguagePLaSM [13], recently integrated into the colla-borative and distributed 3D toolkitShastra[3], with theability to generate platform-independent animated scenedescriptions capable of being read by 3D graphics librariessuch as the Shastra animation moduleGati [4], or OpenInventor [22]. The animation methodology introducedhere is implemented as an extension of thePLaSMlanguage, providing a hierarchical description of scenesand capable of being exported to generic animation engines,just by switching to an appropriate driver.

The proposed methodology allowed to implement adetailed reconstruction of a real catastrophic event whichoccurred in Italy three years ago. This large-scale exampleis described in the companion paper [14].

The present paper is organized as follows. In Section 2some animation softwares are quickly described, in order toabstract their common features. In Section 3 a set ofanimation concepts is defined, and an animation designmethodology based on discrete action networks is proposed.In Section 4 some background concepts from graphics,geometric programming and network programming arerecalled. In Section 5 the design goals and implementationdirections of thePLaSManimation extension are discussed.In Section 6 the static and run-time architecture of both alocal Inventor-based animation server and of web-basedShastra’s animation services are discussed. In Section 7 acomplete implementation of a non-trivial animationexample is given. In Section 8 the on-going extensions tothe described animation environment are outlined.

2. Previous work

In this section we report on some main aspects of bothcommercial and academic animation software. In particular,we concentrate on the animation capabilities, even when thesystems also offer advanced modeling tools. Commercialanimation software usually allows to animate objects, lights,cameras, surface properties and shading parameters. Thebasic tools define animations on the basis of key-framesand motion paths. They also normally solve inversekinematic problems. The user interface allows interactivedefinition and editing of parameters curves.

Power Animator [2] is a software from Alias/Wavefront.Interactive tools allow fine tuning of the interaction among

actors and the background. It also allows to emulate physi-cal phenomena like gravity, friction, turbulence or colli-sions. Advanced features include automatic generation of3D solid and gaseous particles interacting realisticallywith the environment. Maya [1], also from Alias/Wavefront,allows for intuitive animation of syntheticcharacters. Thecharacter behaviors are defined by hierarchical controls.This includes hierarchical deformations, inverse kinematic,facial animation,skinningtools. It provides a wide numberof special effects and includes the scripting language MEL.It also provides a C11 API that allows to modify a numberof functionalities as needed by the user.

LightWave [12] from NewTek is platform independent.The system is mostly modeling and rendering oriented (e.g.real-time transformation of polygonal surfaces intoNURBS). Advanced features are provided for dealing withevolving illumination and the definition of dynamic systemsof particles. The animations can be defined through thescripting languageL-script . Electric Image [6] is alsoplatform independent. In Electric Image 3D models can bebuild directly from their skeletons. Shape transitions areperformed through morphing techniques. Ad hoc featuresare available for sky and backgrounds.

Houdini [19] is a software from Effects Software. It is aprocedural animation system providing a scripting languageand a SDK for system customization. The procedural para-digm is implemented through a friendly user interface with adata-flow like structure. 3D Studio Max [11] from Autodeskis an object-oriented environment with a flexible animationcontrol system, where every feature is editable and exten-sible. SoftImage [20] offers a high-level interface forsequencingactions(sets of animation data) along the timeaxis. This allows easy animation editing of segmented high-resolution characters. It provides advanced features for skin-ning and inverse kinematics of physically based characters.

The academic software Alice, by Randy Pausch’s group[17] at CMU, is an interesting rapid prototyping interactivesystem for virtual reality. Alice is also based on a program-ming approach, which uses the object-oriented interpretedlanguage Python [21]. When the Alice program is execut-ing, the current state can either by updated by evaluatingprogram code fragments, or by GUI tools. Alice’s simula-tion and rendering are transparently decoupled. Cinderella[18] is a Java software for geometry definition and anima-tion. It is oriented towards mathematical users experiment-ing with projective and descriptive geometry, but does notseem to be well suited for 3D modeling.

Published work on advanced animation systems is oftenfocused on specific aspects of the problem. For example,Grzeszczuk et al. [9] explore the possibility to replace heavyphysically based simulated animations with physicallyrealistic sequences generated by trained neural networks.This approach seems very interesting but cannot be usedwithin general-purpose animation systems. Gleicher [8]considers the problem of retargetting existing motions ofanimated characters to structurally equivalent ones. His

C. Bajaj et al. / Computer-Aided Design 31 (1999) 695–710696

approach minimizes the frequency magnitude of the differ-ence between the original motion and the adapted one usinga space–time constraint solver. In this way the visual arti-facts of the adapted motion are strongly reduced. Such anapproach could be used to reusing pieces of animation codein different settings.

3. Methodology

The animation methodology proposed in this paper isspecified here. First some definitions are given, then theanimation partitioning with network techniques is proposed,and the typical modeling and animation cycle is discussed.

3.1. Definitions

In order to focus the main aspects of the animationproblem several definitions are given. Some of them arequite standard in the animation field. Anyway, it seemsuseful to provide a precise meaning to concepts used inthe remainder of this work:

Scene: A sceneis defined here as a function of real para-meters, with values in some suitable data type. Eachfeasible set of parameters defines aconfigurationof thescene. The time can be considered a special parameterand treated separately from the other ones.Background: The scene part which is time-invariant iscalledbackground.Foreground: The time-varying portion of an animatedscene is calledforeground. It can be subdivided intostaticanddynamicforeground. The former is visible only insidea time interval with a constant configuration. The latter isinstead associated to variable configurations.Behavior: The product of the time domain times theConfiguration SpaceCS gives the state-spaceof theanimation.1 A continuous curve in thestate-spaceofthe animation is called abehaviorof the scene.Animation: An animation is a pairkscene, behaviorl.

3.2. Network approach

An animation description with discrete action networks isintroduced here. Such a network description seems wellsuited for easy animation analysis, maintenance and updat-ing. It is also used as the computational basis for schedulingand timing actions in complex scenes. The relevant conceptsare given in the following:

Storyboard: A network representation of the animationforeground is called thestoryboard. It is a hierarchicala-cyclic graph with only one node of in-degree zero(called sourcenode) and only one node of out-degreezero (calledsink node). The source node represents the

animationstart. The sink node represents the animationend.

From a practical viewpoint, the storyboard states a hier-archical partitioning of the animation behavior (and scene)into independent components. In other words, the story-board partitions the animation into largely independent“segments” and specifies both time constraints betweensuch components, and the projection curves of the anima-tion behavior into lower-dimensional subspaces associatedto segments:

Segment: A segmentis an arc of the storyboard. It repre-sents a foreground portion characterized by the fact thatevery interaction with the remainder animation is concen-trated on the starting and ending nodes of the segment.

Each segment may be modeledindependentlyfrom theothers, by using alocal coordinate frame for both space andtime coordinates. The concepts of storyboard and segmentare interchangeable, in the sense that each complex segmentof the animation can be modeled by using a local story-board, which can be decomposed into lower-level segments.Elementary segmentsare those without a local storyboard:

Event: An eventis a storyboard node. The segments start-ing from it may begin only whenall the segments endingin it have finished their execution.Segment model: The geometric modelof a segment is adescription of both the assembly structure and the geome-try of its elementary parts. InPLaSM every geometricmodel results from the evaluation of some polyhedrallytyped expression.Segment behavior: A behavior of the segment is thecontinuous curve restriction of the scene behavior to thesegment’s subset of degrees of freedom.Actor: An actor (or character) is a connected chain ofsegments associated with a unique geometric model andwith different behaviors. So, at any given time each actorhas a unique fixed set of parameters, i.e. a unique config-uration.

Notice that the behaviors of an actor are defined as differ-ent curves in the same subspace of state-space. In fact, since

C. Bajaj et al. / Computer-Aided Design 31 (1999) 695–710 697

Fig. 1. Motion data set generated by anANIMATIONprimitive. This repre-sentation can be played by a generic animation server.

1 Remember thatCSis the product space of the interval domains of sceneDOFs.

the geometric model is invariant, the segment configurationspace is also invariant. The different curves correspond topairs of events where the considered actor interacts withother actors, according to the storyboard.

3.3. Modeling and animation cycle

The highest levelPLaSMprimitive, namedANIMATION,directly corresponds to the animation storyboard. Thelanguage interpreter generates at run-time a suitable set ofmotion data(see Fig. 1) to be interpreted and executed bythe animation server.

Each animation segment is associated with a time length(duration), either introduced by the user for elementarysegments, or automatically computed by using the segmentstoryboard and a suitable algorithm. In particular, thecriti-cal pathalgorithm is used for this purpose. This method isbased on the computation of the longest-time paths of thestoryboard network. According to standard PERT terminol-ogy each segment of a storyboard may be defined as eitherof typeearliest_start, or latest_endor critical (both earlieststart and latest end), to denote the specific time constraints.

Geometric models are implemented inPLaSMas Hier-archical Polyhedral Complexes (HPC) [15]. Such a modelmay be exported fromPLaSMas either VRML or Inventorfile. Container nodes referring to external VRML/Inventorfiles provide the geometric components for the run-timebehavior of the animation.

The geometric model of a dynamic foreground segmentmust provide some degrees of freedom (DOFs), i.e. someunbounded parameters, often corresponding to parametersof affine transformations. Such a segment will be suitablyexported using theMOVEprimitive described in Section 5.2.The unbound parameters constitute one of main componentsof the motion files in the CS folder (see Fig. 1) associated bythe PLaSMinterpreter to the foreground segments.

The behavior curves are implemented inPLaSMby usingparametric curves and splines. The starting and ending timesare automatically computed using the dynamic program-ming formulas recalled in Section 4.5. A simple and oftenuseful choice is to use Be´zier curves to represent the beha-viors. A behavior is completely specified by a sequence ofpoints in state-space. In particular, any Be´zier curve inter-polates the first and last points and approximates the otherones. A sampled behavior, i.e. a finite sequence of state-space points, is exported to the external animation software,where a suitable engine will linearly interpolate betweenany pair of adjacent samples.

Animation cycle: To define a complex animation thefollowing typical steps are required:

• Problem decomposition into animation segments, anddefinition of the storyboard as a graph.

• Modeling of geometry and behavior of the animationsegments. Each segment will be modeled, animated andtested independently from each other.

• Non-linear editing of segments, describing inPLaSM

their events and time relationships (look at example ofSection 7). The segment coordination is obtained byusing the critical path method.

• Simulation and parameter calibration of the animation asa whole.

• Feedback with possible storyboard editing, with the start-ing of a new cycle of modeling, editing, calibration andfeedback, until a satisfying result is obtained.

4. Background

This section presents some background information forbetter understanding the material presented in the paper.First the PLaSM functional approach to programming isdescribed, then the important graphics concepts of hierarch-ical assemblies and parametric curves are recalled. Finallysome concepts of network programming, including criticalpath method, are briefly described.

4.1.PLaSMmodel of computation

ThePLaSMlanguage [13] is a geometry-oriented exten-sion of a subset of the functional languageFL [5]. Generallyspeaking, eachPLaSMprogram is afunction. When appliedto some inputargumenteach program produces some outputvalue. Two programs are usually connected by using func-tional composition, so that the output of the first program isused as input to the second program. The composition ofPLaSMfunctions behaves exactly as the standard composi-tion of mathematical functions. For example the applicationof the compound mathematical functionf +g to thex argu-ment

�f +g��x� ; f �g�x��means that the functiong is first applied tox and that thefunction f is then applied to the valueg(x). The PLaSMdenotation for the previous expressions would be

�f ~g� : x ; f : �g : x �where ~ stands for functioncompositionandg:x stands forapplicationof the functiong to the argumentx .

In PLaSM, a name can be assigned to a geometric modelby defining it as a function without formal parameters. Insuch a case thebodyof the function definition will describethe computational process which generates the geometricvalue. The parameters that it depends on will normally beembedded in such a definition. For example we may have

DEF object � (Fun3~Fun2~Fun1):parameters;

The computational process that produces the object value canbe thought as the computational pipeline shown in Fig. 2.

In severalPLaSMscripts the dependence of the modelupon the parameters is implicit. In order to modify thegenerated object value it is necessary (a) to change thesource code in either the body or the local environment of


its generating function, (b) to compile the new definition and(c) to evaluate again the object identifier.

A parametric geometric model can be converselydefined, and easily combined with other such models, byusing a generating function withformal parameters. Such akind of function will be instantiated with differentactualparameters, so obtaining different output values. It is inter-esting to note that such a generating function of a geometricmodel may accept parameters of any type, including othergeometric objects.

4.2. SomeFL & PLaSMsyntax

FL is a pure functional language based on combinatoriallogic. Primitive FL objects are characters, numbers andtruth values. Primitive objects, functions, applications andsequences are expressions. An application expressionexp1:exp2 applies the function resulting from the evalua-tion of exp1 on the argument resulting from the evaluationof exp2 . Also the infix form is allowed for binary opera-tors:

1 : k1;3l � 1 1 3 � 4

Application associates to left, i.e.f : g : h � �f : g� : h:Also, application binds stronger than composition, i.e.f : g~h � �f : g�~h:

Construction functionalcons allows the application of asequence of functions to the same data. It can also bedenoted by enclosing the functions between angle brackets:

CONS:kf 1,…,f nl:x � [f 1,…,f n]:x �kf 1:x,…,f n:x l

Apply-to-all conversely allows the application of a func-tion to a sequence of data:

AA : f : kx1 ;…; xnl � kf : x1 ;…; f : xnl

The Identity function and the Constant functional havethe standard meaning:

ID : x � xK : x1 : x2 � �K : x1 � : x2 � x1

The Conditional function is defined as follows, wherep,f andg must be functions:

IF : kp; f ;g; l : x � f : x if p : x � TRUEIF : kp; f ;gl : x � g : x if p : x � FALSE

Other FL combining forms have a combinatorial beha-vior, and strongly contribute to the working of the languageas a “combinatorial engine”. In particular, the “Insert right”

and “Insert left” functions allow for (recursively) applying abinary function to a sequence of arguments of any length:

INSR:f: kx1,x 2,…,x nl� f:kx1,INSR:f: kx2,…,x nllINSL:f: kx1,…,x n21,x nl� f:kINSL:f: kx1,…,x n21l,x nl

The CAT (Catenate) function allows for appendingsequences. Several other primitive functions for sequencesare available, includingLIST , FIRST , TAIL , LAST, andthe selectorsS1;S2;…;Sn of the first, second and thenthelement of a sequence:

CAT: kka,b,c l, kd,e l,…, kx,y,w,z ll�ka,b,c,d,e,…,x,y,w,z lLIST : x � kx lS3 : ka; b; c ;d; e; f ; l � c

The two Distribute functions are applied to a paircomposed by a sequence and by any expression and gener-ate a sequence of pairs:

DISTR : kka;b; c l; x l � kka; x l; kb; x l; kc ; x llDISTL : kx ; ka;b; c ll � kkx ; al; kx ;bl; kx ; c ll

The Transpose function works exactly as a matrix compo-sition, e.g.

TRANS:kkx1,x 2l, ky1,y 2l, kw1,w 2ll�kkx1,y 1,w 1l, kx2,y 2,w 2ll

The languagePLaSM can evaluate expressions whosevalue is apolyhedral complex. This is the only new primi-tive data type, with respect toFL. Clearly, it can producehigher-level functions in theFL style. Some importantdifferences withFL exist. In particular no free nesting ofscopes and environments is allowed inPLaSM, and nopattern matching is provided.

Two kinds of functions are recognized inPLaSM: global(or top-level) functions andlocal functions. Global func-tions may contain a definition of local functions betweenWHEREandENDkeywords. Local functions may not, andcannot contain a list of formal parameters. In order to makea local functionparametricthey must necessarily adopt theFL style of function definition, using combining forms andselector functions. Notice that the visibility of local func-tions is restricted to the scope of the global function wherethey are declared.

Top level functions may contain a list of formal para-meters. They are always coupled to some predicate, whichis used to test the type of the actual parameter:


Fig. 2. Example of computational pipeline.

DEF f �a < type1 � � bodyDEF f �a1 ;…;an < type2 � � body

Notice that with more than one parameter, the applicationof the function to actual parameters requires the use of anglebrackets:

f : xf : kx1 ;…; xn l

For a complete listing and meaning of pre-definedPLaSMoperators, the interested reader should read paper [13].Anyway, most of times the operator meanings are consistentwith their names.

4.3. Hierarchical structures

Hierarchical structures are a basic graphics concept. Astructure is inductively defined as an ordered set (sequence)of structures, affine transformations and elementarygeometric objects. The semantics of the structure conceptis very simple. Every affine transformation contained in astructure is (ordinarily) applied to all the subsequent objectsthat follow it in the sequence. This application returns asequence of geometric objects all lying in the same coordi-nate space, when originally they were independently definedusing local coordinate systems.

Structures are represented as oriented acyclic graphs. Inparticular, each structure is associated with a node, whereasthe elements in its sequence are represented as the childnodes of the parent node. The structure

n� S; with S� { n1;n2;…; nk} ;

is therefore implemented as an oriented graph with

nodes {n} < Sand arcs {n} × S:

A structure network2 or hierarchical scene graph3 issimply the union of the graphs of the different structures.Such a graphis not necessarilya tree, since the same nodemay have more than one parent node at an upper level.

A traversal algorithm linearizes such a graph, suitablytransforming all the geometric objects, each one defined ina local coordinate frame, into the coordinate frame of theroot, often calledworld coordinate system. Such a traversalis often performed by some predefinedvieweravailable inthe chosen toolkit (e.g. in Open Inventor) and is executed ata suitable frequency to achieve fluid animation.

The animation effect is obtained when some of geometricparts of the scene change position, orientation or internalconfiguration. Such change is often implemented by editingthe internal values of parameters of some affinetransformation.

4.4. Polynomial parametric curve

A polynomial parametric curve is a vector-valued func-tion of a real variableu, obtained by the combination ofsome control points with the elements of a suitable polyno-mial basis in theu variable. In particular, a Be´zier curvec ofdegreen is a polynomial combination ofn 1 1 controlpointsqi [ Ed:

c : R! Ed : c�u� �Xni�0

Bni �u�qi ;

where the blending functionsBni : R! R are the Bernstein

polynomials:

Bni �u� �

n

i

!ui�1 2 u�n2i

:

Notice that the imagec(u) of the curve is a continuous set ofpoints in the same space where theqi control points aredefined, which shortly describe the curve shape. Rememberalso that a Be´zier curve interpolates the first and last controlpoints, and approximates the intermediate control points.

4.5. Network programming

We use network programming techniques to edit thecollection of animation segments. In particular, we use thedynamic programming algorithm of PERT (ProgramEvaluation and Review Technique) [10] to compute mini-mal and maximal times of events as well the completiontime of the whole animation.

PERT, also known asCritical Path Method, is wellknown for managing, scheduling and controlling verycomplex projects and computing the optimum allocationof resources. Such projects may have tens or hundred ofthousands of activities and events. This technique is themost popular variation of the network programming techni-ques, where a bundle of inter-dependent activities is repre-sented as a directed acyclic graph.

Minimal (maximal) spanning time: tk (Tk) of a nodek isthe minimal (maximal) time for completing the activitiesentering the nodek. Notice that such activities can (must)be completed into this time, respectively.Critical path method: The more important computationconcerns minimal and maximal spanning time of nodes.The dynamic programming algorithm is very easy (seeFig. 3):

tk � maxi[pred�k�

{ ti 1 Tik} ; Tk � mini[succ�k�

{ Ti 2 Tki}

There are two subsequent steps in the computation,respectively, called forward and backward computation.

Forward computationof minimal times tk. Set t0 � 0:Then try to compute the minimal timete of endingnode, i.e. the completion time of the whole project. The


2 ISO/PHIGS terminology.3 SGI/Inventor and VRML terminology.

recursive formula allows for computing thetk of all nodes(see Fig. 3a).Backward computationof maximal timesTk. SetTe � te:Then try to compute the maximal timeT0 of starting node.The recursive formula allows for computing theTk of allnodes (see Fig. 3b).Activity slacks: Theslack Sij of the arc (i, j) is defined asthe quantity of time which may elapse without a corre-sponding slack of the completion time of the project. Theactivity slack is given by

Sij � �Tj 2 ti�2 Tij ;

where Tij is the expected duration of the activity (i, j)(see Fig. 3c). Thecritical activities have empty slacks:Sij � 0:

5. Language extension

This section outlines the extensions to thePLaSMlanguage implemented for defining and exporting motiondata which may contain geometry, attributes and anima-tions. Such exporting was targeted towards commonlyavailable 3D toolkits. The reference model for such graphicsextension of thePLaSMgeometric language is the hierarch-ical scene graph. The described approach is currentlyperforming onlyoff-line geometric animations.

From the animation viewpoint the language extensionsallow the modeling of the actors and their interactions onthe scene, as well as the modeling of the independent beha-viors of animation segments. The time assembly of indepen-dent animation segments is automatically guaranteed.

The previous PLaSM implementation allowed forgeometric computations without considering non-geometricattributes such as colors, lights and textures. The currentextension introduces such non-geometric features into thelanguage, using as reference a hierarchical scene graph withnon-geometric nodes. In particular, colors, lights andtextures were added to the language [16].

A basic design decision was that of introducing onlysmall modifications to the existing language interpreter.The language was mainly extended by modifying the pre-defined functional environment. A new internal data typeand four new animation primitives were introduced into thelanguage. Such minimal extension to the language has

shown to be sufficient for implementing very complexanimated scenes, as discussed in the companion paper [14].

5.1. Static animation with classicPLaSM

In PLaSM the animation of a polyhedral scene can beimplicitly represented by explicitly giving the degrees offreedom as formal parameters of a function which generatesthe polyhedral values.

The desired behavior can also be modeled as a curve inconfiguration space. The movement can finally be emulatedby: (a) sampling the curve; (b) applying the generating func-tion of the shape on each sampled configuration (set ofparameters); and finally by (c) aggregating all the resultingpolyhedral complexes in a unique structure. The resultingcovering of the work space will therefore represent themovement.

Example (Modeling a planar arm). Consider the verysimple planar robotic arm with three degrees of freedomshown in Fig. 4a. There are three rotational degrees of free-dom, respectively, nameda1, a2 anda3

DEF rod � T: k1,2 l: k 2 1, 2 19l:(CUBOID: k2,20 l)DEF DOF(alpha < IsReal) � T:2: 218~R: k1,2 l:alpha;DEF arm(a1,a2,a3 < IsReal) � STRUCT:krod,DOF:a1,rod,DOF:a2,rod,DOF:a3,rod l

Example (Modeling a movement). The desired move-ment is modeled as a cubic Be´zier curve defined by fourpoints in configuration space�2p;p�3 , R

3: Such a curve

is shown in Fig. 4b. Notice that theSampling functionproduces a sampling of the unit internal [0,1]. The imple-mentation of the Be´zier curve mapping is given in AppendixA.4

DEF CSpath � Bezier: kk0,0,0 l,kPI/2,0,0 l, kPI/2,PI/2,0 l,kPI/2,PI/2,PI/2 ll;DEF Sampling(n < IsIntPos) �(AA:LIST~AA:/~DISTR): k0..n,n l;

Such a movement is emulated by applying thearm


Fig. 3. (a) Forward computation of nodek. (b) Backward computation of nodek. (c) SlackSij shown in the earliest_start scheduling of the (i,j) segment.

function to a sequence of 18 curve samples and by accumu-lating the resulting polyhedral complexes in a structure:

(STRUCT~AA:arm~AA:CSpath):(Sampling:18)

The geometric result obtained by evaluating the abovePLaSMexpressions is displayed in Fig. 4c.

5.2. Animation with extendedPLaSM

For the purpose of defining and exporting animations, wehave introduced four new primitives inPLaSM, respec-tively, denoted asFRAME, XSTRUCT, MOVE, ANIMATION.The representation of background objects does not requirenew primitives.

Background: The time-invariant objects in the scene aresimply defined as standard polyhedral complexes, byusing polyhedrally typedPLaSMexpressions.FRAMEprimitive: TheFRAMEprimitive is used to repre-sent a static portion of the foreground, i.e. a segment withconstant configuration. Such a primitive is first applied tothe static geometry, i.e. to a polyhedral complex. Theresult is then applied to an increasing pair of time values.The two time values define the existence interval of suchgeometry in the scene. Each animation is assumed to startat local timet � 0: The special time symbol21 is used todenote the final time of the storyboard.XSTRUCTprimitive: TheXSTRUCTprimitive is used todefine parameterized polyhedral complexes, which corre-spond to the new internal data type XHPC of extendedPLaSM. The syntax and usage are equivalent to theSTRUCTprimitive, which is used to generate assemblies.Its semantics requires a lazy evaluation mechanism,where a set of parameters is left unbound for subsequentuse.MOVEprimitive: The MOVEprimitive is used to imple-ment the behavior of a dynamic foreground segment. Itrequires three cascaded applications. First it is applied toa function, parameterized on the degrees of freedom ofthe segment and returning a value of XHPC type. Theresulting function is then applied to the sampled

trajectory in the segment configuration space. Finally,the function resulting from the latter application isapplied to a conformal sequence of time steps.ANIMATION primitive: The ANIMATION primitive isused (likewise a container) to define and export the setof motion data for a given background and foreground. Itsinput is a sequence of either polyhedral complexes, orFRAMEexpressions orMOVEexpressions. As a side effectof its evaluation the motion files and directories displayedin Fig. 1 are generated. Such files will be used by thecoupled animation server for the animation play-back.

Example (Modeling arm motion and geometry). In orderto discuss the extensions toPLaSM, the robot arm examplehas been animated according to the behavior curve alreadypresented. The extendedPLaSMcode for the description ofboth the planar arm and its motion is given in the following:

DEF background �(EMBED:1~T:2: 2 90~CUBOID): k100,100 l;DEF Rod� T: k1,2 l: k 2 1, 2 19l:(CUBOID: k2,20,1 l);DEF dof(alpha < IsReal) �T:2: 2 18~R: k1,2 l:alpha;DEF Arm(a1,a2,a3 < IsReal) � XSTRUCT:

kRod, dof:a1, Rod, dof:a2, Rod, dof:a3,Rodl;

DEF t1 � 2;DEF t2 � t1 1 5;DEF Sample(n < IsIntPos) �(AA:LIST~A:/~DISTR): k0..n,n l;DEF Motion � Bezier: kk0,0,0 l, kPI/2,0,0 l, kPI/2,PI/2,0 l, kPI/2,PI/2,PI/2 ll;DEF Time � Bezier : kkt1 l; kt1 1 1l; kt2 ll;DEF CSpath � �AA : Motion ~Sample � : 18 ;DEF TimePath �(CAT~AA:Time~Sample):18;DEF FirstConfiguration �(STRUCT~Arm): k0,0,0 l;DEF LastConfiguration �(STRUCT~Arm): kPI/2,PI/2,PI/2 l;DEF Storyboard � ANIMATION : k


Fig. 4. (a) Planar arm configuration generated byarm: kPI/6,PI/4,PI/3 l. (b) Cubic Bezier curve in configuration space. (c) Geometric object generatedby (STRUCT~AA:arm~AA:Cspath):(Sampling18) .

background,FRAME:FirstConfiguration: k0,t1 l,MOVE:Arm:CSpath:TimePath,FRAME:LastConfiguration: kt2, 2 1l

l;

The previous example is a simple instance of our anima-tion model, with only one animated actor. In this case thestoryboard is a linear graph with three arcs, as shown in Fig.5. The first and last segments are static, the second one isdynamic.

6. Test environments

The described animation methodology was experimentedin two settings. A simple Open Inventor-based animationserver has been implemented to allow local play-back ofPLaSM-generated animations. A web-based visualizationframework is also under development to address issues ofuser-collaboration over wide-area networks.

6.1. Open inventor animation server

The visualization server MOV (Motion with Open inVen-tor) was implemented on the IRIX and NT platforms, soallowing local play-back both on high-end workstationsand desk-top PCs. MOV (see architecture in Fig. 6a) takesas input the motion data generated byPLaSMwith informa-tion about: the geometry of actors; their configuration spacepath; the corresponding timeline data; the position, orienta-tion and motion of animated cameras; the backgroundobjects, etc. The motion data set also includes a.prjproject file, with a set of general directives to the player,

like the number of frames per second, the starting andending frames, the display resolution, the setting of staticcameras, the background color, and so on. When the serveris used interactively, the user can browse the animationframe by frame, backward and forward, with interactivecamera control and selection, including all the standardcapabilities of the Inventor’s Examiner Viewer.

The motion data set is used to generate an Inventor scenegraph (see Fig. 6b) and an internal database. The unboundparameters in the XHPC values are mapped symbolically byPLaSMinto labels which are defined in the motion data andreferred in the Inventor geometries. This mechanism allowsto optimize the MOV play-back. Three execution modalitiesare available: real-time, step-wise and off-line. In real-timemode the server tries to synchronize the animation time tothe clock time, eventually dropping some frames. In step-wise mode all the frames are displayed independently fromthe rendering time. In batch-mode a sequence of pictures(jpeg, rgb or bmp) is saved into secondary memory. This isuseful for movie generation and editing.

6.2. Experimental web animation system

We have also built an experimental web animationsystem that uses a simple web-based visualization client(ShaPoly), two domain specific servers (Gati andPLaSM)and the Shastra collaboration toolkit to integrate the appli-cations (see Fig. 7). The visualization client is a Java/VRMLapplication downloadable from a remote web server. Gati isa dedicated animation server for generating complex anima-tions from a high-level declarative language. ThePLaSMserver, as widely discussed in the previous sections,provides the modeling and animation functionalities. It


Fig. 5. The very simple storyboard of the plane arm animation example.

Fig. 6. (a) MOV server architecture. (b) Animated Inventor scene graph generated by MOV fromPLaSMinput.

provides a powerful high-level language for describingcomplex geometric scenes and objects simply. The Shastracollaboration toolkit is a collection of libraries and applica-tions that create a web-based collaborative networked envir-onment.

6.2.1. Static architectureShaPoly is a Java/VRML collaborative object browser

that can retrieve 3D objects, scenes, and animations fromremote applications. It has a simple graphical user interfacefor displaying and manipulating three dimensional scenesand animations. Using the Shastra collaboration toolkitmultiple ShaPoly applications can be used collaboratively.

ThePLaSMinterpreter accepts high-level descriptions ofobjects, scenes, and animations and in conjunction with theGati animation server generates simplified descriptions ofthese scenes and animations. These simplified descriptionsare then returned to the ShaPoly client for visualization.

Gati is a programmable animation server. It is capable ofprocessing multiple remote requests for animations. Scenedescriptions with complex animations are submitted to theserver and simplified scenes and animations are returned asa result.

The Shastra collaboration toolkit is a collection oflibraries and specialized applications that can be used tocreate powerful collaborative and distributed applications.The toolkit is both Java and C11 based, allowing bothC11 and Java collaborative applications to be createdand inter-operate. The toolkit provides communication,coordination, and collaboration mechanisms for applica-tions.

6.2.2. Runtime architectureSome users interact with the visualization client to send

geometric descriptions to thePLaSMserver that generatesrepresentations for scene and animation. This representationis passed to Gati which generates the low-level translationtransmitted to the visualization client which displays theanimation.

The animation is begun by the users pointing their web

browser to a web server and downloading the Java ShaPolyvisualization client. After the client is downloaded the userwill be automatically connected to the Shastra collaborationenvironment. This allows them to access all the networkresources active within the environment.

A user uses the ShaPoly visualization client to create ascene graph with objects that can be imported by thePLaSMinterpreter. A simple graphical user interface is provided forcreating scenes of user defined polyhedral objects. Aftercreating a scene a user can then attach aPLaSMscript tothe scene specifying the motion to be applied to objectswithin the scene. Alternatively the user may sketch outspace curves for objects within the scene to follow andgraphically attach them to the scene objects (the interfacewill generate the correspondingPLaSMcode).

Once defined a scene and animation can be submitted to aremotePLaSM server. The user selects aPLaSM serverfrom a list of available servers provided by the Shastrakernel resource manager. If noPLaSMserver is executingthe user may request that one by starting and the Kernel willstart a remotePLaSMserver.

After the remotePLaSMserver has been selected the userdefined scene and animation is converted to aPLaSMgeometric language description and submitted to the serverusing the Shastra communication layer. ThePLaSMserverthen processes the code and generates the motion datadescribed in the previous sections of this paper. Such dataare submitted to a Gati server specified within the geometriclanguage code. The scene and motion data are transferred tothe Gati server using the Shastra communication layer.

Finally Gati generates a sequence of atomic transforma-tions (events) that the viewer can execute directly. Theresulting scene and animations are then streamed to theoriginal visualization client where they can be played andreplayed by the user.

7. Example

In this section a complete example of scene modeling andanimation is discussed. The example closely resembles thefamousLuxo Lampanimation by Michael Kass and AndrewWitkin [7]. In our case two similar lamps are movingtogether by describing a quite complex path in their config-uration spaces.


Fig. 7. Web animation architecture.

Fig. 8. (a) The lamp model in a given configuration. (b) Some key-framesalong a segment animation.

In Section 7.1 the geometric models of the lamp compo-nents are generated, and the lamp assembly is defined inlocal coordinates (see Fig. 8). In Section 7.2 the storyboardof the animation is given, where the movements of the twoactors are both specified and coordinated (see Fig. 9). In theappendices a quite small set of relatedPLaSMcode is given,together with the specification of the CS paths of the variousanimation segments.

Notice that the given example code is a complete workingimplementation, which can be directly executed under aPLaSM interpreter, obtaining a set of files to be executedunder the control of either a Gati or MOV interface.

7.1. Geometry modeling

Design parameters: In order to generate different lampinstances, the lamp code has been parameterized withrespect to the length and side of rods and to the radius andheight of the basis.

DEF rodHeight � 20;DEF basisRadius � 20;DEF rodSide � SQRT:2;DEF basisHeight � 2;

Geometric model of parts: First the lamp rod, namedJointedRod , is generated. It is an assembly, along thezcoordinate, of amaleJoint , a rod , and a female-Joint .

DEF halfHinge2D � circle:PI:1:12;DEF hinge2D � STRUCT:khalfHinge2D,T: k1,2 l: k 2 1, 2 3l,Q:2*Q:3;DEF hinge � hinge2D*Q : 0:5;DEF DoubleHinge � STRUCT:khinge,T:3:1.2,hinge l;DEF hbasis � circle:(2*PI):1.2:24*Q:2;DEF femaleJoint � STRUCT:

kT:3: 2 5:hbasis,T:2:0.85,R: k2,3 l:(PI/2):DoubleHinge l;

DEF maleJoint � STRUCT:kR: k2,3 l:PI,

T:3: 2 5:hbasis,T:2:0.25,R: k2,3 l:(PI/2):Hinge l;

DEF rod � T:k1,2 l: krodSide/ 22,rodSide/ 22l:�CUBOID: krodSide ; rodSide ; rodHeight l�;

DEF JointRod �maleJointTOP rod TOP femaleJoint;

In the previous code notice that infix binary operators(like TOP) are left-associative. Then the lampbasis andhead are defined, where the conic part as well the cylinderpart are both generated by using the functionTrunCone ,whose definition is given in the appendix. Thehead func-tion depends on an implicit integer parameter, which speci-fies the grain of the polyhedral approximation of surfaces.

DEF basis � (circle:(2*PI):basisRadius:32*Q:basisHeight)

TOP femaleJoint;DEF head� STRUCT~[K:maleJoint,K:(T:3:5),embed:1~circle:(2*PI):4,

TrunCone: k4,4,8 l,K:(T:3:8),TrunCone: k4,20,20 l];

Luxo lamp assembly: The lamp as a parametric hierarch-ical geometric model is defined as follows. Notice that theoffset of joints from their center of rotation is5, and that aJointedRod contains two such joints. This explains theterm10 in thez translation parameter�rodHeight 1 10�:

DEF Luxo�a1 ; a2 ; a3 < IsReal � � XSTRUCT: kbasis,T:3:(basisHeight 1 5),R: k1,3 l:a1,JointedRod,T:3:(rodHeight 1 10),R: k1,3 l:a2,JointedRod,T:3:(rodHeight 1 10),R: k1,3 l:a3,head:32

l;

Notice also that the Luxo function has signatureR3 !

XHPC: So, the generated values are polyhedral complexes,extended with non-geometric entities like colors, anddepending on three degrees of freedom. When used withangle values in degrees, a conversion function to gradientsmust be applied to input data.

Luxo:(convert: k 2 90,90,90 l);

7.2. Motion modeling and coordination

Mobile lamp: A 3D object sliding on the ground has threeadditional degrees of freedom, corresponding to one rotationand two translations

DEF mobileLuxo(a1,a2,a3,a4,a5,a6 < IsReal) �


Fig. 9. Some key-frames of the animated example.

XSRUCT:kT:1:a1,T:2:a2,R: k1,2 l:a3,Luxo: ka4,a5,a6 ll;

Luxo’s and friend’s paths: As already stated, the animationstoryboard is given as a network model, with animationsegmentsassociated to the arcsand (coordination)eventsasso-ciated to the nodes.The expecteddurations ofsingle animationsegments are first given. The dummy segments, drawn ashatched in Figs. 10 and 11, are used only as constraints andhave duration zero. ThePLaSMrepresentationluxo_pertof the graph in Fig. 10 is the sequence of the graph’s arcs. Eacharc is a tripleks,e,t l wheres is the starting node,e theending node andt the duration time of the arc.

DEF luxo_pert � kk0,1,2 l, k1,2,5 l,k2,3,3 l, k3,4,4 l, k1,5,0 l, k6,2,0 l, k2,7,0 l,k8,3,0 l, k5,6,10 l, k6,7,5 l, k7,8,2 ll;

Coordination events: The minimal and maximal spanningtimes of storyboard events are computed from the story-

board network shown in Figs. 10 and 11. The minimaltimes ti are computed astmin:0,…,tmin:8 . The maxi-mal times Tj are computed astmax:0,…,tmax:8 .Appendix A.3 reports of a possible simple implementationof the functionstmin and tmax . Example of curve insegment CS: One of the configuration space curves of thestoryboard segments is given in the following:

DEF CSpath_0_1 � AA:((Bezier~AA:XCAT): kk100 ;0; convert : k0; 0;0;0ll;k150 ;0; convert : k30 ;30 ;0;210ll;k200 ;50 ; convert : k 2 150 ;220 ;90 ; 0ll;k200,100,convert: k90 1 180,2 60,105,60 ll

l);

It is generated as a Be´zier curve of degree 3 in a configura-tion space of dimension 6. ThePLaSMfunction generatingBezier curves of any degree in anyd-dimensional space isgiven in Appendix A.4. The remaining CS curves are alsogiven in the appendix.

Choreographic control: The timing of the (i,j) segment ofthe storyboard may be computed by using either minimal ormaximal spanning times for the starting and ending eventsof the segment. If the�ti ; tj 1 Tij � pair is used, then thesegment is executed “earliest”. If the�Tj 2 Tij ;Tj� pair isused instead, then the segment is executed “latest”.

More interesting, when the pair�ti ;Tj� is used, thesegment timing is automatically adapted to the finish andstart times of the incident segments. If such a choice is donefor all the “critical” segments, i.e. for all segments on thecritical path, their animation will be executed as completelyfluid, and no actors must stop and wait for restart in suchstoryboard segments.

This choice cannot by directly assumed for non-criticalsegments, since if (h,i), (i,k) are two incident non-criticalsegments, it would beTi ± ti ; so that the timing given by�th;Ti� and �ti ;Tk� would produce a time overlap for theirexecution.

A good solution is that of assuming for all events thetiming given by their average spanning time, i.e. to usethe timing�tmj ; tmj � for each segment (i,j), with

tmi � ti 1 Ti

2for all i �1�

This clearly impliestmi � ti � Ti for critical events, andprevents from time overlaps for non-critical events.

It is very important to notice that the “fluidity constraint”of the whole animation induced by Formula (1) holds for anypossible choice of expected durations of animation segments.

In PLaSM the average spanning timestmi ; with i �0;…;8; can be computed astm:0,…,tm:8 using thefunction tm below

DEF tm(node < IsInt) �(tmax:node 1 tmin 1 node)/2;


Fig. 10. Representation of the storyboard as an abstract graph.

Fig. 11. Projection inE2 of the storyboard embedded in configuration space.

Scene animation: The whole animated scene can befinally generated by just evaluating the followingANIMA-TION expression, which contains aMOVEexpression foreach storyboard segment. A number of 10 behavior samplesis generated here for each segment

DEF steps � Sampling : 10 ;DEF step � Sampling : 1;DEF SceneAnimation � ANIMATION : k

FloorPlane,MOVE:mobileLuxo:(CSpath_0_1:steps):(time: ktm:0,tm:1 l:steps),MOVE:mobileLuxo:(CSpath_1_2:steps):(time: ktm:1,tm:2 l:steps),MOVE:mobileLuxo:(CSpath_2_3:steps):(time: ktm:2,tm:3 l:steps),MOVE:mobileLuxo:(CSpath_3_4:steps):(time: ktm:3,tm:4 l:steps),FRAME:((MkStruct~mobileLuxo):((S1~CSpath_5_6):step)): k0,tm:5 l,MOVE:mobileLuxo:(CSpath_5_6:steps):(time: ktm:5,tm:6 l:steps),MOVE:mobileLuxo:(CSpath_6_7:steps):(time: ktm:6,tm:7 l:steps),MOVE:mobileLuxo:(CSpath_7_8:steps):

(time: ktm:7,tm:7 1 0.6*

(tm:8 2 tm:7),tm:7 1 0.8*(tm8 2 tm:7),tm:8 l:steps),

FRAME:((MkStruct~mobileLuxo):((S2~CSpath_7_8):step)): ktm:8, 2 1l

l;SceneAnimation;

Segment sub-timing: The approach shown in this paperallows any sub-timing of segments, according to the degreeof the Bezier map�0;1� ! �0;∞� used to generate the timesamples passed to theMOVEprimitive. This gives theanimator the maximal freedom in accelerating/deceleratingthe animation speed within any segment, alsomaintainingthe constraint of fluidity of the full animation.

As an example of non-linear sub-timing, look at segment(7,8) of the above example, where the time samples aregenerated by the partial map

time: ktm:7,tm:7 1 0.6*(tm:8 2 tm:7),tm:7 1 0.8*(tm:8 2 tm:7),tm:8 l:steps

wheretm:7 , t:m8 , respectively, stand fortm7 ; tm8 : Since theBehavior function, given in Appendix A.2, is applied to asequence of four values, the time sampling is done with acubic real-valued Be´zier map. According to the four controlvalues, which are not equally spaced in the interval�tm7 ; tm8 �;the samples are accumulated towards the interval end, so


Fig. 12. Animation preview by super-imposition of segment key-frames.

suitably decelerating the first part and accelerating thesecond part of the (7,8) segment animation (see Fig. 12).

8. Conclusions and future directions

The present paper introduces a new approach for thesymbolic definition of complex animated geometric scenes.The full integration between the design of both the shape ofthe elements in the scene and their dynamic behaviors isobtained by implementing both modeling and animationwithin the PLaSMlanguage. For this purpose the languagehas been extended with a minimal set of new primitivesshown to be sufficient to design complex animated scenes.

The flexibility of the presented methodology derives fromthe representation of the animation storyboard as a discreteaction network that allows first to define/edit each animationsegment independently and then to automatically integrateall the segments in the global animation. Moreover, anyanimation segment can be in turn decomposed into a localsub-network of lower-level animation segments in a hier-archical fashion.

The effectiveness of the present approach has been testedalso in practice. A substantial test-bed was for example thelarge-scale reconstruction of a catastrophic event describedin the companion paper [15]. In this case all the typicalchallenges that arise in dealing with real-life data weresuccessfully met.

Further development of this research is planned along twomain directions. First thePLaSManimation kernel needsfurther extensions to remove the current limitation to off-line definition of animated scenes. We plan to introduce theconcept of online animation of reactive environments withthe concurrent definition of alternative behaviors. Secondwe plan to improve the user-level interaction implementinga new visual interface for automatic generation ofPLaSMfunctions. In this way we aim to relieve most of the time theuser from the need to write directlyPLaSMdefinitions.

Acknowledgements

The work of C. Baldazzi, A. Paoluzzi and M. Vicentinowas partially supported by CERTIA Research Centerproject on visualization of simulation.

Appendix A

The PLaSM packages used in the examples are givenhere. Together with the code formerly given they constitutea full implementation of the examples, including Be´ziercurves of any degree and critical path method algorithm.

A.1. Geometry toolbox

The smallest set of geometry functions to implement theLuxo geometry is given here. Remember thatPLaSMdo not

have a significant set of pre-defined shapes, but allows forquite simple implementation of needed shape generatorfunctions

DEF Q� QUOTE~IF : kIsSeq ; ID ;LIST l;DEF ButLast � REVERSE~TAIL ~REVERSE;DEF circle(a < IsReal)(r < IsReal)(n < IsInt) �

(S: k1,2 l: kr,r l~JOIN):(MAP:([cos,sin]~s1):((Q~#:n):(a/n)));

DEF TrunCone(r1,r2,h < IsReal)(n < IsInt) �

MAP:[x*cos~s2,x*sin~s2,z]:(Q:1*(Q~#:n):(2*PI/n))

WHEREx � K:r1 1 s1*(K:r2 2 K:r1), y � K:0,z � s1*k:h

END;

A.2. Motion toolbox

The small toolbox of utility functions to sample the [0,1]interval, to convert from degrees to radiants, etc. is givenhere. The recursiveMkStruct function allows to trans-form a XHPC value with bounded parameters to a HPCvalue. It is used to generate a polyhedral actor value for aspecified value of degrees of freedom

DEF Sampling(n < IsIntPos) �(AA:LIST~AA:/~DISTR): k0..n,n l;DEF convert(seq < IsSeqOf:IsReal) �(AA:*~DISTL): kPI/180,seq l;DEF XCAT� CAT~AA : �IF : kIsSeq ; ID ;LIST l�;DEF time(tseq < IsSeqOf:IsReal) �(CAT~AA:(Bezier:(AA:LIST:tseq)));DEF behavior(Constraints < IsSeq)(CSpath < IsFun)(nSamples < IsInt) �

(aa:AL~trans~[time:Constraints,CSpath]):(Sampling:nSamples)

DEF MkStruct � IF: kOR~[IsFun,IsPo1],ID,STRUCT~AA:MkStruct . ;

A.3. Utility functions to query the graphluxo_pert

A full PLaSMimplementation of the critical path methodis given here. A more efficient solution is out the scope ofthe present paper. The functionsrmin and rmax , respec-tively, return the minimum and maximum element of asequence of reals; theinarcs and outarcs functionsreturn the sequences of either the entering or the leavingarcs from a given node, where the arcs are represented astriples (see Section 7.2), and a graph is represented as asequence of such triples

DEF greater(a,b < IsReal) �IF: kGT:a~s2,s2,s1 l: ka,b l;DEF lesser(a,b < IsReal) �IF: kLT~s2,s2,s1 l: ka,b l;DEF rmax(seq < IsSeqOf:IsReal) �


INSR:greater:seq;DEF rmin(seq < IsSeqOf:IsReal) �INSR:lesser:seq;DEF inarc(node7 < IsInt)(arc < IsSeq) �IF: kEQ~[K:node,S2],[[s1,S3]],K: kll:arc;DEF outarc(node < IsInt)(arc < IsSeq) �IF: kEQ~[K:node,S1],[[s2,S3]],K: kll:arc;DEF inarcs(node < IsInt)(graph < IsSeq) �(CAT~AA:(inarc:node)):graph;DEF outarcs(node < IsInt)(graph < IsSeq) �(CAT~AA:(outarc:node)):graph;DEF tmin �node < IsInt � � rmax : �tpredecs �WHERE

predecs � inarcs : node : luxo_pert ;

tpredecs � IF: k~[LEN,K:0],K: k0l,AA:( 1~[tmin~S1,S2]) l:predecs

END;DEFtmax�node < IsInt � � rmin : �tsucces �WHERE

succes � outarcs : node : luxo_pert ;

tsucces � IF: kEQ~[LEN,K:0],K: ktmin:node l,AA:( 2~[tmax~S1,S2]) l:succes

END;

A.4. Bezier curves of any degree

Bezier curves of any degreed embedded in any dimen-sional space are given here. They are implemented as mapsfrom a 1D polyhedral complex to the targetnD space. Themapping is generated as a linear combination of thed 1 1control points with the Bernstein/Be´zier polynomial basis ofdegreed

DEF Fact �n < IsInt � � * : �CAT : kk1l;2::nl�;DEF BinCoeff(n,i < IsInt) � Fact:n/(Fact:i*Fact:(n 2 i));DEF Bernstein �n < IsInt ��i < IsInt � �

*~[K:(BinCoeff: kn,i l),**~[ID,K:i],**~[ 2~[K:1,ID],K:(n 2 i)]]~s1;

DEF BernsteinBase(n < IsInt) �AA:(Bernstein:n):(0..n);DEF Bezier(ControlPoints < IsSeq) �(CONS~AA:( 1~AA:*~TRANS)~DISTL):

kBernsteinBase:degree,(AA:(AA:K)~TRANS):ControlPoints l

WHEREdegree � LEN : ControlPoints 2 1

END;

A.5. Segment CS curves

The symbolic description of the CS paths of the lamp’ssegments is shown here. The example given in the paper isso completely reproducible.

DEF CSpath_0_1 � AA : ��Bezier ~AA : XCAT� : k

k100 ; 0; convert : k0;0;0; 0ll;k150 ; 0; convert : k30 ; 30 ; 0;210ll;k200 ; 50 ; convert : k 2 150 ;220 ;90 ;0ll;k200 ; 100 ; convert : k90 1 180 ;260 ;105 ; 60ll

l);DEF CSpath_1_2 � AA : ��Bezier ~AA : XCAT� : k

k200 ; 100 ; convert : k90 1 180 ;260 ;105 ; 60ll;k200 ; 150 ; convert : k60 ;230 ;80 ;20ll;k150 ; 200 ; convert : k20 ;220 ;60 ;90ll;k100,200,convert: k 2 90 1 180,2 20,30,30 ll


k100,200,convert: k 2 40 1 180,2 20,30,30 ll,k50 ;200 ; convert : k 2 20 ;30 ;0;210ll;k0; 150 ; convert : k 2 40 ;220 ;90 ;0ll;k0; 100 ; convert : k90 1 180 ;230 ;55 ;40ll


k0; 100 ; convert : k90 1 180 ;230 ;55 ;40ll;k0; 50 ; convert : k 2 120 ; 30 ; 0;210ll;k0; 20 ; convert : k 2 60 ;220 ;255 ; 20ll;k0; 0; convert : k0;20;0; 0ll


k100 ;2100 ; convert : k0;60 ;260 ; 90ll;k100 ;250 ; convert : k30 ;0;0;210ll;k150 ; 0; convert : k 2 150 ;220 ; 90 ; 0ll;k150 ; 100 ; convert : k90 ;290 ;145 ; 45ll


k150 ;2100 ; convert : k90 ;290 ;145 ;60ll;k150 ; 150 ; convert : k60 ;260 ;80 ;80ll;k250 ; 250 ; convert : k20 ;60 ;260 ;90ll;k100 ; 250 ; convert : k 2 40 ;45 ;2130 ;90ll


k100 ; 250 ; convert : k 2 40 ;45 ;2130 ;130 ll;k 2 50 ;250 ; convert : k 2 20 ;230 ; 20 ; 0ll;k100 ; 100 ; convert : k 2 40 ;20 ;290 ;250ll;k50 ;0; convert : k90 ;45 ;2145 ; 80ll

l);

References

[1] Alias Wavefront (Silicon Graphics). Maya. http://www.aw.sgi.com/entertainment/solutions/complete/index.html

[2] Alias Wavefront (Silicon Graphics). Power Animator. http://www.aw.sgi.com/pages/home/pages/products/pages/poweranimator

[3] Bajaj CL, Anupam V. SHASTRA—an architecture for developmentof collaborative applications. International Journal of Intelligent andCooperative Information Systems 1994;3(2):155–172.

[4] Bajaj CL, Cutchin S. The GATI client–server animation toolkit. In:Thalmann N, Thalmann D, editors. Proceedings of ComputerGraphics International, CGI93. Communicating with Virtual Worlds,Berlin: Springer, 1993. pp. 413–423.

[5] Backus J, Williams JH, Wimmers EL. An introduction to the


programming language FL. In: Turner DA, editor. Research topics infunctional programming, 1990.

[6] Electric Image. http://www.electricimage.com/product/ei/index.html[7] Foley J, van Dam A, Feiner A, Hughes J. Computer graphics: prin-

ciples and practice, 2. Reading, MA: Addison Wesley, 1993.[8] Gleicher M. Retargeting motion to new characters. ACM Siggraph 98

Conference Proceedings, Annual Conference Series, Reading, MA:Addison Wesley, 1998. pp. 33–42.

[9] Grzeszczuk R, Terzopoulos D, Hinton G. NeuroAnimator: fast neuralnetwork emulation and control of physics-based models. ACMSiggraph 98 Conference Proceedings, Annual Conference Series,Reading, MA: Addison Wesley, 1998. pp. 9–20.

[10] Kelley JE, Walker MR. Critical path planning and scheduling.Proceedings of the Eastern Joint Computer Conference, 1959.

[11] Kinetics. 3D Studio Max. http://www.ktx.com/3dsmaxr3/[12] NewTek. LightWave. http://www.newtek.com/products/framese-

t_lightwave.html[13] Paoluzzi A, Pascucci V, Vicentino M. Geometric programming. A

programming approach to geometric design. ACM Transactions onGraphics 1995;14(3):266–306.

[14] Paoluzzi A, D’Ambrogio A. A programming approach for complexanimations. Part II. Reconstruction of a real disaster. Computer AidedDesign 1999;31:711.

[15] Pascucci V, Ferrucci V, Paoluzzi A. Dimension independent convex-cell based HPC: skeletons and product. International Journal of ShapeModeling 1996;2(1):37–67.

[16] Paoluzzi A, Francesi S, Portuesi S, Vicentino M. Rapid developmentof VRML content via geometric programming. Fifth EurographicsWorkshop on Virtual Environments. Vienna, Austria, 31 May–1June 1999.

[17] Pausch R, Burnette T, Capeheart AC, Conway M, Cosgrove D,DeLine R, Durbin J, Gossweiler R, Koga S, White J. Alice: rapidprototyping system for virtual reality. IEEE Computer Graphics andApplications 1995;15(3):8–11.

[18] Richter-Gebert J, Kortenkamp UH. The interactive geometry softwareCinderella (Interactive geometry on computers, New York: Springer,1999.

[19] Side Effects Software. Houdini. http://www.sidefx.com/product/index.html

[20] SoftImage. SoftImage V3.8. http://www.softimage.com/Products/3D/default.htm

[21] Watters A, van Rossum G, Ahlstrom J. Internet programming withPython, New York: MIS Press/Henry Holt publishers, 1996.

[22] Wernecke J. The inventor mentor, New York: Addison Wesley, 1994.


a programming approach for complex animations. …...a programming approach for complex animations....

Documents