Difference between revisions of "CSC111 Programs for Week 10 2015"

From dftwiki3
Jump to: navigation, search
(Created page with "--~~~~ ---- <br /> =Skeleton Program for Processing Images= <br /> The program below will work with this image, named "catGlasses.gif". It should be located in the same direc...")
 
(→‎Aquarium)
 
(19 intermediate revisions by the same user not shown)
Line 2: Line 2:
 
----
 
----
 
<br />
 
<br />
−
=Skeleton Program for Processing Images=
+
=Skeleton Program for Displaying an Image=
 
<br />
 
<br />
 
The program below will work with this image, named "catGlasses.gif".  It should be located in the same directory where the program is saved.
 
The program below will work with this image, named "catGlasses.gif".  It should be located in the same directory where the program is saved.
Line 51: Line 51:
 
</source>
 
</source>
 
<br />
 
<br />
 +
=Skeleton Program for Processing an Image=
 +
<br />
 +
<source lang="python">
 +
# pixelProcessingSkel.py
 +
# D. Thiebaut
 +
# Simple skeleton program for processing
 +
# the pixels of an image
 +
 +
from graphics import *
 +
 +
# image geometry
 +
# 424x18
 +
# make the window the same geometry
 +
WIDTH  = 424
 +
HEIGHT = 418
 +
IMAGEFILENAME = "catGlasses.gif"
 +
 +
#----------------------------------------------------------------
 +
def waitForClick( win, message ):
 +
    """ waitForClick: stops the GUI and displays a message. 
 +
    Returns when the user clicks the window. The message is erased."""
 +
 +
    # wait for user to click mouse to start
 +
    startMsg = Text( Point( win.getWidth()/2, win.getHeight()-15 ), message )
 +
    startMsg.draw( win )    # display message
 +
    win.getMouse()          # wait
 +
    startMsg.undraw()      # erase
 +
 +
def makeRed( win, img ):
 +
    """ set the red component of all the pixels to 255, the
 +
    maximum value.
 +
    """
 +
    global WIDTH, HEIGHT
 +
    for x in range( WIDTH ):
 +
        for y in range( HEIGHT ):
 +
            red, green, blue = img.getPixel( x, y )
 +
            img.setPixel( x, y, color_rgb(255, green, blue ) )
 +
           
 +
