Lib/lib-tk/turtle.py

# LogoMation-like turtle graphics

"""
Turtle graphics is a popular way for introducing programming to
kids. It was part of the original Logo programming language developed
by Wally Feurzeig and Seymour Papert in 1966.

Imagine a robotic turtle starting at (0, 0) in the x-y plane. Give it
the command turtle.forward(15), and it moves (on-screen!) 15 pixels in
the direction it is facing, drawing a line as it moves. Give it the
command turtle.left(25), and it rotates in-place 25 degrees clockwise.

By combining together these and similar commands, intricate shapes and
pictures can easily be drawn.
"""

from math import * # Also for export
from time import sleep
import Tkinter

speeds = ['fastest', 'fast', 'normal', 'slow', 'slowest']

class Error(Exception):
    pass

class RawPen:

    def __init__(self, canvas):
        self._canvas = canvas
        self._items = []
        self._tracing = 1
        self._arrow = 0
        self._delay = 10     # default delay for drawing
        self._angle = 0.0
        self.degrees()
        self.reset()

    def degrees(self, fullcircle=360.0):
        """ Set angle measurement units to degrees.

        Example:
        >>> turtle.degrees()
        """
        # Don't try to change _angle if it is 0, because
        # _fullcircle might not be set, yet
        if self._angle:
            self._angle = (self._angle / self._fullcircle) * fullcircle
        self._fullcircle = fullcircle
        self._invradian = pi / (fullcircle * 0.5)

    def radians(self):
        """ Set the angle measurement units to radians.

        Example:
        >>> turtle.radians()
        """
        self.degrees(2.0*pi)

    def reset(self):
        """ Clear the screen, re-center the pen, and set variables to
        the default values.

        Example:
        >>> turtle.position()
        [0.0, -22.0]
        >>> turtle.heading()
        100.0
        >>> turtle.reset()
        >>> turtle.position()
        [0.0, 0.0]
        >>> turtle.heading()
        0.0
        """
        canvas = self._canvas
        self._canvas.update()
        width = canvas.winfo_width()
        height = canvas.winfo_height()
        if width <= 1:
            width = canvas['width']
        if height <= 1:
            height = canvas['height']
        self._origin = float(width)/2.0, float(height)/2.0
        self._position = self._origin
        self._angle = 0.0
        self._drawing = 1
        self._width = 1
        self._color = "black"
        self._filling = 0
        self._path = []
        self.clear()
        canvas._root().tkraise()

    def clear(self):
        """ Clear the screen. The turtle does not move.

        Example:
        >>> turtle.clear()
        """
        self.fill(0)
        canvas = self._canvas
        items = self._items
        self._items = []
        for item in items:
            canvas.delete(item)
        self._delete_turtle()
        self._draw_turtle()

    def tracer(self, flag):
        """ Set tracing on if flag is True, and off if it is False.
        Tracing means line are drawn more slowly, with an
        animation of an arrow along the line.

        Example:
        >>> turtle.tracer(False)   # turns off Tracer
        """
        self._tracing = flag
        if not self._tracing:
            self._delete_turtle()
        self._draw_turtle()

    def forward(self, distance):
        """ Go forward distance steps.

        Example:
        >>> turtle.position()
        [0.0, 0.0]
        >>> turtle.forward(25)
        >>> turtle.position()
        [25.0, 0.0]
        >>> turtle.forward(-75)
        >>> turtle.position()
        [-50.0, 0.0]
        """
        x0, y0 = start = self._position
        x1 = x0 + distance * cos(self._angle*self._invradian)
        y1 = y0 - distance * sin(self._angle*self._invradian)
        self._goto(x1, y1)

    def backward(self, distance):
        """ Go backwards distance steps.

        The turtle's heading does not change.

        Example:
        >>> turtle.position()
        [0.0, 0.0]
        >>> turtle.backward(30)
        >>> turtle.position()
        [-30.0, 0.0]
        """
        self.forward(-distance)

    def left(self, angle):
        """ Turn left angle units (units are by default degrees,
        but can be set via the degrees() and radians() functions.)

        When viewed from above, the turning happens in-place around
        its front tip.

        Example:
        >>> turtle.heading()
        22
        >>> turtle.left(45)
        >>> turtle.heading()
        67.0
        """
        self._angle = (self._angle + angle) % self._fullcircle
        self._draw_turtle()

    def right(self, angle):
        """ Turn right angle units (units are by default degrees,
        but can be set via the degrees() and radians() functions.)

        When viewed from above, the turning happens in-place around
        its front tip.

        Example:
        >>> turtle.heading()
        22
        >>> turtle.right(45)
        >>> turtle.heading()
        337.0
        """
        self.left(-angle)

    def up(self):
        """ Pull the pen up -- no drawing when moving.

        Example:
        >>> turtle.up()
        """
        self._drawing = 0

    def down(self):
        """ Put the pen down -- draw when moving.

        Example:
        >>> turtle.down()
        """
        self._drawing = 1

    def width(self, width):
        """ Set the line to thickness to width.

        Example:
        >>> turtle.width(10)
        """
        self._width = float(width)

    def color(self, *args):
        """ Set the pen color.

        Three input formats are allowed:

            color(s)
            s is a Tk specification string, such as "red" or "yellow"

            color((r, g, b))
            *a tuple* of r, g, and b, which represent, an RGB color,
            and each of r, g, and b are in the range [0..1]

            color(r, g, b)
            r, g, and b represent an RGB color, and each of r, g, and b
            are in the range [0..1]

        Example:

        >>> turtle.color('brown')
        >>> tup = (0.2, 0.8, 0.55)
        >>> turtle.color(tup)
        >>> turtle.color(0, .5, 0)
        """
        if not args:
            raise Error, "no color arguments"
        if len(args) == 1:
            color = args[0]
            if type(color) == type(""):
                # Test the color first
                try:
                    id = self._canvas.create_line(0, 0, 0, 0, fill=color)
                except Tkinter.TclError:
                    raise Error, "bad color string: %r" % (color,)
                self._set_color(color)
                return
            try:
                r, g, b = color
            except:
                raise Error, "bad color sequence: %r" % (color,)
        else:
            try:
                r, g, b = args
            except:
                raise Error, "bad color arguments: %r" % (args,)
        assert 0 <= r <= 1
        assert 0 <= g <= 1
        assert 0 <= b <= 1
        x = 255.0
        y = 0.5
        self._set_color("#%02x%02x%02x" % (int(r*x+y), int(g*x+y), int(b*x+y)))

    def _set_color(self,color):
        self._color = color
        self._draw_turtle()

    def write(self, text, move=False):
        """ Write text at the current pen position.

        If move is true, the pen is moved to the bottom-right corner
        of the text. By default, move is False.

        Example:
        >>> turtle.write('The race is on!')
        >>> turtle.write('Home = (0, 0)', True)
        """
        x, y  = self._position
        x = x-1 # correction -- calibrated for Windows
        item = self._canvas.create_text(x, y,
                                        text=str(text), anchor="sw",
                                        fill=self._color)
        self._items.append(item)
        if move:
            x0, y0, x1, y1 = self._canvas.bbox(item)
            self._goto(x1, y1)
        self._draw_turtle()

    def fill(self, flag):
        """ Call fill(1) before drawing the shape you
         want to fill, and fill(0) when done.

        Example:
        >>> turtle.fill(1)
        >>> turtle.forward(100)
        >>> turtle.left(90)
        >>> turtle.forward(100)
        >>> turtle.left(90)
        >>> turtle.forward(100)
        >>> turtle.left(90)
        >>> turtle.forward(100)
        >>> turtle.fill(0)
        """
        if self._filling:
            path = tuple(self._path)
            smooth = self._filling < 0
            if len(path) > 2:
                item = self._canvas._create('polygon', path,
                                            {'fill': self._color,
                                             'smooth': smooth})
                self._items.append(item)
                self._canvas.update()
        self._path = []
        self._filling = flag
        if flag:
            self._path.append(self._position)

    def begin_fill(self):
        """ Called just before drawing a shape to be filled.
            Must eventually be followed by a corresponding end_fill() call.
            Otherwise it will be ignored.

        Example:
        >>> turtle.begin_fill()
        >>> turtle.forward(100)
        >>> turtle.left(90)
        >>> turtle.forward(100)
        >>> turtle.left(90)
        >>> turtle.forward(100)
        >>> turtle.left(90)
        >>> turtle.forward(100)
        >>> turtle.end_fill()
        """
        self._path = [self._position]
        self._filling = 1

    def end_fill(self):
        """ Called after drawing a shape to be filled.

        Example:
        >>> turtle.begin_fill()
        >>> turtle.forward(100)
        >>> turtle.left(90)
        >>> turtle.forward(100)
        >>> turtle.left(90)
        >>> turtle.forward(100)
        >>> turtle.left(90)
        >>> turtle.forward(100)
        >>> turtle.end_fill()
        """
        self.fill(0)

    def circle(self, radius, extent = None):
        """ Draw a circle with given radius.
        The center is radius units left of the turtle; extent
        determines which part of the circle is drawn. If not given,
        the entire circle is drawn.

        If extent is not a full circle, one endpoint of the arc is the
        current pen position. The arc is drawn in a counter clockwise
        direction if radius is positive, otherwise in a clockwise
        direction. In the process, the direction of the turtle is
        changed by the amount of the extent.

        >>> turtle.circle(50)
        >>> turtle.circle(120, 180)  # half a circle
        """
        if extent is None:
            extent = self._fullcircle
        frac = abs(extent)/self._fullcircle
        steps = 1+int(min(11+abs(radius)/6.0, 59.0)*frac)
        w = 1.0 * extent / steps
        w2 = 0.5 * w
        l = 2.0 * radius * sin(w2*self._invradian)
        if radius < 0:
            l, w, w2 = -l, -w, -w2
        self.left(w2)
        for i in range(steps):
            self.forward(l)
            self.left(w)
        self.right(w2)

    def heading(self):
        """ Return the turtle's current heading.

        Example:
        >>> turtle.heading()
        67.0
        """
        return self._angle

    def setheading(self, angle):
        """ Set the turtle facing the given angle.

        Here are some common directions in degrees:

           0 - east
          90 - north
         180 - west
         270 - south

        Example:
        >>> turtle.setheading(90)
        >>> turtle.heading()
        90
        >>> turtle.setheading(128)
        >>> turtle.heading()
        128
        """
        self._angle = angle
        self._draw_turtle()

    def window_width(self):
        """ Returns the width of the turtle window.

        Example:
        >>> turtle.window_width()
        640
        """
        width = self._canvas.winfo_width()
        if width <= 1:  # the window isn't managed by a geometry manager
            width = self._canvas['width']
        return width

    def window_height(self):
        """ Return the height of the turtle window.

        Example:
        >>> turtle.window_height()
        768
        """
        height = self._canvas.winfo_height()
        if height <= 1: # the window isn't managed by a geometry manager
            height = self._canvas['height']
        return height

    def position(self):
        """ Return the current (x, y) location of the turtle.

        Example:
        >>> turtle.position()
        [0.0, 240.0]
        """
        x0, y0 = self._origin
        x1, y1 = self._position
        return [x1-x0, -y1+y0]

    def setx(self, xpos):
        """ Set the turtle's x coordinate to be xpos.

        Example:
        >>> turtle.position()
        [10.0, 240.0]
        >>> turtle.setx(10)
        >>> turtle.position()
        [10.0, 240.0]
        """
        x0, y0 = self._origin
        x1, y1 = self._position
        self._goto(x0+xpos, y1)

    def sety(self, ypos):
        """ Set the turtle's y coordinate to be ypos.

        Example:
        >>> turtle.position()
        [0.0, 0.0]
        >>> turtle.sety(-22)
        >>> turtle.position()
        [0.0, -22.0]
        """
        x0, y0 = self._origin
        x1, y1 = self._position
        self._goto(x1, y0-ypos)

    def towards(self, *args):
        """Returs the angle, which corresponds to the line
        from turtle-position to point (x,y).

        Argument can be two coordinates or one pair of coordinates
        or a RawPen/Pen instance.

        Example:
        >>> turtle.position()
        [10.0, 10.0]
        >>> turtle.towards(0,0)
        225.0
        """
        if len(args) == 2:
            x, y = args
        else:
            arg = args[0]
            if isinstance(arg, RawPen):
                x, y = arg.position()
            else:
                x, y = arg
        x0, y0 = self.position()
        dx = x - x0
        dy = y - y0
        return (atan2(dy,dx) / self._invradian) % self._fullcircle

    def goto(self, *args):
        """ Go to the given point.

        If the pen is down, then a line will be drawn. The turtle's
        orientation does not change.

        Two input formats are accepted:

           goto(x, y)
           go to point (x, y)

           goto((x, y))
           go to point (x, y)

        Example:
        >>> turtle.position()
        [0.0, 0.0]
        >>> turtle.goto(50, -45)
        >>> turtle.position()
        [50.0, -45.0]
        """
        if len(args) == 1:
            try:
                x, y = args[0]
            except:
                raise Error, "bad point argument: %r" % (args[0],)
        else:
            try:
                x, y = args
            except:
                raise Error, "bad coordinates: %r" % (args[0],)
        x0, y0 = self._origin
        self._goto(x0+x, y0-y)

    def _goto(self, x1, y1):
        x0, y0 = self._position
        self._position = map(float, (x1, y1))
        if self._filling:
            self._path.append(self._position)
        if self._drawing:
            if self._tracing:
                dx = float(x1 - x0)
                dy = float(y1 - y0)
                distance = hypot(dx, dy)
                nhops = int(distance)
                item = self._canvas.create_line(x0, y0, x0, y0,
                                                width=self._width,
                                                capstyle="round",
                                                fill=self._color)
                try:
                    for i in range(1, 1+nhops):
                        x, y = x0 + dx*i/nhops, y0 + dy*i/nhops
                        self._canvas.coords(item, x0, y0, x, y)
                        self._draw_turtle((x,y))
                        self._canvas.update()
                        self._canvas.after(self._delay)
                    # in case nhops==0
                    self._canvas.coords(item, x0, y0, x1, y1)
                    self._canvas.itemconfigure(item, arrow="none")
                except Tkinter.TclError:
                    # Probably the window was closed!
                    return
            else:
                item = self._canvas.create_line(x0, y0, x1, y1,
                                                width=self._width,
                                                capstyle="round",
                                                fill=self._color)
            self._items.append(item)
        self._draw_turtle()

    def speed(self, speed):
        """ Set the turtle's speed.

        speed must one of these five strings:

            'fastest' is a 0 ms delay
            'fast' is a 5 ms delay
            'normal' is a 10 ms delay
            'slow' is a 15 ms delay
            'slowest' is a 20 ms delay

         Example:
         >>> turtle.speed('slow')
        """
        try:
            speed = speed.strip().lower()
            self._delay = speeds.index(speed) * 5
        except:
            raise ValueError("%r is not a valid speed. speed must be "
                             "one of %s" % (speed, speeds))


    def delay(self, delay):
        """ Set the drawing delay in milliseconds.

        This is intended to allow finer control of the drawing speed
        than the speed() method

        Example:
        >>> turtle.delay(15)
        """
        if int(delay) < 0:
            raise ValueError("delay must be greater than or equal to 0")
        self._delay = int(delay)

    def _draw_turtle(self, position=[]):
        if not self._tracing:
            self._canvas.update()
            return
        if position == []:
            position = self._position
        x,y = position
        distance = 8
        dx = distance * cos(self._angle*self._invradian)
        dy = distance * sin(self._angle*self._invradian)
        self._delete_turtle()
        self._arrow = self._canvas.create_line(x-dx,y+dy,x,y,
                                          width=self._width,
                                          arrow="last",
                                          capstyle="round",
                                          fill=self._color)
        self._canvas.update()

    def _delete_turtle(self):
        if self._arrow != 0:
            self._canvas.delete(self._arrow)
            self._arrow = 0


