Ray Trace Renderer

homepage computer graphics short film photo gallery

Beautifying Randomness

by Celambarasan Ramasamy

Random Animation Demos:

Note that the following animation clips are rendered by the exact same algorithm. The animation turns out differently every time it is rendered.

This project uses Computer Graphics to study how randomness affects an artwork in a time based medium like animation. Is it possible to generate a random animation that is different every time it is rendered, while at the same time remaining aesthetically pleasing to the viewer? I have used an abstract animation, implemented in C++, to explore this concept. The primary goal of my work is to explore the effect of randomness on the sense of motion in an animation and see how the randomness affects the overall aesthetic appeal of the animation.

Traditionally, Computer Graphics artists tend to exert as much control as possible on all possible aspects of an animation in order to achieve the ‘vision’ in their mind. I wanted to explore the other end of the spectrum, create an animation in which the control exerted by the ‘artist’s vision’ is replaced by randomness. This introduces chance and uncertainty into the work.

From a historical perspective, examples of chance and randomness incorporated into art work can be found starting from the Dadaist movement in the early 1920s. The art works from the Dadaist period that incorporated randomness like the,

• Collage with squares arranged according to the law of chances by Jean Arp

http://www.moma.org/collection/printable_view.php?object_id=37013

• Three Standard Stoppages by Marcel Duchamp

http://arthist.binghamton.edu/duchamp/Standard%20Stoppages.html

can be seen as static snap shots of randomness incorporated into works of art. Now, Computer Graphics enables us to explore the role of randomness in an artwork across time, using a time based medium like animation.

This work uses an abstract animation to explore the limit at which randomness and aesthetic beauty coexist in an art work. I have implemented a renderer in C++ that generates an abstract animation of a randomly deforming object. Every time the animation is rendered it turns out differently.

The random motion in the animation can be categorized into two components,

i) motion due to the random deformation of the object.

ii) random motion of the camera animated within the scene.

My initial rendering tests of the random animation contained only the randomly deforming object with the camera remaining static in the scene. I observed that even though the animation turned out differently each time it was rendered. The results were often aesthetically uninteresting.

Heres a test clip showing a randomly deforming object captured with a static camera.

This began to raise further questions like, can randomness be used to generate aesthetically interesting imagery? if so, how consistently?

The motion due to the random deformation alone did not seem coherent enough to create the visual rhythm that’s needed to accentuate the aesthetic appeal of the animation. So in order to create this visual rhythm, I looked at ways for controlling the camera motion within the scene without compromising on the random nature of the animation. I implemented an algorithm for animating the camera within the scene. The algorithm allows the camera motion to be random but at the same time ensures that the camera movement follows certain rules that mimic the ‘cohesive’ tracking movements of the cameras found in real world cinematic work. More implementation details on the camera movement can be found below.

The camera movement adds the second component of the random motion to the animation. The camera trajectory generated by the algorithm adds a sense of cohesiveness to the overall motion found in the animation. This cohesiveness helps to bring a visual rhythm to the animation that adds to its aesthetic appeal.

Music is another vital tool in enhancing the aesthetic appeal of the random animation. It can be used to further accentuate the cohesiveness created by the camera motion, adding to a sense of flow in the animation.

This clip shows the same deforming object with the renderer algorithmically controlling the motion of the camera within the scene.

All the random animation clips were rendered on my C++ renderer.

Implementation of algorithmically controlled camera movement

I started out by plotting out some camera 'Dolly' moves , that would make for some interesting shots within the scene. Then I implemented each of these camera moves as an algorithm in my renderer. And by using these algorithms as a guide, my renderer automatically generates interpolation points for camera movements within the scene.

All the interpolation points that are generated by the renderer lies outside the inner bounding box and within the outer bounding box. The inner bounding box helps to prevent some cases where the camera might get struck too close to the object. The actual path of the camera is generated by cubically interpolating between these generated point. The cubic interpolation generates a really smooth and flowing camera motion. Each time the renderer runs out of interpolation points, it generates a new set of interpolation points by randomly selecting between any one of the following algorithms that govern the camera movement.

Dolly Left:

This algorithm generates a series of interpolation points such that each new point lies to the left of the previously generated interpolation point with respect to the camera space created from the previous point. This algorithm helps to build a continuity of motion for the camera within the scene. The actual number of interpolation points that are generated each time by this algorithm is not fixed but varies between a specified upper bound and a lower bound value.

Dolly Right:

This algorithm is very similar to the Dolly Left algorithm except that it generates new points that are to the right of the previously generated point. This algorithm too helps to build a continuity of motion for the camera within the scene.

Dolly Past the Subject:

This third algorithm makes the camera to zip right past the subject from one side of the scene on to the other side, all the while maintaining focus on the subject. This algorithm serves to break the continuity of the camera motion generated by the previous two algorithms. Every time this algorithm is called, only one new point is generated. This helps to avoid situations where the camera continuously keeps zipping front and back past the object .

Early Experimental Tests

I also wanted to share some of the earliest test render clips that inspired me to further develop this idea. Please note that I put together these demos using very short renders for testing purpose (each render is something like 15 secs and I streched them into 50 sec demos!). So theres a considerable amount of looping in these clips. The camera motion is also not obvious as there is no reference geometry surrounding the deforming object. But the clips are interesting nonetheless.

Dots Demo

And the following two demos take the same rendering and combines it with two different types of music. Kind of shows how the music influences the way the animation is perceived.