Welcome to the Fractacular Page. Below, you will find what
information on what we (Sean, John, and Rohan) have worked very hard on
for the past few weeks. On the left side is a set of links that
redirect you to the Java programs. Please read the guide to see if you
can run the programs and how to use them.
Project Details [Brief]
- Our project is based primarily on creating Iterated Function
which include the Sierpinski Triangle (Or Sierpinski Pyramid in 3D) and
the Sierpinski Carpet (Or Menger Sponge in 3D)
- It is mainly focused on creating 3D IFS's and displaying 2D
fractals through python or Java. For the 3D portion, we began with
working in Python and moved on to Syzygy programming.
- Initially, we did some work with Escape-time Fractals such as the
Mandelbrot Set and the Julia Sets, examples of which can be accessed on
the left of this page. Please refer to the guide.
- We then used Barnsley iterations (Part of his "Chaos Game") to
create the Sierpinski triangle in VPython. We implemented OpenGL in
VPython. Jon also created the Sierpinski Pyramid (3D) through VPython.
- Finally, the third and final part of the project was to create
the sponge in the cube. We were able to create a Menger Sponge, where
the user could vary iterations, views, and transparency.
Definitions & Concepts
Iterated Function Systems
- Self-similar geometric shape that may be repeated at a smaller
level and contains an infinite or finite fractal dimension
- Two types: Iterated Function Systems and Escape-time Fractals.
Escape Time Fractals
- Short form: IFS
- This type of fractal follows a basic geometric rule or function
to graph the next point in its system.
- Given a simple function, you start at a certain point in the
field and then jump from point to point, pixel to pixel, drawing out
the shape of the entire fractal. Since the point chosen (and the random
number seed) is random, there is no specific way to know how the
fractal will be drawn, but the shape will be known since it is governed
by a function
- There are several examples of this, including a fern, a spiral,
- Also known as Orbit-Trap Fractals
- The fractal is drawn pixel by pixel by determining the number
of iterations through a formula.
- Using the formula, if the starting complex number goes to
infinity, it is given a color depending on the number of iterations it
takes to surpasss a certain orbit, circle, or "trap"
- If the point hovers inside the orbit and never exits, it is a
dead point and is represented by a single color.
For my work with fractals, I focused mainly on the Mandelbrot and
Julia sets. I used the Java compiler and the integrated development
envirenment (IDE) Eclipse on a Windows 7 machine. I created two
separate programs, one of which draws the Mandelbrot Set and the other
that has the ability to draw several Julia sets. How the two sets work
is governed by the equation...
zn+1 = zn^2 + c
We essentially see if a certain starting value for z or c allow this
iteration formula to be trapped in a circle of radius two or escape it
and draw a color based on that.
So, given a visual representation or window, for the Mandelbrot Set, z
is constant (0 + 0i) whereas c changes depending on where you are in
For the Julia set, z changes depending on location and c remains
The method I used to generate my Sierpinski triangle and tetrahedron
is called the chaos game, a term coined by Michael Barnsley. These
fractals are known as Iterated Function Systems (IFS's) This
method uses a polygon a randomly selected point inside of the polygon.
Then for each iteration, a random vertex of the polygon is chosen and
the next point is plotted is a chosen, and constant, fraction of the
way along the line between the current point and the vertex. This is
repeated a large amount of times and the emerging pattern generally
takes the form of a fractal, and in the case of selecting a triangle
and the fraction to be one half, an approximation of the Sierpinski
triangle is formed. The jump to the tetrahedron simply involves
choosing a tetrahedron as the polygon and the fraction to be one half
2D Sierpinski Fractal (Triangle)
3D Sierpinski Fractal (Pyramid)
I focused on implementing Rohan's recursive method and Jon's work
with 3D in the Cube. My work was primarily focused on the Menger Sponge
and recreating it for the Cave/Cube through C++ and Syzygy.
Some aspects of the project that we could have worked on:
- Trying out a rotated Mandelbrot 3D graph (A Mandelbrot bulb)
- Graphing, with pixels, a Julia Set in 3D
- Working with different ways to calculate the Sierpinski fractals
- Implementing different color systems for fractals
- Enhance speed of program calculations
- Work with Sierpinski Pyramid in the cube
- More in-depth calculations with fractals (More details at higher
- Adding zooming and keyboard movement to the PyOpenGL programs
- Java programs are limited to a Windows Virtual Machine (And may
run on Linux depending on browser config)
- Original programs run on i7 processors that are able to calculate
the fractals in greate detail. The programs have slightly more slowly
on older computers with slower processors
- With Python, we ran into issues regarding the slow speed of the
painting process, as there were thousands of points that we had to plot
we painted while calculating. So, we used a display list to first store
data and then paint everything, helping speed up the Python program.
- With programming in C++, we faced the issue with coloring and two
sides colliding, causing flickering. We were able to fix it by
assigning certains colors to opposite sides. We were unable to figure
out how to increase the number of iterations, however.