_root = None
_canvas = None
_pen = None
_width = 0.50                  # 50% of window width
_height = 0.75                 # 75% of window height
_startx = None
_starty = None
_title = "Turtle Graphics"     # default title

class Pen(RawPen):

    def __init__(self):
        global _root, _canvas
        if _root is None:
            _root = Tkinter.Tk()
            _root.wm_protocol("WM_DELETE_WINDOW", self._destroy)
            _root.title(_title)

        if _canvas is None:
            # XXX Should have scroll bars
            _canvas = Tkinter.Canvas(_root, background="white")
            _canvas.pack(expand=1, fill="both")

            setup(width=_width, height= _height, startx=_startx, starty=_starty)

        RawPen.__init__(self, _canvas)

    def _destroy(self):
        global _root, _canvas, _pen
        root = self._canvas._root()
        if root is _root:
            _pen = None
            _root = None
            _canvas = None
        root.destroy()

def _getpen():
    global _pen
    if not _pen:
        _pen = Pen()
    return _pen

class Turtle(Pen):
    pass

"""For documentation of the following functions see
   the RawPen methods with the same names
"""

def degrees(): _getpen().degrees()
def radians(): _getpen().radians()
def reset(): _getpen().reset()
def clear(): _getpen().clear()
def tracer(flag): _getpen().tracer(flag)
def forward(distance): _getpen().forward(distance)
def backward(distance): _getpen().backward(distance)
def left(angle): _getpen().left(angle)
def right(angle): _getpen().right(angle)
def up(): _getpen().up()
def down(): _getpen().down()
def width(width): _getpen().width(width)
def color(*args): _getpen().color(*args)
def write(arg, move=0): _getpen().write(arg, move)
def fill(flag): _getpen().fill(flag)
def begin_fill(): _getpen().begin_fill()
def end_fill(): _getpen().end_fill()
def circle(radius, extent=None): _getpen().circle(radius, extent)
def goto(*args): _getpen().goto(*args)
def heading(): return _getpen().heading()
def setheading(angle): _getpen().setheading(angle)
def position(): return _getpen().position()
def window_width(): return _getpen().window_width()
def window_height(): return _getpen().window_height()
def setx(xpos): _getpen().setx(xpos)
def sety(ypos): _getpen().sety(ypos)
def towards(*args): return _getpen().towards(*args)

