Three-dimensional static Animation of computation

8/7/2019 Three-dimensional static Animation of computation

1/20


2/20

` Introduction

`

3D-Algorithm Animation Language` Implementation

` Application Example

` Evaluation


3/20

We distinguish in our work between two classes of algorithm visualizations:

Static animations

Visual simulations (also called dynamic animations)

3D-algorithms are algorithms that can only be or can be better visualized in a

three-dimensional scene. There is a variety of 3D-algorithms in the fields of

computer graphics and bioinformatics such as Ray tracing, RNA predicting

algorithms etc.


4/20

Static animations:

A static animation is a constant, unchangeable sequence of frames, which does

not support any user interactions that could influence the frames content. The

behavior of the algorithm or the data structure is in each run of the animation

the same. The input data for the algorithm or the data structure has beendefined by the animation author at the point of creation and can not be modified

anymore. Learning takes place by observing the animation film in a passive

way.


5/20

Visual simulations (also called dynamic animations) :

Visual simulations on the other hand are dynamic animations with an

underlying real-time simulation of the algorithm or the data structure. Beyond

restarting, aborting and resuming the animation the user can interact with the

animation in different ways depending on the interaction level supported by the

simulation author at implementation time. Thus the user has the possibility to

change the input data of the algorithm during the execution of the simulation or

to insert, delete and modify elements of the simulated data structure.

None of these operations are possible in static animations


6/20

An essential feature of the new standard is its ability toanimate any 3D

algorithms that meet all requirements proposed invarious studies so far.

` The language should support modeling and utilizationof data structures along with its associated operationsin a most convenient way.

` This implies that complex data structures (trees,

graphs, multidimensionalarrays, etc.) are fully supported or at least easy to

construct.


7/20

` The language should be easy to learn. Authors

without any, or with only

sparse programming skills, should be given the

opportunity to createanimations without much additional effort.