def main():
 +
 +
    win = GraphWin( "Image Editor", WIDTH, HEIGHT )
 +
 +
    img = Image( Point(WIDTH//2, HEIGHT//2), IMAGEFILENAME )
 +
    img.draw( win )
 +
 +
    makeRed( win, img )
 +
   
 +
    waitForClick( win, "click to close" )
 +
 +
    win.close()
 +
 +
main()
 +
</source>
 +
<br />
 +
<br />
 +
=Image Processing: Program developed in class=
 +
<br />
 +
<source lang="python">
 +
# pixelProcessingSkel.py
 +
# D. Thiebaut
 +
# Simple skeleton program for processing
 +
# the pixels of an image
 +
# This is the code we developed in class
 +
from graphics import *
 +
 +
# image geometry
 +
# make the window the same geometry
 +
WIDTH  = 424  #243
 +
HEIGHT = 418 #207
 +
IMAGEFILENAME = "catGlasses.gif" #"catHat.gif"
 +
 +
# other image we can play with
 +
#WIDTH  = 243
 +
#HEIGHT = 207
 +
#IMAGEFILENAME = "catHat.gif"
 +
 +
def waitForClick( win, message ):
 +
    """ waitForClick: stops the GUI and displays a message. 
 +
    Returns when the user clicks the window. The message is erased."""
 +
 +
    # wait for user to click mouse to start
 +
    startMsg = Text( Point( win.getWidth()/2, win.getHeight()-15 ), message )
 +
    startMsg.draw( win )    # display message
 +
    win.getMouse()          # wait
 +
    startMsg.undraw()      # erase
 +
 +
def saturate( x ):
 +
    """given a color amount, 0-255, returns 0 if the amount is closer to 0 than 255,
 +
    and returns 255 if not."""
 +
    if x < 255//2:
 +
        return 0
 +
    else:
 +
        return 255
 +
   
 +
def makeRed( win, img ):
 +
    """ set the red component of all the pixels to 255, the
 +
    maximum value.
 +
    """
 +
    global WIDTH, HEIGHT
 +
    for y in range( HEIGHT ):
 +
        win.update()
 +
        for x in range( WIDTH ):
 +
            red, green, blue = img.getPixel( x, y )
 +
            green, blue, red = red, green, blue
 +
            red = saturate( red )
 +
            green = saturate( green )
 +
            blue = saturate( blue )
 +
            img.setPixel( x, y, color_rgb(red, green, blue ))
 +
 +
def makeBlackAndWhite( win, img ):
 +
    """ Make the image black and white, by making each pixel
 +
    grey.  A grey pixel has the same amount of red, green, and blue.
 +
    """
 +
    global WIDTH, HEIGHT
 +
    for y in range( HEIGHT ):
 +
        win.update()
 +
        for x in range( WIDTH ):
 +
            red, green, blue = img.getPixel( x, y )
 +
            # make the pixel grey, and use the average of the 3 values
 +
            # as the amount of grey.
 +
            avg = (green+blue+red)//3
 +
            img.setPixel( x, y, color_rgb(avg, avg, avg ) )
 +
 +
def addBorder( win, img ):
 +
    """add a red border at the top of the image"
 +
    for y in range( 0, 15 ):
 +
        for x in range( WIDTH ):
 +
            img.setPixel( x, y, color_rgb( 255, 0, 0 ) )
 +
 +
def main():
 +
 +
    win = GraphWin( "Dominique Thiebaut", WIDTH, HEIGHT )
 +
 +
    img = Image( Point(WIDTH//2, HEIGHT//2), IMAGEFILENAME )
 +
    img.draw( win )
 +
 +
    makeRed( win, img )
 +
    addBorder( win, img )
 +
   
 +
    waitForClick( win, "click to close" )
 +
 +
    win.close()
 +
 +
main()
 +
 +
</source>
 +
<br />
 +
 +
=Playing Checkers=
 +
<br />
 +
==ChangeColorPiece.py==
 +
[[Image:piece.gif|right]][[Image:piece2.gif|right]]
 +
<br />
 +
<source lang="python">
 +
# changeColorPiece.py
 +
# D. Thiebaut
 +
# Create new checkers image with different color.
 +
# based on piece.gif.  New image saved in piece2.gif
 +
#
 +
from graphics import *
 +
 +
WIDTH = 80  # dimension of checkers piece
 +
HEIGHT= 80
 +
 +
def main():
 +
    # open the window
 +
    win = GraphWin( "Checkers", WIDTH, HEIGHT )
 +
 +
    # open image of black piece
 +
    piece = Image( Point( WIDTH//2, HEIGHT//2 ),
 +
                  "piece.gif" )
 +
    piece.draw( win )
 +
 +
    # change color of all the dark pixels
 +
    for x in range( WIDTH ):
 +
        for y in range( HEIGHT ):
 +
            r, g, b = piece.getPixel( x, y )
 +
 +
            # don't change the color of the mostly white pixels
 +
            if r>255-10 and g>255-10 and b>255-10:
 +
                continue
 +
 +
            # create a new color based on the r,g,b of the original pixel
 +
            newColor = color_rgb( r + (255-r)//2, g,  b+(255-b)//2 )
 +
            piece.setPixel( x, y, newColor )
 +
 +
    # save modified image into new file
 +
    piece.save( "piece2.gif" )
 +
 +
    # close window
 +
    win.close()
 +
 +
main()
 +
 +
</source>
 +
<br />
 +
 +
==Checkers0.py==
 +
<br />
 +
[[Image:Checkers0.png|right|150px]]
 +
This program is the bare skeleton for display the board.  You have to add the code inside the '''displayBoard()''' function.
 +
<br />
 +
<source lang="python">
 +
# checkers0.py
 +
# D. Thiebaut
 +
# A first program to display an 8x8 chessboard
 +
# in a graphic window.
 +
#
 +
from graphics import *
 +
 +
WIDTH = 600    # width of the window
 +
HEIGHT= 600    # height of the window
 +
SIDE  = 600//8 # the side of a cell of the 8x8 board
 +
 +
 +
def displayBoard( win ):
 +
    """displays an 8x8 board in the graphic window.  The board extends to the sides of the window'''
 +
    # add your code here...
 +
    return
 +
 +
def waitForClick( win, message ):
 +
    """ waitForClick: stops the GUI and displays a message. 
 +
    Returns when the user clicks the window. The message is erased."""
 +
 +
    # wait for user to click mouse to start
 +
    startMsg = Text( Point( win.getWidth()/2, win.getHeight()-15 ), message )
 +
    startMsg.draw( win )    # display message
 +
    win.getMouse()          # wait
 +
    startMsg.undraw()      # erase
 +
 +
 +
def main():
 +
    # open the window
 +
    win = GraphWin( "Checkers", WIDTH, HEIGHT )
 +
 +
    # display 8x8 checkers board
 +
    displayBoard( win )
 +
 +
    # wait for user to click before closing everything...
 +
    waitForClick( win, "click to close" )
 +
 +
    win.close()
 +
 +
main()
 +
 +
</source>
 +
<br />
 +
 +
==Display Checkers==
 +
<br />
 +
This is a cleaned up version of the program we created in class on 4/08/15.  It only displays the checkers pieces on black squares only, white pieces on the top 3 rows, black pieces on the bottom 3 rows.
 +
<br />
 +
<source lang="python">
 +
# checkers4.py
 +
# D. Thiebaut
 +
# Displays the images for the checkers.
 +
#
 +
from graphics import *
 +
 +
WIDTH = 680
 +
HEIGHT= 680
 +
SIDE  = 680 // 8
 +
 +
class CheckersPiece:
 +
    def __init__( self, col, ii, jj ):
 +
        self.color = col
 +
        self.i    = ii
 +
        self.j    = jj
 +
       
 +
        if col=="white":
 +
            self.image = Image( Point( ii*SIDE + SIDE//2,
 +
                                      jj*SIDE + SIDE//2 ), "piece2.gif" )
 +
        else:
 +
            self.image = Image( Point( ii*SIDE + SIDE//2,
 +
                                      jj*SIDE + SIDE//2 ), "piece.gif" )
 +
 +
    def draw( self, win ): 
 +
        self.image.draw( win )
 +
 +
    def undraw( self ):
 +
        self.image.undraw()
 +
 +
 +
def isWhiteCell( i, j ):
 +
    """returns True if the cell identified by (i,j) is
 +
    a white cell on the board.  White cells correspond to
 +
    i+j being an even number."""
 +
    if (i+j) % 2 == 0:
 +
        return True
 +
    else:
 +
        return False
 +
       
 +
def displayBoard( win ):
 +
    """display board with alternating black and white cells"""
 +
    for i in range( 0, 8 ):
 +
        for j in range( 0, 8 ):
 +
            x = i * SIDE
 +
            y = j * SIDE
 +
            rect = Rectangle( Point( x, y ), Point( x+SIDE, y+SIDE ) )
 +
            if isWhiteCell( i, j ):
 +
                rect.setFill( "white" )
 +
            else:
 +
                rect.setFill( "grey" ) 
 +
            rect.draw( win )
 +
            #Text( Point( x+side//2, y+side//2 ),
 +
            #      "{0:1} {1:1}".format( i, j ) ).draw(win)
 +
 +
 +
def displayCheckers( win ):
 +
    """ display checkers on black cells only, top and bottom 3 rows"""
 +
    checkers = []
 +
    for i in range( 8 ):
 +
        # top 3 rows
 +
        for j in range( 0, 3 ):
 +
            if isWhiteCell( i, j )==False:
 +
                piece = CheckersPiece( "white", i, j )
 +
                piece.draw( win )
 +
                checkers.append( piece )
 +
 +
        # bottom 3 rows
 +
        for j in range( 5, 8 ):
 +
            if isWhiteCell( i, j )==False:
 +
                piece = CheckersPiece( "black", i, j )
 +
                piece.draw( win )
 +
                checkers.append( piece )
 +
   
 +
    return checkers
 +
 +
   
 +
 +
def main():
 +
    # open the window
 +
    win = GraphWin( "Checkers", WIDTH, HEIGHT )
 +
 +
    # display 8x8 checkers board
 +
    displayBoard( win )
 +
 +
    # display the checkers on top of the board.
 +
    # 3 rows of white checkers on black cells
 +
    # and 3 rows of black checkers on white cells
 +
    checkers = displayCheckers( win )
 +
   
 +
    win.getMouse()
 +
    win.close()
 +
 +
main()
 +
 +
</source>
 +
<br />
 +
 +
<!--
 +
=Checkers Program Created in Class, 4/08/15=
 +
<br />
 +
<source lang="python">
 +
# checkers00.py
 +
# D. Thiebaut
 +
# This is the program we developed in class.
 +
# It displays a board with dark and white cells.
 +
# It displays images for the checkers on dark cells only.
 +
#
 +
from graphics import *
 +
 +
WIDTH = 680    # width of the window
 +
                        #(adjusted to be slightly bigger than the image of the checkers piece)
 +
HEIGHT= 680    # height of the window
 +
SIDE  = 680//8 # the side of a cell of the 8x8 board
 +
 +
# ---------------------------------------------------------------------------------
 +
class Piece:
 +
    """A class defining an individual checkers piece."""
 +
 +
    def __init__( self, ii, jj, col ):
 +
        """constructor.  Given an position on the board, ii, jj, and a color col,
 +
        creates a checkers piece of that color on the cell ii, jj on the board.  We
 +
        assume that the top-left cell is at 0, 0."""
 +
        self.i = ii
 +
        self.j = jj
 +
        self.color = col
 +
        x = ii * SIDE + SIDE//2
 +
        y = jj * SIDE + SIDE//2
 +
 +
        """
 +
        # old code: creates a piece using concentrinc circles
 +
        self.circ1 = Circle( Point( x, y ), SIDE//2 )
 +
        if col=="white":
 +
            self.circ1.setFill( color_rgb( 250, 250, 250 ) )
 +
        else:
 +
            self.circ1.setFill( color_rgb( 10, 10, 10 ) )
 +
           
 +
        self.circ2 = Circle( Point( x, y ), SIDE//2 - 5 )
 +
        if col=="white":
 +
            self.circ2.setFill( color_rgb( 230, 230, 230 ) )
 +
        else:
 +
            self.circ2.setFill( color_rgb( 50, 50, 50 ) )
 +
        """
 +
 +
        # new code: creates a piece using an image, either "piece.gif" which is
 +
        # black, or "piece2.gif" which is purple.
 +
        if col=="white":
 +
            self.image = Image( Point( x, y ), "piece.gif" )
 +
        else:
 +
            self.image = Image( Point( x, y ), "piece2.gif" )
 +
 +
    def draw( self, win ):
 +
        """ draw the piece on the graphic window.
 +
        """
 +
        """
 +
        # old code
 +
        self.circ1.draw( win )
 +
        self.circ2.draw( win )
 +
        """
 +
 +
        # new code
 +
        self.image.draw( win )
 +
       
 +
 +
# ---------------------------------------------------------------------------------
 +
 +
def displayBoard( win ):
 +
    """display an 8x8 board"""
 +
    for i in range( 8 ):
 +
        for j in range( 8 ):
 +
            # compute the coordinates of the top-left point that will define
 +
            # the rectangular cell
 +
            x = i*SIDE
 +
            y = j*SIDE
 +
 +
            # create a rectangle that is square, with width and height equal to SIDE.
 +
            rect = Rectangle( Point( x, y ), Point( x+SIDE, y+SIDE ) )
 +
            if (i+j)%2 == 0:
 +
                rect.setFill( color_rgb( 255, 255, 255 ) )
 +
            else:
 +
                rect.setFill( color_rgb( 100, 100, 100 ) )
 +
 +
            # draw the square rectangle
 +
            rect.draw( win )
 +
 +
def isBlack( i, j ):
 +
    """A utility function that returns True if the cell at i, j should be
 +
    black.  We found out that if all the cells for which i+j is even should
 +
    be the same color.  So we decided that if (i+j) is odd, the cell should be
 +
    black.  If i+j is odd, then the remainder of the division by 2 is not 0"""
 +
    if (i+j)%2 == 0:
 +
        return False
 +
    else:
 +
        return True
 +
   
 +
def displayCheckers( win ):
 +
    """displays the pieces on the board, on the top and bottom 3 rows, and
 +
    on black cells only."""
 +
    checkers = []
 +
    for i in range( 8 ):
 +
        for j in range( 3 ):
 +
            if isBlack( i, j ):
 +
                piece = Piece( i, j, "white" )
 +
                piece.draw( win )
 +
                checkers.append( piece )
 +
 +
    for i in range( 8 ):
 +
        for j in range( 5, 8 ):
 +
            if isBlack( i, j ):
 +
                piece = Piece( i, j, "black" )
 +
                piece.draw( win )
 +
                checkers.append( piece )
 +
           
 +
def waitForClick( win, message ):
 +
    """ waitForClick: stops the GUI and displays a message. 
 +
    Returns when the user clicks the window. The message is erased."""
 +
    startMsg = Text( Point( win.getWidth()/2, win.getHeight()-15 ),
 +
                    message )
 +
    startMsg.draw( win )    # display message
 +
    win.getMouse()          # wait
 +
    startMsg.undraw()      # erase
 +
 +
def main():
 +
    # open the window
 +
    win = GraphWin( "Checkers", WIDTH, HEIGHT )
 +
 +
    # display 8x8 checkers board
 +
    displayBoard( win )
 +
    checkers = displayCheckers( win )
 +
   
 +
    # wait for user to click before closing everything...
 +
    waitForClick( win, "click to close" )
 +
 +
    win.close()
 +
 +
main()
 +
 +
</source>
 +
-->
 +
<br />
 +
<br />
 +
==Remove Checkers, One by One==
 +
<br />
 +
<source lang="python">
 +
# checkers00.py
 +
# D. Thiebaut
 +
# Displays checker board.  Then displays 3 rows of white
 +
# and black checkers pieces.
 +
# Allows the user to remove checkers, one by one, by
 +
# clicking on them.
 +
#
 +
from graphics import *
 +
 +
WIDTH = 680    # width of the window
 +
HEIGHT= 680    # height of the window
 +
SIDE  = 680//8 # the side of a cell of the 8x8 board
 +
 +
class Piece:
 +
    def __init__( self, ii, jj, col ):
 +
        self.i = ii
 +
        self.j = jj
 +
        self.color = col
 +
        x = ii * SIDE + SIDE//2
 +
        y = jj * SIDE + SIDE//2
 +
        """
 +
        self.circ1 = Circle( Point( x, y ), SIDE//2 )
 +
        if col=="white":
 +
            self.circ1.setFill( color_rgb( 250, 250, 250 ) )
 +
        else:
 +
            self.circ1.setFill( color_rgb( 10, 10, 10 ) )
 +
           
 +
        self.circ2 = Circle( Point( x, y ), SIDE//2 - 5 )
 +
        if col=="white":
 +
            self.circ2.setFill( color_rgb( 230, 230, 230 ) )
 +
        else:
 +
            self.circ2.setFill( color_rgb( 50, 50, 50 ) )
 +
        """
 +
        if col=="white":
 +
            self.image = Image( Point( x, y ), "piece2.gif" )
 +
        else:
 +
            self.image = Image( Point( x, y ), "piece.gif" )
 +
 +
    def __str__( self ):
 +
        return "Piece: ({0:1},{1:1}) {2:1}".format( self.i, self.j, self.color )
 +
   
 +
    def draw( self, win ):
 +
        """
 +
        self.circ1.draw( win )
 +
        self.circ2.draw( win )
 +
        """
 +
        self.image.draw( win )
 +
 +
    def undraw( self ):
 +
        self.image.undraw()
 +
       
 +
    def getI( self ):
 +
        return self.i
 +
 +
    def getJ( self ):
 +
        return self.j
 +
   
 +
    def moveToSquare( self, i, j, win ):
 +
        destX = i * SIDE + SIDE//2
 +
        destY = j * SIDE + SIDE//2
 +
        currentX = self.i * SIDE + SIDE//2
 +
        currentY = self.j * SIDE + SIDE//2
 +
        deltaX = destX - currentX
 +
        deltaY = destY - currentY
 +
        self.image.undraw()
 +
        self.image._move( deltaX, deltaY )
 +
        self.image.draw( win )
 +
        self.i = i
 +
        self.j = j
 +
       
 +
def displayBoard( win ):
 +
    """display an 8x8 board"""
 +
    for i in range( 8 ):
 +
        for j in range( 8 ):
 +
            x = i*SIDE
 +
            y = j*SIDE
 +
            rect = Rectangle( Point( x, y ), Point( x+SIDE, y+SIDE ) )
 +
            if (i+j)%2 == 0:
 +
                rect.setFill( color_rgb( 255, 255, 255 ) )
 +
            else:
 +
                rect.setFill( color_rgb( 100, 100, 100 ) )
 +
            rect.draw( win )
 +
 +
def isBlack( i, j ):
 +
    if (i+j)%2 == 0:
 +
        return False
 +
    else:
 +
        return True
 +
   
 +
def displayCheckers( win ):
 +
    checkers = []
 +
    for i in range( 8 ):
 +
        for j in range( 3 ):
 +
            if isBlack( i, j ):
 +
                piece = Piece( i, j, "white" )
 +
                piece.draw( win )
 +
                checkers.append( piece )
 +
 +
    for i in range( 8 ):
 +
        for j in range( 5, 8 ):
 +
            if isBlack( i, j ):
 +
                piece = Piece( i, j, "black" )
 +
                piece.draw( win )
 +
                checkers.append( piece )
 +
    return checkers
 +
 +
 +
def getCheckerPieceAt( i, j, checkers ):
 +
    for piece in checkers:
 +
        if piece.getI() == i and piece.getJ() == j:
 +
            return piece
 +
 +
    return None
 +
 +
def main():
 +
    # open the window
 +
    win = GraphWin( "Checkers", WIDTH, HEIGHT )
 +
 +
    # display 8x8 checkers board
 +
    displayBoard( win )
 +
    checkers = displayCheckers( win )
 +
 +
    # -----------------------------------------------
 +
    # Animation Loop
 +
    # -----------------------------------------------
 +
    while len( checkers ) > 0:
 +
        # see if the user clicked the mouse
 +
        mouseClick = win.checkMouse()
 +
 +
        # if not, then keep looping and do nothing
 +
        if mouseClick == None:
 +
            continue
 +
 +
        # mouseClick is the point that was clicked.
 +
        # transform the x and y of the point into i and j
 +
        # identifying the squares of the checkerboard
 +
        i = mouseClick.getX() // SIDE
 +
        j = mouseClick.getY() // SIDE
 +
        print( "User clicked on cell", i, ", ", j )
 +
       
 +
        # check to see if a checkers piece was clicked
 +
        piece = getCheckerPieceAt( i, j, checkers )
 +
       
 +
        if piece != None:
 +
            # yes, a piece was clicked!  Remove it.
 +
            print( "User clicked on a checkers piece", piece )
 +
            piece.undraw()
 +
            checkers.remove( piece )
 +
       
 +
 +
    win.close()
 +
 +
main()
 +
 +
</source>
 +
<br />
 +
==Move Checkers==
 +
<br />
 +
Here the user moves the checkers, one by one, to any place on the board.
 +
<br />
 +
<source lang="python">
 +
# checkers4.py
 +
# D. Thiebaut
 +
# Displays the images for the checkers.
 +
#
 +
from graphics import *
 +
 +
WIDTH = 680
 +
HEIGHT= 680
 +
SIDE  = 680 // 8
 +
 +
class CheckersPiece:
 +
    def __init__( self, col, ii, jj ):
 +
        self.color = col
 +
        self.i    = ii
 +
        self.j    = jj
 +
       
 +
        if col=="white":
 +
            self.image = Image( Point( ii*SIDE + SIDE//2,
 +
                                      jj*SIDE + SIDE//2 ), "piece2.gif" )
 +
        else:
 +
            self.image = Image( Point( ii*SIDE + SIDE//2,
 +
                                      jj*SIDE + SIDE//2 ), "piece.gif" )
 +
    def getI( self ):
 +
        return self.i
 +
 +
    def getJ( self ):
 +
        return self.j
 +
   
 +
    def draw( self, win ): 
 +
        self.image.draw( win )
 +
 +
    def undraw( self ):
 +
        self.image.undraw()
 +
 +
    def moveToCell( self, ii, jj ):
 +
        self.image.move( (ii-self.i)*SIDE, (jj-self.j)*SIDE )
 +
       
 +
    def __str__( self ):
 +
        s = "Piece ({0:1},{1:1}) {2:1}".format( self.i, self.j, self.color)
 +
        return s
 +
   
 +
def isWhiteCell( i, j ):
 +
    """returns True if the cell identified by (i,j) is
 +
    a white cell on the board.  White cells correspond to
 +
    i+j being an even number."""
 +
    if (i+j) % 2 == 0:
 +
        return True
 +
    else:
 +
        return False
 +
       
 +
def displayBoard( win ):
 +
    """display board with alternating black and white cells"""
 +
    for i in range( 0, 8 ):
 +
        for j in range( 0, 8 ):
 +
            x = i * SIDE
 +
            y = j * SIDE
 +
            rect = Rectangle( Point( x, y ), Point( x+SIDE, y+SIDE ) )
 +
            if isWhiteCell( i, j ):
 +
                rect.setFill( "white" )
 +
            else:
 +
                rect.setFill( "grey" ) 
 +
            rect.draw( win )
 +
            #Text( Point( x+side//2, y+side//2 ),
 +
            #      "{0:1} {1:1}".format( i, j ) ).draw(win)
 +
 +
 +
def displayCheckers( win ):
 +
    """ display checkers on black cells only, top and bottom 3 rows"""
 +
    checkers = []
 +
    for i in range( 8 ):
 +
        # top 3 rows
 +
        for j in range( 0, 3 ):
 +
            if isWhiteCell( i, j )==False:
 +
                piece = CheckersPiece( "white", i, j )
 +
                piece.draw( win )
 +
                checkers.append( piece )
 +
 +
        # bottom 3 rows
 +
        for j in range( 5, 8 ):
 +
            if isWhiteCell( i, j )==False:
 +
                piece = CheckersPiece( "black", i, j )
 +
                piece.draw( win )
 +
                checkers.append( piece )
 +
   
 +
    return checkers
 +
 +
def getCheckersAt( i, j, checkers ):
 +
    for piece in checkers:
 +
        if piece.getI()==i and piece.getJ()==j:
 +
            return piece
 +
    return None
 +
 +
def main():
 +
    # open the window
 +
    win = GraphWin( "Checkers", WIDTH, HEIGHT )
 +
 +
    # display 8x8 checkers board
 +
    displayBoard( win )
 +
 +
    # display the checkers on top of the board.
 +
    # 3 rows of white checkers on black cells
 +
    # and 3 rows of black checkers on white cells
 +
    checkers = displayCheckers( win )
 +
 +
    # animation loop
 +
    clickedPiece = None
 +
    while True:
 +
        # check if use clicked on board
 +
        # if not, keep looping
 +
        p = win.checkMouse()
 +
        if p==None:
 +
            continue
 +
 +
        i = p.getX()//SIDE
 +
        j = p.getY()//SIDE
 +
        print( "user clicked on Cell", i, ",", j )
 +
       
 +
        piece = getCheckersAt( i, j, checkers )
 +
        # is it on a piece?
 +
        if piece != None:
 +
            # if so, remember that piece as the clicked-piece
 +
            print( "Clicked on", piece )
 +
            clickedPiece = piece
 +
            print( "clickedPiece is now", clickedPiece )
 +
           
 +
        else:
 +
            # if not on a piece, then clicked an empty cell
 +
            # if the clicked-piece exists,
 +
            if clickedPiece != None:
 +
                # then move it to the empty cell
 +
                clickedPiece.moveToCell( i, j )
 +
                print( "Moved piece", clickedPiece, "to", i,",", j )
 +
                # un-remember the cliked-piece
 +
                clickedPiece = None
 +
            else:
 +
            # if the clicked-piece does not exist
 +
                # then do nothing
 +
                continue
 +
       
 +
       
 +
    win.getMouse()
 +
    win.close()
 +
 +
main()
 +
 +
</source>
 +
<br />
 +
 +
=Aquarium=
 +
<br />
 +
<source lang="python">
 +
# aquarium.gif
 +
# D. Thiebaut
 +
# Displays 4 fish on the image, making them move randomly around the aquarium.
 +
#
 +
from graphics import *
 +
import random  # because the fish should move randomly, horizontally and vertically.
 +
 +
WIDTH  = 700 # geometry of tank2.gif
 +
HEIGHT = 517
 +
 +
class Fish:
 +
    """A class for the fish.  Build it so that it looks as much as possible the
 +
    other graphics objects in Zelle's library."""
 +
    def __init__( self, fileNm, xx, yy ):
 +
        self.fileName = fileNm
 +
        self.x = xx
 +
        self.y = yy
 +
        self.image = Image( Point( xx, yy ), fileNm )
 +
           
 +
    def draw( self, win ):
 +
        """draws the image on the graphic window."""
 +
        self.image.draw( win )
 +
       
 +
    def moveRandom( self ):
 +
        """move the fish to the left. 
 +
        deltax = - random.randrange( 10 )
 +
        deltay = random.randrange( -3, 3 )
 +
        self.image.move( deltax, deltay )
 +
        x = self.image.getAnchor().getX()
 +
        if x < -50:
 +
            self.image.move( WIDTH+100, 0 )
 +
           
 +
       
 +
def main():
 +
    # open the window
 +
    win = GraphWin( "CSC Aquarium", WIDTH, HEIGHT )
 +
 +
    # display background
 +
    background = Image( Point( WIDTH//2, HEIGHT//2 ), "tank2.gif" )
 +
    background.draw( win )
 +
 +
    fishList = []
 +
    for i in range( 4 ):
 +
        fish = Fish( "fish0.gif", i*100, 350 )
 +
        fish.draw( win )
 +
        fishList.append( fish )
 +
 +
    # animation loop
 +
    while True:
 +
 +
        # move all fish
 +
        for fish in fishList:
 +
            fish.moveRandom()
 +
 +
           
 +
 +
    win.getMouse()       
 +
    win.close()
 +
   
 +
main()
 +
 +
 +
</source>
 +
<br />
 +
<br />
 +
<br />
 +
<br />
 +
<br />
 +
<br />
 +
 +
[[Category:CSC111]][[Category:Python]]

Latest revision as of 11:30, 10 April 2015

--D. Thiebaut (talk) 05:48, 6 April 2015 (EDT)


Skeleton Program for Displaying an Image


The program below will work with this image, named "catGlasses.gif". It should be located in the same directory where the program is saved.

CatGlasses.gif


# imageProcessingSkel.py
# D. Thiebaut
# A skeleton program to start doing image processing
# in Python

from graphics import *

# image geometry
# 424x18
# make the window the same geometry
WIDTH  = 424
HEIGHT = 418
IMAGEFILENAME = "catGlasses.gif"

#----------------------------------------------------------------
def waitForClick( win, message ):
    """ waitForClick: stops the GUI and displays a message.  
    Returns when the user clicks the window. The message is erased."""

    # wait for user to click mouse to start
    startMsg = Text( Point( win.getWidth()/2, win.getHeight()-15 ), message )
    startMsg.draw( win )    # display message
    win.getMouse()          # wait
    startMsg.undraw()       # erase

def main():
    # open the window
    win = GraphWin( "Image Editor", WIDTH, HEIGHT )

    # open the cat image
    cat = Image( Point(WIDTH//2, HEIGHT//2), IMAGEFILENAME )
    cat.draw( win )

    waitForClick( win, "click to close" )

    win.close()

main()


Skeleton Program for Processing an Image


# pixelProcessingSkel.py
# D. Thiebaut
# Simple skeleton program for processing
# the pixels of an image

from graphics import *

# image geometry
# 424x18
# make the window the same geometry
WIDTH  = 424
HEIGHT = 418
IMAGEFILENAME = "catGlasses.gif"

#----------------------------------------------------------------
def waitForClick( win, message ):
    """ waitForClick: stops the GUI and displays a message.  
    Returns when the user clicks the window. The message is erased."""

    # wait for user to click mouse to start
    startMsg = Text( Point( win.getWidth()/2, win.getHeight()-15 ), message )
    startMsg.draw( win )    # display message
    win.getMouse()          # wait
    startMsg.undraw()       # erase

def makeRed( win, img ):
    """ set the red component of all the pixels to 255, the
    maximum value.
    """
    global WIDTH, HEIGHT
    for x in range( WIDTH ):
        for y in range( HEIGHT ):
            red, green, blue = img.getPixel( x, y )
            img.setPixel( x, y, color_rgb(255, green, blue ) )
            
def main():

    win = GraphWin( "Image Editor", WIDTH, HEIGHT )

    img = Image( Point(WIDTH//2, HEIGHT//2), IMAGEFILENAME )
    img.draw( win )

    makeRed( win, img )
    
    waitForClick( win, "click to close" )

    win.close()

main()



Image Processing: Program developed in class


# pixelProcessingSkel.py
# D. Thiebaut
# Simple skeleton program for processing
# the pixels of an image
# This is the code we developed in class
from graphics import *

# image geometry
# make the window the same geometry
WIDTH  = 424   #243 
HEIGHT = 418 #207
IMAGEFILENAME = "catGlasses.gif" #"catHat.gif"

# other image we can play with
#WIDTH  = 243 
#HEIGHT = 207
#IMAGEFILENAME = "catHat.gif"

def waitForClick( win, message ):
    """ waitForClick: stops the GUI and displays a message.  
    Returns when the user clicks the window. The message is erased."""

    # wait for user to click mouse to start
    startMsg = Text( Point( win.getWidth()/2, win.getHeight()-15 ), message )
    startMsg.draw( win )    # display message
    win.getMouse()          # wait
    startMsg.undraw()       # erase

def saturate( x ):
    """given a color amount, 0-255, returns 0 if the amount is closer to 0 than 255,
    and returns 255 if not."""
    if x < 255//2:
        return 0
    else:
        return 255
    
def makeRed( win, img ):
    """ set the red component of all the pixels to 255, the
    maximum value.
    """
    global WIDTH, HEIGHT
    for y in range( HEIGHT ):
        win.update()
        for x in range( WIDTH ):
            red, green, blue = img.getPixel( x, y )
            green, blue, red = red, green, blue
            red = saturate( red )
            green = saturate( green )
            blue = saturate( blue )
            img.setPixel( x, y, color_rgb(red, green, blue )) 

def makeBlackAndWhite( win, img ):
    """ Make the image black and white, by making each pixel
    grey.  A grey pixel has the same amount of red, green, and blue.
    """
    global WIDTH, HEIGHT
    for y in range( HEIGHT ):
        win.update()
        for x in range( WIDTH ):
            red, green, blue = img.getPixel( x, y )
            # make the pixel grey, and use the average of the 3 values
            # as the amount of grey.
            avg = (green+blue+red)//3
            img.setPixel( x, y, color_rgb(avg, avg, avg ) )

def addBorder( win, img ):
    """add a red border at the top of the image"
    for y in range( 0, 15 ):
        for x in range( WIDTH ):
            img.setPixel( x, y, color_rgb( 255, 0, 0 ) )

def main():

    win = GraphWin( "Dominique Thiebaut", WIDTH, HEIGHT )

    img = Image( Point(WIDTH//2, HEIGHT//2), IMAGEFILENAME )
    img.draw( win )

    makeRed( win, img )
    addBorder( win, img )
    
    waitForClick( win, "click to close" )

    win.close()

main()


Playing Checkers


ChangeColorPiece.py

Piece.gif
Piece2.gif


# changeColorPiece.py
# D. Thiebaut
# Create new checkers image with different color.
# based on piece.gif.  New image saved in piece2.gif
#
from graphics import *

WIDTH = 80  # dimension of checkers piece
HEIGHT= 80

def main():
    # open the window
    win = GraphWin( "Checkers", WIDTH, HEIGHT )

    # open image of black piece
    piece = Image( Point( WIDTH//2, HEIGHT//2 ),
                   "piece.gif" )
    piece.draw( win )

    # change color of all the dark pixels
    for x in range( WIDTH ):
        for y in range( HEIGHT ):
            r, g, b = piece.getPixel( x, y )

            # don't change the color of the mostly white pixels
            if r>255-10 and g>255-10 and b>255-10:
                continue

            # create a new color based on the r,g,b of the original pixel
            newColor = color_rgb( r + (255-r)//2, g,  b+(255-b)//2 )
            piece.setPixel( x, y, newColor )

    # save modified image into new file
    piece.save( "piece2.gif" )

    # close window
    win.close()

main()


Checkers0.py


Checkers0.png

This program is the bare skeleton for display the board. You have to add the code inside the displayBoard() function. 

# checkers0.py
# D. Thiebaut
# A first program to display an 8x8 chessboard
# in a graphic window.
# 
from graphics import *

WIDTH = 600    # width of the window
HEIGHT= 600    # height of the window
SIDE  = 600//8 # the side of a cell of the 8x8 board


def displayBoard( win ):
    """displays an 8x8 board in the graphic window.  The board extends to the sides of the window'''
    # add your code here...
    return

def waitForClick( win, message ):
    """ waitForClick: stops the GUI and displays a message.  
    Returns when the user clicks the window. The message is erased."""

    # wait for user to click mouse to start
    startMsg = Text( Point( win.getWidth()/2, win.getHeight()-15 ), message )
    startMsg.draw( win )    # display message
    win.getMouse()          # wait
    startMsg.undraw()       # erase


def main():
    # open the window
    win = GraphWin( "Checkers", WIDTH, HEIGHT )

    # display 8x8 checkers board
    displayBoard( win )

    # wait for user to click before closing everything...
    waitForClick( win, "click to close" )

    win.close()

main()


Display Checkers


This is a cleaned up version of the program we created in class on 4/08/15. It only displays the checkers pieces on black squares only, white pieces on the top 3 rows, black pieces on the bottom 3 rows. 

# checkers4.py
# D. Thiebaut
# Displays the images for the checkers.
#
from graphics import *

WIDTH = 680
HEIGHT= 680
SIDE  = 680 // 8

class CheckersPiece:
    def __init__( self, col, ii, jj ):
        self.color = col
        self.i     = ii
        self.j     = jj
        
        if col=="white":
            self.image = Image( Point( ii*SIDE + SIDE//2,
                                       jj*SIDE + SIDE//2 ), "piece2.gif" )
        else:
            self.image = Image( Point( ii*SIDE + SIDE//2,
                                       jj*SIDE + SIDE//2 ), "piece.gif" )

    def draw( self, win ):   
        self.image.draw( win )

    def undraw( self ):
        self.image.undraw()


def isWhiteCell( i, j ):
    """returns True if the cell identified by (i,j) is
    a white cell on the board.  White cells correspond to
    i+j being an even number."""
    if (i+j) % 2 == 0:
        return True
    else:
        return False
        
def displayBoard( win ):
    """display board with alternating black and white cells"""
    for i in range( 0, 8 ):
        for j in range( 0, 8 ):
            x = i * SIDE
            y = j * SIDE
            rect = Rectangle( Point( x, y ), Point( x+SIDE, y+SIDE ) )
            if isWhiteCell( i, j ): 
                rect.setFill( "white" ) 
            else:
                rect.setFill( "grey" )  
            rect.draw( win )
            #Text( Point( x+side//2, y+side//2 ),
            #      "{0:1} {1:1}".format( i, j ) ).draw(win)


def displayCheckers( win ):
    """ display checkers on black cells only, top and bottom 3 rows"""
    checkers = []
    for i in range( 8 ):
        # top 3 rows
        for j in range( 0, 3 ):
            if isWhiteCell( i, j )==False:
                piece = CheckersPiece( "white", i, j )
                piece.draw( win )
                checkers.append( piece )

        # bottom 3 rows
        for j in range( 5, 8 ):
            if isWhiteCell( i, j )==False:
                piece = CheckersPiece( "black", i, j )
                piece.draw( win )
                checkers.append( piece )
    
    return checkers

    

def main():
    # open the window
    win = GraphWin( "Checkers", WIDTH, HEIGHT )

    # display 8x8 checkers board
    displayBoard( win )

    # display the checkers on top of the board.
    # 3 rows of white checkers on black cells
    # and 3 rows of black checkers on white cells
    checkers = displayCheckers( win )
    
    win.getMouse()
    win.close()

main()




Remove Checkers, One by One


# checkers00.py
# D. Thiebaut
# Displays checker board.  Then displays 3 rows of white
# and black checkers pieces.
# Allows the user to remove checkers, one by one, by
# clicking on them.
# 
from graphics import *

WIDTH = 680    # width of the window
HEIGHT= 680    # height of the window
SIDE  = 680//8 # the side of a cell of the 8x8 board

class Piece:
    def __init__( self, ii, jj, col ):
        self.i = ii
        self.j = jj
        self.color = col
        x = ii * SIDE + SIDE//2
        y = jj * SIDE + SIDE//2
        """
        self.circ1 = Circle( Point( x, y ), SIDE//2 )
        if col=="white":
            self.circ1.setFill( color_rgb( 250, 250, 250 ) )
        else:
            self.circ1.setFill( color_rgb( 10, 10, 10 ) )
            
        self.circ2 = Circle( Point( x, y ), SIDE//2 - 5 )
        if col=="white":
            self.circ2.setFill( color_rgb( 230, 230, 230 ) )
        else:
            self.circ2.setFill( color_rgb( 50, 50, 50 ) )
        """
        if col=="white":
            self.image = Image( Point( x, y ), "piece2.gif" )
        else:
            self.image = Image( Point( x, y ), "piece.gif" )

    def __str__( self ):
        return "Piece: ({0:1},{1:1}) {2:1}".format( self.i, self.j, self.color )
    
    def draw( self, win ):
        """
        self.circ1.draw( win )
        self.circ2.draw( win )
        """
        self.image.draw( win )

    def undraw( self ):
        self.image.undraw()
        
    def getI( self ):
        return self.i

    def getJ( self ):
        return self.j
    
    def moveToSquare( self, i, j, win ):
        destX = i * SIDE + SIDE//2
        destY = j * SIDE + SIDE//2
        currentX = self.i * SIDE + SIDE//2
        currentY = self.j * SIDE + SIDE//2
        deltaX = destX - currentX
        deltaY = destY - currentY
        self.image.undraw()
        self.image._move( deltaX, deltaY )
        self.image.draw( win )
        self.i = i
        self.j = j
        
def displayBoard( win ):
    """display an 8x8 board"""
    for i in range( 8 ):
        for j in range( 8 ):
            x = i*SIDE
            y = j*SIDE
            rect = Rectangle( Point( x, y ), Point( x+SIDE, y+SIDE ) )
            if (i+j)%2 == 0:
                rect.setFill( color_rgb( 255, 255, 255 ) )
            else:
                rect.setFill( color_rgb( 100, 100, 100 ) )
            rect.draw( win )

def isBlack( i, j ):
    if (i+j)%2 == 0:
        return False
    else:
        return True
    
def displayCheckers( win ):
    checkers = []
    for i in range( 8 ):
        for j in range( 3 ):
            if isBlack( i, j ):
                piece = Piece( i, j, "white" )
                piece.draw( win )
                checkers.append( piece )

    for i in range( 8 ):
        for j in range( 5, 8 ):
            if isBlack( i, j ):
                piece = Piece( i, j, "black" )
                piece.draw( win )
                checkers.append( piece )
    return checkers


def getCheckerPieceAt( i, j, checkers ):
    for piece in checkers:
        if piece.getI() == i and piece.getJ() == j:
            return piece

    return None

def main():
    # open the window
    win = GraphWin( "Checkers", WIDTH, HEIGHT )

    # display 8x8 checkers board
    displayBoard( win )
    checkers = displayCheckers( win )

    # -----------------------------------------------
    # Animation Loop
    # -----------------------------------------------
    while len( checkers ) > 0:
        # see if the user clicked the mouse
        mouseClick = win.checkMouse()

        # if not, then keep looping and do nothing
        if mouseClick == None:
            continue

        # mouseClick is the point that was clicked.
        # transform the x and y of the point into i and j
        # identifying the squares of the checkerboard
        i = mouseClick.getX() // SIDE
        j = mouseClick.getY() // SIDE
        print( "User clicked on cell", i, ", ", j )
        
        # check to see if a checkers piece was clicked
        piece = getCheckerPieceAt( i, j, checkers )
        
        if piece != None:
            # yes, a piece was clicked!  Remove it.
            print( "User clicked on a checkers piece", piece )
            piece.undraw()
            checkers.remove( piece )
        

    win.close()

main()


Move Checkers


Here the user moves the checkers, one by one, to any place on the board. 

# checkers4.py
# D. Thiebaut
# Displays the images for the checkers.
#
from graphics import *

WIDTH = 680
HEIGHT= 680
SIDE  = 680 // 8

class CheckersPiece:
    def __init__( self, col, ii, jj ):
        self.color = col
        self.i     = ii
        self.j     = jj
        
        if col=="white":
            self.image = Image( Point( ii*SIDE + SIDE//2,
                                       jj*SIDE + SIDE//2 ), "piece2.gif" )
        else:
            self.image = Image( Point( ii*SIDE + SIDE//2,
                                       jj*SIDE + SIDE//2 ), "piece.gif" )
    def getI( self ):
        return self.i

    def getJ( self ):
        return self.j
    
    def draw( self, win ):   
        self.image.draw( win )

    def undraw( self ):
        self.image.undraw()

    def moveToCell( self, ii, jj ):
        self.image.move( (ii-self.i)*SIDE, (jj-self.j)*SIDE )
        
    def __str__( self ):
        s = "Piece ({0:1},{1:1}) {2:1}".format( self.i, self.j, self.color)
        return s
    
def isWhiteCell( i, j ):
    """returns True if the cell identified by (i,j) is
    a white cell on the board.  White cells correspond to
    i+j being an even number."""
    if (i+j) % 2 == 0:
        return True
    else:
        return False
        
def displayBoard( win ):
    """display board with alternating black and white cells"""
    for i in range( 0, 8 ):
        for j in range( 0, 8 ):
            x = i * SIDE
            y = j * SIDE
            rect = Rectangle( Point( x, y ), Point( x+SIDE, y+SIDE ) )
            if isWhiteCell( i, j ): 
                rect.setFill( "white" ) 
            else:
                rect.setFill( "grey" )  
            rect.draw( win )
            #Text( Point( x+side//2, y+side//2 ),
            #      "{0:1} {1:1}".format( i, j ) ).draw(win)


def displayCheckers( win ):
    """ display checkers on black cells only, top and bottom 3 rows"""
    checkers = []
    for i in range( 8 ):
        # top 3 rows
        for j in range( 0, 3 ):
            if isWhiteCell( i, j )==False:
                piece = CheckersPiece( "white", i, j )
                piece.draw( win )
                checkers.append( piece )

        # bottom 3 rows
        for j in range( 5, 8 ):
            if isWhiteCell( i, j )==False:
                piece = CheckersPiece( "black", i, j )
                piece.draw( win )
                checkers.append( piece )
    
    return checkers

def getCheckersAt( i, j, checkers ):
    for piece in checkers:
        if piece.getI()==i and piece.getJ()==j:
            return piece
    return None

def main():
    # open the window
    win = GraphWin( "Checkers", WIDTH, HEIGHT )

    # display 8x8 checkers board
    displayBoard( win )

    # display the checkers on top of the board.
    # 3 rows of white checkers on black cells
    # and 3 rows of black checkers on white cells
    checkers = displayCheckers( win )

    # animation loop
    clickedPiece = None
    while True:
        # check if use clicked on board
        # if not, keep looping
        p = win.checkMouse()
        if p==None:
            continue

        i = p.getX()//SIDE
        j = p.getY()//SIDE
        print( "user clicked on Cell", i, ",", j )
        
        piece = getCheckersAt( i, j, checkers )
        # is it on a piece?
        if piece != None:
            # if so, remember that piece as the clicked-piece
            print( "Clicked on", piece )
            clickedPiece = piece
            print( "clickedPiece is now", clickedPiece )
            
        else:
            # if not on a piece, then clicked an empty cell
            # if the clicked-piece exists,
            if clickedPiece != None:
                # then move it to the empty cell
                clickedPiece.moveToCell( i, j )
                print( "Moved piece", clickedPiece, "to", i,",", j )
                # un-remember the cliked-piece
                clickedPiece = None
            else:
            # if the clicked-piece does not exist
                # then do nothing
                continue
        
        
    win.getMouse()
    win.close()

main()


Aquarium


# aquarium.gif
# D. Thiebaut
# Displays 4 fish on the image, making them move randomly around the aquarium.
# 
from graphics import *
import random  # because the fish should move randomly, horizontally and vertically.

WIDTH  = 700 # geometry of tank2.gif
HEIGHT = 517

class Fish:
    """A class for the fish.   Build it so that it looks as much as possible the 
    other graphics objects in Zelle's library."""
    def __init__( self, fileNm, xx, yy ):
        self.fileName = fileNm
        self.x = xx
        self.y = yy
        self.image = Image( Point( xx, yy ), fileNm )
            
    def draw( self, win ):
        """draws the image on the graphic window."""
        self.image.draw( win )
        
    def moveRandom( self ):
        """move the fish to the left.  
        deltax = - random.randrange( 10 )
        deltay = random.randrange( -3, 3 )
        self.image.move( deltax, deltay )
        x = self.image.getAnchor().getX()
        if x < -50:
            self.image.move( WIDTH+100, 0 )
            
        
def main():
    # open the window
    win = GraphWin( "CSC Aquarium", WIDTH, HEIGHT )

    # display background
    background = Image( Point( WIDTH//2, HEIGHT//2 ), "tank2.gif" )
    background.draw( win )

    fishList = []
    for i in range( 4 ):
        fish = Fish( "fish0.gif", i*100, 350 )
        fish.draw( win )
        fishList.append( fish )

    # animation loop
    while True:

        # move all fish
        for fish in fishList:
            fish.moveRandom()

            

    win.getMouse()        
    win.close()
    
main()







Retrieved from "http://dominiquethiebaut.com/dftwiki3/index.php?title=CSC111_Programs_for_Week_10_2015&oldid=26139"