def done(): _root.mainloop()
def delay(delay): return _getpen().delay(delay)
def speed(speed): return _getpen().speed(speed)

for methodname in dir(RawPen):
    """ copies RawPen docstrings to module functions of same name """
    if not methodname.startswith("_"):
        eval(methodname).__doc__ = RawPen.__dict__[methodname].__doc__


def setup(**geometry):
    """ Sets the size and position of the main window.

    Keywords are width, height, startx and starty:

    width: either a size in pixels or a fraction of the screen.
      Default is 50% of screen.
    height: either the height in pixels or a fraction of the screen.
      Default is 75% of screen.

    Setting either width or height to None before drawing will force
      use of default geometry as in older versions of turtle.py

    startx: starting position in pixels from the left edge of the screen.
      Default is to center window. Setting startx to None is the default
      and centers window horizontally on screen.

    starty: starting position in pixels from the top edge of the screen.
      Default is to center window. Setting starty to None is the default
      and centers window vertically on screen.

    Examples:
    >>> setup (width=200, height=200, startx=0, starty=0)

    sets window to 200x200 pixels, in upper left of screen

    >>> setup(width=.75, height=0.5, startx=None, starty=None)

    sets window to 75% of screen by 50% of screen and centers

    >>> setup(width=None)

    forces use of default geometry as in older versions of turtle.py
    """

    global _width, _height, _startx, _starty

    width = geometry.get('width',_width)
    if width >= 0 or width == None:
        _width = width
    else:
        raise ValueError, "width can not be less than 0"

    height = geometry.get('height',_height)
    if height >= 0 or height == None:
        _height = height
    else:
        raise ValueError, "height can not be less than 0"

    startx = geometry.get('startx', _startx)
    if startx >= 0 or startx == None:
        _startx = startx
    else:
        raise ValueError, "startx can not be less than 0"

    starty = geometry.get('starty', _starty)
    if starty >= 0 or starty == None:
        _starty = starty
    else:
        raise ValueError, "startx can not be less than 0"


    if _root and _width and _height:
        if 0 < _width <= 1:
            _width = _root.winfo_screenwidth() * +width
        if 0 < _height <= 1:
            _height = _root.winfo_screenheight() * _height

        # center window on screen
        if _startx is None:
            _startx = (_root.winfo_screenwidth() - _width) / 2

        if _starty is None:
            _starty = (_root.winfo_screenheight() - _height) / 2

        _root.geometry("%dx%d+%d+%d" % (_width, _height, _startx, _starty))

