Martin McBride, 2020-10-09

Tags generativepy koch curve turtle recursion

Categories generativepy generative art

**generativepy has moved** to the pythoninformer.com website, and this page might not be up to date. Please visit the new location.

In this post we will create a simple turtle graphics in generativepy, and use it to recursively plot a Koch curve.

The turtle will be useful for exploring L Systems.

You will probably be familiar with turtle graphics. The idea is that you have a graphics *cursor* that can draw lines as it moves around.

The cursor has an (x, y) position, and also a direction it is pointing in (the *heading*). The you can tell the turtle to move forward by a certain distance, or to turn through a certain angle to the left or right. By issuing a series of instructions, you can draw various shapes.

To allow for recursive drawing (to create fractal images) turtle graphics can push the current state onto a stack. At some later stage it can pop its previous state (position and heading) and continue from there.

Here is the Python code to implement a simple turtle:

import math from generativepy.geometry import Line from generativepy.color import Color import math class Turtle(): def __init__(self, ctx): self.ctx = ctx self.heading = 0 self.x = 0 self.y = 0 self.stack = [] def push(self): state = self.heading, self.x, self.y self.stack.append(state) def pop(self): state = self.stack.pop() self.heading, self.x, self.y = state def forward(self, distance): p1 = self.x, self.y self.x += distance*math.cos(self.heading) self.y += distance*math.sin(self.heading) Line(self.ctx).of_start_end(p1, (self.x, self.y))\ .stroke(Color('darkblue'), 1) def move(self, distance): self.x += distance*math.cos(self.heading) self.y += distance*math.sin(self.heading) def move_to(self, x, y): self.x = x self.y = y def left(self, angle): self.heading -= angle def right(self, angle): self.heading += angle

This class uses `self.x`

and `self.y`

to store the position, and `self.heading`

to store the current direction. It draws on a generativepy `drawing.Canvas`

object.

`push`

and`pop`

save and restore the current state (`x`

,`y`

and`heading`

) as a tuple, using a list as a stack.`forward`

moves forward a certain distance, drawing a line on the canvas.`move`

is similar to`forward`

but moves without leaving a line.`moveTo`

moves straight to a new (x, y) position without drawing anything.`left`

and`right`

move the turtle direction through`angle`

, to the k=left or right.

The turtle will draw lines using the stroke colour and weight that is defined when the turtle functions are called.

Here is some code that draws a simple figure using the turtle (assuming we have a suitable canvas object):

turtle.forward(10) turtle.left(math.pi/2) turtle.forward(10) turtle.right(math.pi/2) turtle.forward(10) turtle.right(math.pi/2) turtle.forward(10) turtle.left(math.pi/2) turtle.forward(10)

This sequence (foward, left, forward, right, forward, right, forward, left, forward ) will draw a shape something like this:

We can draw this figure recursively using the following code:

def plot(turtle, level): if level < 1: turtle.forward(10) else: plot(turtle, level-1) turtle.left(math.pi/2) plot(turtle, level-1) turtle.right(math.pi/2) plot(turtle, level-1) turtle.right(math.pi/2) plot(turtle, level-1) turtle.left(math.pi/2) plot(turtle, level-1)

If we call this function with `level`

set to 0, the if statement will be true and the function will just call `turtle.forward`

, which just draws a single line.

If we call the function with level set to 1, the second part of the if statement will execute. This executes the following steps:

- calls
`plot`

recursively with`level`

set to 0 - draws a single line - turn left
- calls
`plot`

recursively with`level`

set to 0 - draws a single line - turn right
- etc

These steps are identical to the original code. This will draw the same figure as before:

If we call the function with level set to 2, things get more interesting. The second part of the if statement will execute. This executes the following steps:

- calls
`plot`

recursively with`level`

set to 1 - draws the original figure - turn left
- calls
`plot`

recursively with`level`

set to 1 - draws the original figure rotated to the left - turn right
- calls
`plot`

recursively with`level`

set to 1 - draws the original figure back at the original orientation - turn right
- calls
`plot`

recursively with`level`

set to 1 - draws the original figure rotated to the right - turn left
- calls
`plot`

recursively with`level`

set to 1 - draws the original figure back at the original orientation

The result is shown below, with the original figure shown in a different colour for each iteration:

Here is the full code that you can run for yourself. You will also need the turtle code from earlier in this post, which you should save in a file called *turtle.py* in the same folder.

from generativepy.drawing import make_image, setup from generativepy.color import Color from turtle import Turtle import math def plot(turtle, level): if level < 1: turtle.forward(10) else: plot(turtle, level-1) turtle.left(math.pi/2) plot(turtle, level-1) turtle.right(math.pi/2) plot(turtle, level-1) turtle.right(math.pi/2) plot(turtle, level-1) turtle.left(math.pi/2) plot(turtle, level-1) def draw(ctx, width, height, frame_no, frame_count): setup(ctx, width, height, background=Color(1)) turtle = Turtle(ctx) turtle.move_to(10, 290) plot(turtle, 3) make_image("turtle-koch-curve.png", draw, 800, 300)

You should be able to run this yourself if you have generativepy installed. Here is the output you will get:

**Iteration level 1**

**Iteration level 2**

**Iteration level 3**

**Iteration level 4**

Note that when the level is set to 4, the image is too big to fit the image size we are using. You can either increase the image size, or make the image smaller, or even try a combination of both.

In this case we have made the image smaller by setting the `forward`

distance to to 4 rather than 10 (the `turtle.forward(10)`

line in the `plot`

function).

We have defined a simple turtle system, and used it to draw a Koch curve in generativepy. You can use this to try drawing other fractals such as the Sierpinski triangle. See the article on L Systems for a way to make this easier.

Copyright (c) Axlesoft Ltd 2021