## 18.4 Recursive Drawing--Fractals

Recursively repetitive figures arise naturally and in a variety of pattern and design work. Such figures are called fractals. The essence of a fractal is that is has the same kind of micro structure as it has a macro structure.

For instance, if the West coast of British Columbia, Canada is viewed from outer space, it has an irregular shape with numerous inlets folded into the larger outline throughout this length. Looked at from a lower altitude airplane, these larger inlets themselves have an irregular and folded structure, and if one were to look closer still down on the ground, these too would be seen to have inlets and folds. That is to say, a fractal is recursive, at least to some number of levels. (In the case of the coastline, the recursion would break down to some extent after one began looking at individual grains of sand under sufficient magnification.)

A number of standard fractal designs can be constructed using recursive drawing techniques, and these are detailed below.

### 18.4.1 Snowflake Fractals

One of the easiest types of fractals to draw is a snowflake.

The snowflake fractal shown in figure 18.5 is based on triangles and has four levels of recursion or sizes of triangle. Assuming that the drawing starts at the lower left corner and with the direction to the right or East, the drawing of this fractal could be formulated in terms of pseudocode for a three sided figure as follows:

```draw fractal =
select standard coordinates
select levelsofrecursion
select mainlength
select starting point on screen
calculate turn angle based on number of sides (60 degrees for triangles)
drawfigure

drawfigure (mainlength, recursionlevel) =
save current position and direction
turnby -60 degrees; (* turn out and away first *)
drawsegment (sidelen, curreclevel); (* go draw a side *)
for count := 2 to numsides - 1
do  (* then turn and draw each successive side except the last *)
turnby 120 degrees; (* turn back in *)
drawsegment (sidelen, curreclevel);
end;

if curreclevel < recursionlevel
then (* fill in the missing side -- central third *)
turnto (olddir);
moveto (oldx, oldy);
lineto (curx, cury);
else  (* go draw the last side *)
turnby 120 degrees;
drawsegment (sidelen, curreclevel);
end;

drawsegment (dist, curreclevel) =
disttodraw := dist / 3.0;
if curreclevel = 0
then
lineby (dist);
else
drawsegment (disttodraw, curreclevel - 1);
drawfigure (disttodraw, curreclevel - 1);
drawsegment (disttodraw, curreclevel - 1);
end;```

The basic idea is that drawing a figure (say, a triangle) consists of drawing three successive segments with the appropriate angle between. Drawing each segment consists of drawing a third of that segment, then drawing the original figure at one third size as the middle third (unless one is past the appropriate number of recursion levels) then drawing the last third of the segment. In the code that follows, however, this has been modified to allow for the angle to be calculated for the number of sides. The number of recursion levels and number of sides is initially set to reproduce the drawing above, but both can easily be changed. Here is the code:

```MODULE Snowflake;

(* by R. Sutcliffe 1996 01 29
to illustrate Macintosh quickdraw
revised by Joel Schwartz and R. Sutcliffe to depend on GraphPaper.
This program draws a recursive snowflake with a specified number of sides and level of recursion. Last revision 1998 06 16 *)

FROM GraphPaper IMPORT
LineBy, LineTo, TurnTo, MoveTo, GetDimensions, SetCoordSystem, CoordSystem, GetLocation;

CONST
(* set up these first two constants; the rest depend on them. *)
recursionLevel = 3;
numSides = 3;

degreesAvailable = 180 * (numSides - 2);
(* how many degrees around and back *)
turnAngle = degreesAvailable DIV numSides;
(* turn for each corner *)
VAR
curDir : INTEGER;
curX, curY : INTEGER; (* to globally store position and direction *)
dimX, dimY : INTEGER; (* the dimensions *)

PROCEDURE DrawSegment (dist : REAL; curRecLevel : INTEGER); FORWARD;
(* omit if compiler is multi pass *)

PROCEDURE DrawFigure (sideLen : REAL; curRecLevel :INTEGER);

VAR
oldX, oldY : INTEGER;
oldDir : INTEGER;
count : CARDINAL;

BEGIN
(* store current directions *)
oldX := curX;
oldY := curY;
oldDir := curDir;
curDir := curDir - turnAngle;
TurnTo (FLOAT (curDir)); (* turn out and away first *)
DrawSegment (sideLen, curRecLevel); (* go draw a side length *)
FOR count := 2 TO numSides - 1
DO  (* then turn and draw each successive one but the last *)
curDir := curDir - turnAngle + 180;
TurnTo (FLOAT (curDir));
DrawSegment (sideLen, curRecLevel);
END;

IF curRecLevel < recursionLevel
THEN (* fill in the missing side -- central third *)
curDir := oldDir; (* go back to old position *)
TurnTo (FLOAT (curDir));
MoveTo (oldX, oldY);
LineTo (curX, curY); (* and draw to new one *)
ELSE (* draw another side like the ones in the loop above *)
curDir := curDir - turnAngle + 180;
TurnTo (FLOAT (curDir));
DrawSegment (sideLen, curRecLevel);
END;
END DrawFigure;

PROCEDURE DrawSegment (dist : REAL; curRecLevel : INTEGER);
(* recursively draw a third of the segment as another one
then a third size figure on the next segment
then another segment after that. *)

VAR
distToDraw : REAL;
BEGIN
distToDraw := dist / 3.0;
IF curRecLevel = 0
THEN
LineBy (TRUNC(dist));
GetLocation (curX, curY); (* reset local storage of position *)
ELSE
DrawSegment (distToDraw, curRecLevel - 1);
DrawFigure (distToDraw, curRecLevel - 1);
DrawSegment (distToDraw, curRecLevel - 1);
END;
END DrawSegment;

VAR
mainLength : INTEGER;

BEGIN (* main *)
(* calculate a length that will fill the screen nicely *)
SetCoordSystem (MacWin);
GetDimensions (dimX, dimY);

mainLength := 3 * dimY/(2 * numSides); (* arrived at by experimenting *)

(* starting point is "lower left" of first level recursive figure. *)
curDir := 0;
curX := (dimX - mainLength) / 2;
curY := (dimY + mainLength) / 2;

(* above formula not bad except for three sides, so adjust *)
IF numSides = 3
THEN
curY := curY - 75;
END;
MoveTo (curX, curY);
DrawFigure (FLOAT (mainLength), recursionLevel);

END Snowflake.```