def title(title):
    """Set the window title.

    By default this is set to 'Turtle Graphics'

    Example:
    >>> title("My Window")
    """

    global _title
    _title = title

def demo():
    reset()
    tracer(1)
    up()
    backward(100)
    down()
    # draw 3 squares; the last filled
    width(3)
    for i in range(3):
        if i == 2:
            fill(1)
        for j in range(4):
            forward(20)
            left(90)
        if i == 2:
            color("maroon")
            fill(0)
        up()
        forward(30)
        down()
    width(1)
    color("black")
    # move out of the way
    tracer(0)
    up()
    right(90)
    forward(100)
    right(90)
    forward(100)
    right(180)
    down()
    # some text
    write("startstart", 1)
    write("start", 1)
    color("red")
    # staircase
    for i in range(5):
        forward(20)
        left(90)
        forward(20)
        right(90)
    # filled staircase
    fill(1)
    for i in range(5):
        forward(20)
        left(90)
        forward(20)
        right(90)
    fill(0)
    tracer(1)
    # more text
    write("end")

def demo2():
    # exercises some new and improved features
    speed('fast')
    width(3)

    # draw a segmented half-circle
    setheading(towards(0,0))
    x,y = position()
    r = (x**2+y**2)**.5/2.0
    right(90)
    pendown = True
    for i in range(18):
        if pendown:
            up()
            pendown = False
        else:
            down()
            pendown = True
        circle(r,10)
    sleep(2)

    reset()
    left(90)

    # draw a series of triangles
    l = 10
    color("green")
    width(3)
    left(180)
    sp = 5
    for i in range(-2,16):
        if i > 0:
            color(1.0-0.05*i,0,0.05*i)
            fill(1)
            color("green")
        for j in range(3):
            forward(l)
            left(120)
        l += 10
        left(15)
        if sp > 0:
            sp = sp-1
            speed(speeds[sp])
    color(0.25,0,0.75)
    fill(0)

    # draw and fill a concave shape
    left(120)
    up()
    forward(70)
    right(30)
    down()
    color("red")
    speed("fastest")
    fill(1)
    for i in range(4):
        circle(50,90)
        right(90)
        forward(30)
        right(90)
    color("yellow")
    fill(0)
    left(90)
    up()
    forward(30)
    down();

    color("red")

    # create a second turtle and make the original pursue and catch it
    turtle=Turtle()
    turtle.reset()
    turtle.left(90)
    turtle.speed('normal')
    turtle.up()
    turtle.goto(280,40)
    turtle.left(24)
    turtle.down()
    turtle.speed('fast')
    turtle.color("blue")
    turtle.width(2)
    speed('fastest')

    # turn default turtle towards new turtle object
    setheading(towards(turtle))
    while ( abs(position()[0]-turtle.position()[0])>4 or
            abs(position()[1]-turtle.position()[1])>4):
        turtle.forward(3.5)
        turtle.left(0.6)
        # turn default turtle towards new turtle object
        setheading(towards(turtle))
        forward(4)
    write("CAUGHT! ", move=True)



if __name__ == '__main__':
    demo()
    sleep(3)
    demo2()
    done()