Turtle Graphics and Recursive Images
Turtle Graphics is a system for drawing images first introduced in the Logo language. The basic premise for Turtle Graphics is quite simple. It is based on the idea of a turtle that appears mid-screen and can be moved by ordering it to move about using a few basic directional commands.
How images are created
When the turtle moves it leaves a trail behind it, creating the displayed image. One of the features of Turtle graphics is that through recursive calls to functions, quite stunning graphic images can be created. Your basic turtle can be moved forward by set distances and may be turned by a given angle.
To experience the power of Turtle graphics, you would require a fully working version of LOGO, but the following program is simple enough to allow you to see how recursion works and still creates quite stunning results.
The code
- cx = 160; // Horizontal CenterX of screen.
- cy = 100; // Vertical CenterY of screen.
- repeats = 700 // The number of repetitions to do
- forward = 10 // The number of steps forward to move each time
- incstep = 10 // The incremental step for the angle
- turn = 200 // The angle to turn after each move
- PI = 3.141 //The value of PI
- Pixel (cx, cy) //Plot first point at center of screen
- angle = 0 //Initial angle at 0 degrees
- For a = 1 To repeats
- angle = angle + turn // Turn to new angle
- ra = (angle * PI) / 180 // Radians of new angle
- dx = Sin(ra) * forward // Delta X for new move
- dy = Cos(ra) * forward // Delta Y for new move
- LineRel (dx, dy) // Draw a line relative from (cx,cy) to (cx+dx,cy+dy)
- forward = forward + incstep // Increase step size.
- Next a
The basic image can be changed quite dramatically by simply changing some of the basic settings at the start of the program. The following are two examples of other images created by using alternate values.
repeats = 100
forward = 2
incstep = 1
angle = 88
repeats = 55
forward = 1
incstep = 5
angle = 181
The main advantage of this type of system is that it is extremely easy to store a variety of images in quite a small amount of space. With the above examples, it requires only four variables to create each. So, you can see that within any computer program, it is possible to store many graphic images in a small space. This simple idea of recursion is found again in fractal geometry and can be used in powerful ways. It is possible, for instance, to create quite complex patterns using only some simple algorithms. The algorithm above can be altered to create an infinite number of patterns.
To take the recursive program further, you can add color to your images and create more interesting results. Quite stunning effects can be created by using color cycling on the images. There are several different variations of this theme. It’s up to you how much time you work and alter the basic algorithm.
Applications of Turtle Graphics
Turtle Graphics is not just a fun way to create images; it has practical applications in teaching programming concepts, especially recursion and loops. It is often used in educational environments to help students visualize the effects of their code.
Modern Implementations
While originally part of the Logo language, Turtle Graphics has been implemented in many modern programming languages, including Python. The turtle module in Python is a popular tool for beginners to learn programming and create graphics.
Enhancing Your Turtle Graphics
- Color and Pen Control: Modern implementations allow you to change the color and thickness of the turtle’s trail, adding more variety to your images.
- Animation: By controlling the speed of the turtle, you can create animations that show the drawing process in real-time.
- User Interaction: Some implementations allow for user interaction, where the user can control the turtle’s movements with keyboard or mouse inputs.
Example in Python
Here’s a simple example of Turtle Graphics in Python:
<?php
import turtle
# Set up the screen
screen = turtle.Screen()
screen.bgcolor("white")
# Create a turtle
t = turtle.Turtle()
t.speed(0)
# Draw a recursive pattern
def draw_pattern(t, length, angle, increment, depth):
if depth == 0:
return
t.forward(length)
t.right(angle)
draw_pattern(t, length + increment, angle, increment, depth - 1)
# Initial parameters
length = 10
angle = 144
increment = 2
depth = 50
# Start drawing
draw_pattern(t, length, angle, increment, depth)
# Hide the turtle and display the window
t.hideturtle()
turtle.done()
?>Advertising
