TITLE: Faces
NAME: Aaron Gage
COUNTRY: USA
EMAIL: agage@mines.edu
WEBPAGE: http://www.mines.edu/students/a/agage
TOPIC: Metamorphosis
COPYRIGHT: I SUBMIT TO THE STANDARD RAYTRACING COMPETITION COPYRIGHT.
MPGFILE: amgface.mpg
ZIPFILE: amgface.zip
RENDERER USED: 
    POVray 3.0 for Linux

TOOLS USED: 

        gcc compiler for wave mesh creator and pre-frame-command script
        xv to grab part of a text window for the credits


CREATION TIME: 

        Scene creation and C programming took about 3-4 days worth of
        free time.

RENDER TIME: 66h 12m 5s for the frames which ended up in the animation


HARDWARE USED: 
    i486DX2/66 with 32M RAM, running Linux 2.0.28

ANIMATION DESCRIPTION: 


        Sometimes we see ourselves as who we were, not who we are.  As the
waves in a pool distort the reflection, the face reflected back changes from
young to old.  Well, at least it was supposed to.  The reflection doesn't
change nearly as much as intended.

DESCRIPTION OF HOW THIS IMAGE WAS CREATED:

        I am beginning to wish that I had either started this animation when
the round began, or that I had chosen some other image to reflect off of the
pool.  I have a particular weakness when it comes to creating human shapes,
especially against a deadline.  If nothing else, the technical steps I made
for this image make up for the lack of pretty pictures.

        The face was the easiest feature, basically constructed out of blobs
by hand.  The actual face, when viewed directly, has a very prominent nose
and mouth, but the reflection has faded those almost entirely out (though I
did play with the ambient values and reflection levels).  The hair was done
with a .inc file that I created a while back for just that purpose; its
biggest drawbacks are that each strand must be placed individually and that
they consist of a lot of primitives (like 60).  I includeed hair.inc in my
.zip file.

        The surface of the pool is the part of the animation that I actually
like.  For the first few frames, it is just a plane, because parsing and
rendering a plane is pretty fast.  After those frames, I had a script run
which would generate a time-based triangle mesh of the pool, positioned so
that it would be indistinguishable from the plane until the waves began to
advance.  I wrote the program that created and propagated the waves for
this animation, and may improve it to handle wave reflections (since it
manages proper constructive/destructive wave interference for any number of
sources already).  Deriving the algorithm for the code was easy; getting
POV to interpret it correctly was not (I had trouble with the normal vectors
until I normalized them before writing them out; even so, it is a little
rough in some places).  It would be nice if POVray had a binary file format
*hint hint* since my text file for the mesh varies around 14 megs.  The
mesh consists of 80K triangles or so, and all parameters can be adjusted
easily in the C file.  I included that code in my .zip file, under the GPL.
I had a bit of trouble getting the reflection to change over time --
although I changed the color and ambient value on the face dramatically,
the reflection didn't budge until I started changing the surface color of
the pool and its filtering.  Unfortunately, that makes things look rather
foggy instead, which isn't much better.  Nothing else I could do with
only a few days left to render.  I'm not as satisfied with the aging
effects as I could be, and another drop might have prolonged the waves
enough to hide the change better, but there is not time to redo it.  The
simple fact that the last frames fade into white made my credits frames
much easier to do :)

        The files were all raytraced with POVray, converted to PPM with
tgatoppm (from the netpbm library) and converted to MPEG with mpeg_encode.
Best framerate is probably 24; I had intended 20, but that is not given
under the MPEG-1 standard.  I would have made it 30 fps if I had more than
a week to render the 120 frames.  As it was, this was my first animation.
I used POVray's internal animation cycle, but had to restart it a few
times due to unintentional interruptions and two mistakes that ruined 59
frames.  Hopefully, this experience will show me what kind of framerate,
resolution, and level of AA produce files closest to the regulation limit
of 3 megs while not taking too long to render.

        Things I could have done better:
         o Use more than 100f the allowed space for the animation
         o Make the change over time more dramatic
         o Have the waves go further before they die off
         o Eliminate the artifact (dark band) to the upper right of
           the images

VIEWING RECOMMENDATIONS: 

        20 or 24 frames per second, if possible