Lab 7

Due at the end of today's class, except by permission.

Problem 1.

In this problem, you will use a Turtle to make a self-similar drawing, the Sierpinski gasket. A self-similar drawing is a pattern that looks the same at different levels of magnification. The following picture shows a 3-level Sierpinski gasket:

Notice that this Sierpinski gasket is composed of three smaller versions of the Sierpinski gasket, one in each corner of the original triangle. Each of these smaller versions is half the size of the original, and made of up one less level. That is, a 3-level Sierpinski gasket is made up of three half-size 2-level Sierpinski gaskets. And each of those 2-level Sierpinski gaskets is of course made up of three one-quarter-size 1-level Sierpinski gaskets, and so on. A 0-level Sierpinski gasket is just a triangle. Thus, drawing the Sierpinski gasket is a problem that can be solved using recursion.

Write a recursive function, sierpinski(myTurtle, size, N), that draws an N-level Sierpinski whose sides are each of length size. Your function should call itself to draw the smaller versions of the Sierpinski gasket. When your function starts, the turtle will be in some position on the screen. If you have programmed the function correctly, then the turtle will end up in that same position when the function is finished.

Follow these steps to write your function. Note that each step involves exactly one Python statement (i.e. one line of code, one function call, or one if-else conditional statement).

• Write a conditional to check for the base case, when the level is less than or equal to zero.
• In the base case, your function should draw a triangle with side length given by size. (You should call the drawTriangle( ) function given in the skeleton code below).
• The general case, written in the else clause, should do the following:
• Draw a Sierpinski gasket of half the size and with one less level at the turtle's current position. (Use a recursive call to do this!)
• Move the turtle forward by half the side length.
• Draw a Sierpinski gasket of half the size and one less level at this new current position.
• Move the turtle backward by half the side length—there is a turtle.backward( ) function for this that works similarly to turtle.forward( ). (The turtle should now be back where it started.)
• Turn the turtle left by 60 deg.
• Move the turtle forward by half a side length.
• Turn the turtle right by 60 deg. (This places the turtle halfway up the left side of the gasket and facing right.)
• Draw a Sierpinski gasket of half the size and one less level at this new current position.
• Turn the turtle left by 60 deg.
• Move the turtle backward by half a side length.
• Turn the turtle right by 60 deg. (So it is now back where it started.)

You may use the following skeleton code for your program:

# Program: sierpinski.py
# Your name and program prologue go here.

from turtle import Turtle, exitonclick

# This function draws a triangle. It is called by the sierpinski function.
def drawTriangle(myTurtle, size):
    myTurtle.forward(size)
    myTurtle.left(120)
    myTurtle.forward(size)
    myTurtle.left(120)
    myTurtle.forward(size)
    myTurtle.left(120)
    
def sierpinski(myTurtle, size, N):
    # Your code for the body of the sierpinski() function goes here.

# Main program begins here
yertle = Turtle( )
sierpinski(yertle, 100, 3) # draw a 3-level gasket of size 100
# If your code works, try a 4 or 5 level drawing!

Problem 2.

In this problem, you will modify a small piece of a larger program. Download these two files:

• paint.py This is a simple "paint" program.
• graphics.py This is a Python library that paint.py uses for opening windows and drawing on the screen.

If you run the paint.py program you will be shown a small window in which you can make drawings using the mouse. Try it out.

Your task is to modify the code in paint.py so that it can do a bucket-fill operation with the color blue. The idea is that the user should be able to double-click any white spot on the drawing canvas, and the program should fill that white spot, and all nearby white spots, with blue color. For instance, if the user draws this picture:

then double clicks in the middle part of the drawing, the result should look like this:

The existing program code already calls a function, fillWithColor(canvas, x, y), whenever the user double-clicks on the drawing canvas. This is the function you should modify. If you look in paint.py, you will see that the fillWithColor( ) function currently does not do a bucket-fill with blue paint. Instead, it just prints some silly messages and changes a single pixel at coordinates (x, y) to green. Delete the code in the body of this function and replace it with your own code that does the following:

• Write a conditional to check if the pixel at (x, y) is colored white. If so, then...
• Color the pixel at (x, y) blue.
• Fill everything directly above (x, y) to blue. (This is a recursive call.)
• Fill everthying directly below (x, y) to blue. (This is another recursive call.)
• Fill everthying directly to the left of (x, y) to blue. (This is yet another recursive call.)
• Fill everthying directly to the right of (x, y) to blue. (This is one more recursive call.)

Note: Each of the steps in the list above corresponds to just one Python statement. The only functions you need to know about (besides the one you are modifying) are:

• canvas.getPixel(x, y)— this returns the color of the pixel at coordinates (x, y). The value it returns will typically be a string like "blue", "white", "black", etc.
• canvas.setPixel(x, y, "blue")— this colors the pixel at coordinates (x, y) blue.

What To Turn In.

Submit your program files to Moodle. Be sure that your name is in the program prologue's comment section of the program, and that you have put an appropriate comment before each function and made your program easy to read and understand.

Reminder.
Be sure to save a copy of each program on your P:\ drive or gmail, etc.
You are responsible for keeping a copy of every program until the graded assignment is handed back.