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.

- Our project is based primarily on creating Iterated Function Systems (IFS's), 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 Escape-time 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.

- 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.

- 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, etc...

- 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...

z_{n+1} = z_{n}^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 the window. For the Julia set, z changes depending on location and c remains constant.

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 again.

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 magnification levels
- 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
and
we painted while calculating. So, we used a display list to first store
the
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.

- Original Proposal by Rohan
- Group Proposal by Sean
- Updated Proposal by Jon
- Wiki Links to Fractals: Mandelbrot, Julia, Sierpinski Carpet, Sierpinski Triangle
- Java Fractals (Includes explanations)
- Fractal Tutorial - Basic, but helpful, reading