m Introduction

m 3D-Algorithm Animation Language

m Implementation
m Application Example
m Evaluation
e 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.
!




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 been
defined 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.
O





 




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

An essential feature of the new standard is its ability to
animate any 3D
algorithms that meet all requirements proposed in
various studies so far.

m The language should support modeling and utilization

of data structures along with its associated operations
in a most convenient way.
m This implies that complex data structures (trees,
graphs, multidimensional
arrays, etc.) are fully supported or at least easy to
construct.
m The language should be easy to learn. Authors
without any, or with only
sparse programming skills, should be given the
opportunity to create
animations without much additional effort.
m The syntax of the language a platform-
independent and portable format should be used
which does not only support the manual, but also
tool-based script production.
—
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.
¢or 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 —Owhich fulfils the
essential requirements.

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

platform called O!(Three-dimensional Visual Simulation and
Animation 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.
 
(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 }
}
This prototype system was written in C and created to run under
Microsoft
indows 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 bus
graphics
is more than adequate to support the system with reasonable
animation
speeds.

Similar to AACE's user interface, tape deck type controls are the
primary user
interface for the system which is yet flexible way to control the
animations.
Similar to AACE's user interface, tape deck type controls are the
primary user
interface for the system which is yet flexible way to control the
animations.

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 a
system specifically tailored to visualize computer graphics
rendering
algorithms was our original objective
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 the
entire view be redrawn. This feature was needed to allow reverse execution at
reasonable speeds.

!

 O!
p li ti l f rt

 f r t

r
 t
 tr
t t 
iliti f
l i t r t t 
i
li
ti f t  tr

lli

l 
 rl fr it

rti  ( iti ).  rl i
 ir

 - lt
rl,
 t i t l

l 


lrit i l i
l ti. pll

lrit fr l
i ti
rl r ir ti
l r i
ti. H ti rl i  t
it
l t 
i
li 

t
ti

i
ti.
    
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).
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.
¢or 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.
!   
 


The 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
Apparently using a high-level programming language
can 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 animation
language or even a high-level programming language
can only statically animate such kind of
algorithms either. In this presentation and pay special
attention to the three-dimensional static animation of
NP-complete algorithms and computational intensive
3D-algorithms in the fields of computer graphics and
bioinformatics.
As almost all currently existing algorithm animation
languages are restricted
to the two-dimensional visualization of conventional
algorithms and data
structures there is a strong need to develop a new
animation language that
can be used for the visualization of 3D-algorithms.
 !


S ARANYA.DUGGI