` The syntax of the language a platform-

independent and portable format should be used

which does not only support the manual, but alsotool-based script production.


8/20

XML standard which supports the creation of general animations is the well

known X3D standard [12]. X3D is an XML based 3D description language for

interactive 3D contents, which could also be used for the animation of

algorithms and data structures.

X3D is too powerful. In order to be applicable, the entire scheme must be

learned first. This contradicts our demand that the animation language should

be easy to learn.

If more complex data structures and methods are required, a huge number of

graphic primitives must be initialized first, in order to combine them into the

desired data structures in X3D. Algorithm animation specific concepts such as

displaying source code, code highlighting, syntax-coloring, quiz, announcement

of narratives and documentation etc. must be encoded in X3D manually. The

embedding of an existent X3D interpreter in an existing algorithm animation

system would be complicated.


9/20

For all these reasons Computer Graphics an XML standard for the three-dimensional animation of the previously mentioned class of algorithms was

developed and gave this standard the name Xml3DVis which fulfils the

essential requirements.

Independent of this work, developed a prototype of an algorithm visualization

platform called 3D-VISIAN(Three-dimensional Visual Simulation andAnimation System for Algorithms and Data structures) which allows to load and

play three-dimensional static animations and visual simulations in real-time. A

considerable aspect in developing an animation interpreter is providing

unlimited linear undo/redo functionality. Animations not supporting the undo

functionality are considered ineffective. As the player of xml3DVis provides

complete undo/redo functionality the animation author does not need to care

about it.


10/20

3D-Algorithm@inproceedings{conf/csse/BakerK08,

title = {Three-Dimensional Static Animation of Computation-Intensive 3D

Algorithms.},

author = {Ashraf Abu Baker and Stefan Kappes},

booktitle = {CSSE (5)},

crossref = {conf/csse/2008-5},

pages = {434-437},

publisher = {IEEE Computer Society},

url = {http://dblp.uni-trier.de/db/conf/csse/csse2008-5.html#BakerK08},

year = {2008},

description = {dblp},

ee = {http://dx.doi.org/10.1109/CSSE.2008.514}, isbn = {978-0-7695-3336-0},

date = {2009-01-28},keywords = {dblp }

}


11/20

This prototype system was written in C and created to run underMicrosoft

Windows TM version 3.1 and later on IBM PC compatibles.This particular platform was selected primarily for its low cost and

familiar

user interface. Currently, a 486/66 DX with 8MB RAM and local busgraphicsis more than adequate to support the system with reasonable

animationspeeds.

Similar to AACE's user interface, tape deck type controls are theprimary user

interface for the system which is yet flexible way to control theanimations.


12/20

Similar to AACE's user interface, tape deck type controls are theprimary user

interface for the system which is yet flexible way to control theanimations.

The system supports algorithm execution in forward or reverse(roll-back

mode) by utilizing temporary event log files. It is primarily an event-based

system similar but not identical to systems such as BALSA. To

create asystem specifically tailored to visualize computer graphics

renderingalgorithms was our original objective


13/20

In addition to displaying the vector-guided view, the system can also maintain

several other views, including textual and actual views.

In the ray tracing animation created here, a text view is used to display source

code and highlight lines as they are executed. An actual view maintains any

output that the algorithm is writing to the screen or graphics display. This view

was built to display any graphics calls (putting pixels, drawing lines, etc.)made within the algorithm.

Additionally, the view maintains an intelligent infinite undo feature to permit

roll-back or reverse execution of the program.

Unlike some paint programs, this undo feature replaces only the pixels that

were altered by the specified graphics calls and does not require that theentire view be redrawn. This feature was needed to allow reverse execution at

reasonable speeds.


14/20

As li ti l f r t

sage f rstandardand t

emonstrate t eabilitiesof

ml is to resent t e

isuali ationof t e travelling

salesman roblem foreight

verti es ( ities). he roblem is

onsideredasan - omplete

problem, and thus isnot solvableby

anyalgorithm inpolynomial time. All

nownalgorithms forsolving this

problem requireexponential runningtime. Hence thisproblem isbest

suitable tobevisuali edasastatic

animation.

Animation of TSP using xml3Dvis under 3D-VISIAN


15/20

The actual ray-tracing program being visualized was written C an taken from an article

by Roman Kuchkuda[16]. It has only been modified to write pixels to the screen (instead

of to a file).

3D-AAPE prototype screen.


16/20

Despite all disadvantages of static animation of algorithms and data structures this kind

of graphical presentation is the only possibility to visualize computation intensive

algorithms. Non-computation-intensive algorithms should be from our point of view only

visualized using real-time simulations, as these are pedagogically more effective than

static animations. The use of static algorithm animations should be taken into

consideration only for the visualization of computation-intensive algorithms.

owever, both alternatives have their own advantages and disadvantages. One of the

advantages of using animation languages is that no programming skills are required.

For example designer without any programming skills can create professional and

visually attractive animations, satisfying many design guidelines, whereas the use of

programming languages requires both design and programming experience.

Programmers pay less attention to design details than designers usually do. On the

other hand high-level programming languages are more powerful than algorithm

animation languages, as these normally support neither loops nor conditional

assignments.


17/20

Segment of an RNA animationThe question that arises is whether to use a high-level programming

Language or an algorithm animation language to visualize a given algorithm

or data structure. To answer this question, and will now examine another

example of a computation intensive and graphically demanding bioinformatics

algorithm


18/20

Apparently using a high-level programming languagecan visually simulate

every non computational intensive algorithm. owever,due to the enormous

execution time required to simulate a computational-intensive or an NP-

complete algorithm, using an algorithm animationlanguage or even a high-level programming languagecan only statically animate such kind of

algorithms either. In this presentation and pay specialattention to the three-dimensional static animation of

NP-complete algorithms and computational intensive3D-algorithms in the fields of computer graphics andbioinformatics.


19/20

As almost all currently existing algorithm animation

languages are restrictedto the two-dimensional visualization of conventional

algorithms and data

structures there is a strong need to develop a new

animation language thatcan be used for the visualization of 3D-algorithms.


20/20

Submitted byS ARANYA.DUGGI

Three-dimensional static Animation of computation

Documents

Transcript of Three-dimensional static Animation of computation