There are a lot of fractal patterns you can "easily" draw using recursive functions. Here is are a few links to more information about fractals:

• Fractals in nature
• Recursion in Nature, Mathematics and Art
• Lindenmayer System recursive rules that generate fractal patterns
• Trippy "fractal zoom" videos on youtube

Here are two challenging patterns you could try:

1. Fractal Tree Recursive techniques can be used to draw trees, ferns, and other patterns. The tree below is drawn by drawing the trunk, turning slightly to the left and recursively drawing a tree, then turning slightly right and recursively drawing a tree. Experiment with recursive drawing and come up with your own patterns.

A recursive function to draw a tree requires some trigonometry and keeping track of the current location and size branch you are drawing, and at what angle and scale. A recursive function definition might look like:

drawTree(window, depth, start, end, angle, scale, split)

• window the graphics window
• depth the current recursive depth
• start, end the start and end Point for the current branch
• angle defines the orientation of the branch (in radians) where 0 radians is a horizontal line pointing to the left. As we move clockwise, this angle increases. As we move counter-clockwise, this angle decreases. The trunk of the tree is vertical and will have angle = -pi/2 (e.g., -90 degrees).
• scale the relative length of the smaller two branches to the larger one at each level (try 0.75 and some other values).
• split: the angle between the two branches at the same depth level.

Angles should be in radians. You can convert between degrees and radians using the radians() function in the math library. window, scale, split do not change values in recursive calls. The other parameters do.

• In the base case: could stop drawing or draw a single leaf at the start point.
• In the other case:
  • Draw the line defined by the start and end points.
  • Calculate the length of the current branch:

    dx = end.getX() - start.getX()
    dy = end.getY() - start.getY()
    length = sqrt(dx**2 + dy**2)
    

  • Use this length to determine the length of the new left and right branches, which will be based on the scale parameter.
  • Each new branch will start at the end point of the current branch, but will have unique end points. We can determine the end point (x, y) of a new branch with the following formula:

    x = end.getX() + length * cos(desiredAngle)
    y = end.getY() + length * sin(desiredAngle)
    

  • To draw the tree you'll need to make a recursive call to drawTree for the left branch and a recursive call drawTree for the right branch.

2. Koch curves

Below are examples of six Koch curves that have recursion depths from 0 (a straight line) at the top to 5 at the bottom.

A Koch curve is created by breaking a line segment into thirds and replacing the middle segment by two segments that are equal in length. This creates a two-sided equilateral triangle in the middle (e.g., all angles are 60 degrees).

You should start by creating a program called koch.py. You will write a function:

drawKochCurve(win, n, start, end, angle)

which draws a Koch curve from point start to a point end with recursion depth n where angle specifies the angle of the line that connects start to end.

A Koch curve of recursion depth n is formed by four Koch curves as follows:

1. drawing a Koch curve of length length/3 with degree n-1 and angle
2. drawing a Koch curve of length length/3 with degree n-1 and angle-radians(60)
3. drawing a Koch curve of length length/3 with degree n-1 and angle+radians(60)
4. drawing a Koch curve of length length/3 with degree n-1 and angle

Hint: Each one of these recursive calls is starting from a diffrent starting point. Like in the tree, you will need to know where you are and how you are oriented.