### 18.4.2 A Tree Fractal

The program in this section recursively draws a tree fractal. The idea is that it draws a trunk in the current direction, then two trees at half size at forty-five degrees on either side of the top of the trunk, then a tree at three-quarters size in the same direction as the original trunk. After the first vertical trunk, the remaining trees can be thought of as branches. Recursion is exited if the length of the trunk is less than two units.

```MODULE DrawTree;
(* Program by R. Sutcliffe
to illustrate GraphPaper
revised 1998 06 16
recursively draws a fractal based tree. *)

FROM GraphPaper IMPORT
MoveTo, LineBy, Turn, TurnTo, GetLocation;

PROCEDURE DrawATree (trunkLength : CARDINAL);
VAR
baseX, baseY : INTEGER;

BEGIN
IF trunkLength < 2
THEN
RETURN
END (* if *);
LineBy (trunkLength);
GetLocation (baseX, baseY);
Turn (45.0);
DrawATree (trunkLength DIV 2);  (* 1/2 current size right *)
MoveTo (baseX, baseY);
Turn (-90.0);
DrawATree (trunkLength DIV 2); (* 1/2 current size left *)
MoveTo (baseX, baseY);
Turn (45.0);
DrawATree (3 * (trunkLength DIV 4)); (* 3/4 current size up *)
MoveTo (baseX, baseY);
END DrawATree;

BEGIN
(* Find a good place to start drawing the tree. *)
MoveTo (0,-250);
TurnTo (90.0);
DrawATree (128);
END DrawTree.```

Here is a screen shot of the tree that is drawn:

### 18.4.3 Singly-Recursive Snowflake-like Fractals

The tree fractal was drawn in a different way than the snowflake that preceded it. Rather than use a pair of mutually recursive procedures, it employed only a single procedure that drew segment-right fractal-left fractal-central fractal. Snowflakes can be drawn in a similar manner, without the filled in sides, and by using a singly-recursive procedure as in the following:

```MODULE DrawFractal;

(* Program to draw a fractal
by R. Sutcliffe
revised 1998 06 16 *)

FROM GraphPaper IMPORT
LineBy, Turn, TurnTo, MoveTo;
TYPE
CardArray = ARRAY [0..12] OF CARDINAL;
CONST
order = 6; (* fits on most screens *)
(* make a constant array with the powers of two for the line lengths. *)
Power = CardArray {1,2,4,8,16,32,64,128,256,512,1024,2048,4096};

PROCEDURE Fractal (level: CARDINAL);
(* Recursive drawing of levelth fractal *)
BEGIN
Turn (-60.0);
(* at all but the outer level, we do segment-fractal-segment *)
LineBy (Power [level]);
IF level > 1
THEN
Fractal (level - 1);
END;  (* if *)
LineBy (Power [level]);
Turn (120.0);
LineBy (Power [level]);
IF level > 1
THEN
Fractal (level - 1);
END;  (* if *)
LineBy (Power [level]);

(* at the outer level we complete the figure so it is closed *)
IF level = order
THEN
Turn (120.0);
LineBy (Power [level]);
IF level > 1
THEN
Fractal (level - 1);
END;  (* if *)
LineBy (Power [level]);
END;
Turn (-60.0);
END Fractal;

VAR
ch : CHAR;

BEGIN  (* DrawFractal *)
(* orient on the page the way we want *)
TurnTo  (180.0);
MoveTo  (100, -50);
Fractal (order);
END DrawFractal.```

This program produces the following version of the snowflake fractal:

### 18.4.4 Sierpinski's Curve

The most basic form of the fractal known as Sierpinski's curve consists of a square with squares on its corners in the manner shown in figure 18.8. Assuming standard coordinates with the origin at the centre, and given that the basic length on one of the corners is dist, drawing is done in four steps starting from the indicated point. (Recall that Line draws to a point with the given displacement from the current point.)

top: Line (dist, -dist); Line (2 * dist, 0); Line (dist, dist);
followed by Line (dist, -dist) to glue to the next piece

right: Line (-dist, -dist); Line (0, -2 * dist); Line (dist, -dist);
followed by Line (-dist, -dist) to glue to the next piece

bottom: Line (-dist, dist); Line (-2 * dist, 0); Line (-dist, -dist);
followed y Line (-dist, dist) to glue to the next piece

left: Line (dist, dist); Line (0, 2 * dist); Line (-dist, dist);
followed by Line (dist, dist) to glue to the next piece

That is, each procedure has three steps that draw a copy (in one of four rotations) of what is shown in figure 18.9, followed by a connector to the next part.

The fun begins when this process is made recursive, in the sense that the prototype procedure Top becomes:

```Top =
IF level > 0
THEN
Top (level - 1);   Line (dist, -dist);
Right (level - 1); Line (2 * dist, 0);
Left (level - 1);  Line (dist, dist);
Top (level - 1)
END```

If this is drawn at level two, the top (including the glue) becomes figure 18.10, and this pattern can be replicated around the basic square using the other three procedures in turn.

With a careful calculation of starting points, the level two diagram can be superimposed on top of the level one diagram, and indeed as many levels can be drawn as desired. In the code that is given below, three levels have been drawn by the main loop. Care must be taken not to ask for too many levels, or one could find the program in an infinite loop unable to compute the next smaller side length.

```MODULE Sierpinski;
(* Heavily adapted from a version in Wirth's PIM-2
by R. Sutcliffe to illustrate GraphPaper
last revision: 1998 06 22 *)

FROM GraphPaper IMPORT
Line, LineTo, MoveTo;

CONST
size = 512; (* use a power of two that fits on screen. *)
numOfLevels = 3; (* set to number smaller than the power in the last line; if 512; use 8 or less here *)

VAR
dist : INTEGER;

(* Each of the mutually recursive procedures draws one side of the basic square figure in the orientation given by its name. At the lowest level, this is an angled part, a straight part, and then an angled part, concluding with a "larger" copy of itself at a lower level to glue to the next piece. *)

PROCEDURE Top (level: CARDINAL);
BEGIN
IF level > 0
THEN
Top (level - 1);   Line (dist, -dist);
Right (level - 1); Line (2 * dist, 0);
Left (level - 1);  Line (dist, dist);
Top (level - 1)
END
END Top;

PROCEDURE Right (level: CARDINAL);
BEGIN
IF level > 0
THEN
Right (level - 1);   Line (-dist, -dist);
Bottom  (level - 1); Line (0, -2 * dist);
Top (level - 1);     Line (dist, -dist);
Right (level - 1)
END
END Right;

PROCEDURE Bottom  (level: CARDINAL);
BEGIN
IF level > 0
THEN
Bottom  (level - 1); Line (-dist, dist);
Left (level - 1);    Line (-2 * dist, 0);
Right (level - 1);   Line (-dist, -dist);
Bottom  (level - 1)
END
END Bottom;

PROCEDURE Left (level: CARDINAL);
BEGIN
IF level > 0
THEN
Left (level - 1);    Line (dist, dist);
Top (level - 1);     Line (0, 2 * dist);
Bottom  (level - 1); Line (-dist, dist);
Left (level - 1);
END
END Left;

VAR
level  : CARDINAL;
startX, startY : INTEGER;

BEGIN
dist := size DIV 4; (* initial segment distance *)
startX :=  0;
startY :=  dist;
level := 0;

(* The following loop draws the level one figure and then overlays it with the level two figure, and so on until the number of specified levels have all been drawn. *)

REPEAT
INC (level);        (* begin at one and work up to max set. *)
DEC (startX, dist); (* set up new corner to start *)
dist := dist / 2;   (* and basic distance for next level *)
INC (startY, dist);
MoveTo (startX, startY);
(* We end up d units left and d/2 units up from last start for next one.*)

(* In the main program the figure is drawn with the four "sides" in succession, each followed by a line segment to glue to the next piece. *)
Top (level);     Line (dist, -dist);
Right (level);   Line (-dist, -dist);
Bottom  (level); Line (-dist, dist);
Left (level);    Line (dist, dist);
UNTIL level = numOfLevels

END Sierpinski.```

When this version of the code was compiled and run, the following figure was produced.

Careful examination will reveal the three levels drawn. More can be called for, but the diagram becomes somewhat cluttered for illustrative purposes.

Contents