CSC111 Homework 11 Solution Program 2014
--D. Thiebaut (talk) 12:56, 29 April 2014 (EDT)
Source
#----------------------------------------------------------------------
# hw11b.py
# Julieanna Niu (bi)
# 4/24/2014
#
# Program containing seven classes: Rectangle, Polygon, Curves, Windows,
# Wheels, Cars, and oldCar. Descriptions of each class can be found
# below, along with methods associated with each class.
#
# This program uses the graphics library graphics.py to generate an
# image that contains alternatingrows of cars, with a message in a
# text box in the center of the image. The scheme, colors, car style,
# and message have all been predefined.
#----------------------------------------------------------------------
from graphics import GraphicsWindow
from random import seed
from random import randrange
from random import choice
# width and height of canvas
MAXWIDTH = 800
MAXHEIGHT = 600
# list of colors that will be available as car colors.
colors = ['RoyalBlue4','RoyalBlue1','dodger blue','light sky blue',
'deep sky blue','gold','light goldenrod','goldenrod4',
'goldenrod2', 'khaki1','red','tomato','salmon2', 'firebrick4',
'OrangeRed2']
#----------------------------------------------------------------------
# Rectangle: a class containing 5 private member variables:
# - x coordinate of the top left corner of the rectangle
# - y coordinate of the top left corner of the rectangle
# - width of the rectangle
# - height of the rectangle
# - color of the rectangle (can either be a list of 3 ints
# between 0 and 255, or a string of a color name recognized
# by TKinter)
# Methods supported:
# - draw(canvas): specifies color and draws rectangle onto the
# canvas.
#----------------------------------------------------------------------
class Rectangle:
def __init__( self, x, y, width, height, color ):
self._x = x
self._y = y
self._width = width
self._height = height
self._color = color
def draw( self, canvas ):
if isinstance(self._color, str): # if color is string
canvas.setFill(self._color)
else: # if color is 3 ints
canvas.setFill( self._color[0], self._color[1], self._color[2] )
canvas.drawRect( self._x, self._y, self._width, self._height )
#----------------------------------------------------------------------
# Polygon: a class containing 15 private member variables:
# - Seven pairs of x and y coordinates specifying the placement
# of the vertices of a seven-sided polygon shape.
# - color of the polygon (string of a color name recognized
# by TKinter)
# Methods supported:
# - draw(canvas): specifies color and draws polygon onto the
# canvas.
#----------------------------------------------------------------------
class Polygon:
def __init__( self, x1, y1, x2, y2, x3, y3, x4, y4, x5, y5, x6, y6, \
x7, y7, color ):
self._x1 = x1
self._y1 = y1
self._x2 = x2
self._y2 = y2
self._x3 = x3
self._y3 = y3
self._x4 = x4
self._y4 = y4
self._x5 = x5
self._y5 = y5
self._x6 = x6
self._y6 = y6
self._x7 = x7
self._y7 = y7
self._color = color
def draw( self, canvas ):
canvas.setLineWidth(3) # increases width of outline
canvas.setFill( self._color )
canvas.drawPolygon( self._x1, self._y1, self._x2, self._y2,\
self._x3, self._y3, self._x4, self._y4,\
self._x5, self._y5, self._x6, self._y6, \
self._x7, self._y7)
#----------------------------------------------------------------------
# Curves: a class containing 6 private member variables:
# - x and y coordinates of the top-left corner of the square that
# encloses the curve
# - the diameter of the circle that contains the curve
# - the angle at which the curve begins. Angles are taken with
# reference to the axis between the fourth and first quadrants.
# - angle of curve
# - color of the enclosed curve (string of a color name recognized
# by TKinter)
# Methods supported:
# - draw(canvas): specifies color and draws the curve onto the
# canvas. The 'curve' appears as a part of a circle (i.e.
# like a pie)
#----------------------------------------------------------------------
class Curves:
def __init__( self, x, y, diam, start, extent, color ):
self._x = x
self._y = y
self._diam = diam
self._extent = extent
self._start = start
self._color = color
def draw( self, canvas ):
canvas.setLineWidth(3)
canvas.setFill (self._color)
canvas.drawArc(self._x, self._y, self._diam, self._start, \
self._extent)
#----------------------------------------------------------------------
# Windows: a class containing 9 private member variables:
# - Four pairs of x and y coordinates specifying the placement
# of the vertices of a four-sided polygon shape.
# - color of the polygon (3 ints between 0 and 255)
# Methods supported:
# - draw(canvas): specifies color and draws the polygon on the
# canvas.
#----------------------------------------------------------------------
class Windows:
def __init__( self, x1, y1, x2, y2, x3, y3, x4, y4, color ):
self._x1 = x1
self._y1 = y1
self._x2 = x2
self._y2 = y2
self._x3 = x3
self._y3 = y3
self._x4 = x4
self._y4 = y4
self._color = color
def draw( self, canvas ):
canvas.setFill(self._color[0], self._color[1], self._color[2] )
canvas.drawPolygon( self._x1, self._y1, self._x2, self._y2,\
self._x3, self._y3, self._x4, self._y4)
#----------------------------------------------------------------------
# Wheels: a class containing 3 private member variables:
# - x and y coordinates of the center of the circle
# - the diameter of the circle
# Methods supported:
# - draw(canvas): draws a 'wheel' on the canvas, which consists
# of one larger circle with the specified diameter, and a
# smaller circle centrally superimposed on the large circle.
# Color is also specified (black for the large circle, grey
# for the small circle).
#----------------------------------------------------------------------
class Wheel:
def __init__( self, x, y, diam ):
self._x = x
self._y = y
self._diam = diam
def draw( self, canvas ):
canvas.setFill( 0, 0, 0 ) # sets color to black
# changes the x and y coordinates in order to use drawOval method
# on the canvas as specified by the graphics library. In drawOval,
# the x and y coordinates are the top-left corner of the rectangle
# that encloses the oval/circle.
canvas.drawOval( self._x-(self._diam//2), self._y-(self._diam//2),\
self._diam, self._diam)
canvas.setFill(200, 200, 200 ) # sets color to grey
canvas.drawOval( self._x-(self._diam//4), self._y-(self._diam//4), \
self._diam//2, self._diam//2)
#----------------------------------------------------------------------
# Car: a class containing 5 private member variables:
# - x and y coordinates of the top left corner of the rectangle
# that encloses the car
# - the width of the rectangle
# - the height of the rectangle
# - color of the body of the car (string of a color name recognized
# by TKinter)
#
# The body of this car is made up of one polygon. There is a light made
# of a rectangle, and windows made of a polygon. There are two wheels.
#
# Methods supported:
# - draw(canvas): draws all components of the car onto the canvas
#----------------------------------------------------------------------
class Car:
def __init__( self, x, y, width, height, color ):
# All components of the car have been initialized into their
# respective classes, with variables written with reference
# to the x and y coordinates of the top-left corner of the
# rectangle that encloses the car, as well as the width and
# height of the car.
self._bodypoly = Polygon(x, y+height, x, y+height//2, x+width//8,\
y, x+width//2, y, x+3*(width//4), y+height//2,\
x+width, y+height//2, x+width, y+height, color)
self._lights = Rectangle(x+width-width//16, y+height//2,
width//16, height//8, [125,125,125]) # white lights
self._windows= Windows( x+width//12,y+height//2, \
x+width//8+width//16, y+height//8, \
x+width//2-width//16, y+height//8, \
x+3*(width//4)-width//8, y+height//2, \
[200,200,200]) # grey windows
self._w1 = Wheel( x + 2*width//9, y+height, (width//9)*2)
self._w2 = Wheel( x + 5*width//7, y+height, (width//9)*2)
def draw( self, canvas ):
self._bodypoly.draw(canvas)
self._lights.draw(canvas)
self._windows.draw(canvas)
self._w1.draw(canvas)
self._w2.draw(canvas)
#----------------------------------------------------------------------
# oldCar: a class containing 5 private member variables:
# - x and y coordinates of the top left corner of a rectangle
# that encloses the car
# - the width of the rectangle
# - the height of the rectangle
# - color of the body of the car (string of a color name recognized
# by TKinter)
#
# The body of this car is made up of one rectangle, one semicircle (as the
# top of the car) and two quarter-circles (as the front and back of the car).
# There are two wheels.
#
# Methods supported:
# - draw(canvas): draws all components of the car onto the canvas
#----------------------------------------------------------------------
class oldCar:
def __init__(self, x, y, width, height, color):
self._body = Rectangle(x+width//4, y+height//2, 50, 25, color)
self._top = Curves( x+width//4, y, width//2, 0, 180, color)
self._left = Curves( x, y+height//2, 50, 90, 90, color)
self._right = Curves (x+width//2,y+height//2, 50,0, 90, color)
self._w1 = Wheel( x + 2*width//9, y+height, (width//9)*2)
self._w2 = Wheel( x + 5*width//7, y+height, (width//9)*2)
def draw (self, canvas):
self._body.draw(canvas)
self._top.draw(canvas)
self._left.draw(canvas)
self._right.draw(canvas)
self._w1.draw(canvas)
self._w2.draw(canvas)
#----------------------------------------------------------------------
# main(): The main function. Generates an image that has rows of cars
# of the same style, of a random color. The center of the image has a
# message within a rectangle ('Unhappy Easter') that hides the cars
# underneath it.
#----------------------------------------------------------------------
def main():
win = GraphicsWindow(MAXWIDTH, MAXHEIGHT)
canvas = win.canvas()
# for loop that draws the cars onto the canvas row by row, of
# alternating type
# for aesthetic purposes, the value for height should be between 1/3
# to 1/2 the value of the width.
width = 100 # width of rectangle that encloses car
height = 50 # height of rectangle that encloses car
y = 0
count = 1 # when count is odd, use Car class, else use oldCar
for y in range( 0, MAXHEIGHT, height+height//2):
x = 0
if count%2 != 0:
for x in range ( 0, MAXWIDTH, width+width//4):
c = Car( x, y, width, height, choice(colors))
c.draw( canvas )
count = count + 1
else:
for x in range ( 0, MAXWIDTH, width+width//4):
c = oldCar( x, y, width, height, choice(colors))
c.draw( canvas )
count = count + 1
y = y + height + 20
# creates textbox
textbox = Rectangle(200,250,400,100,'lemon chiffon')
textbox.draw(canvas)
# text and adjustments
canvas.setTextAnchor("center") # centers text
canvas.setTextFont( 'helvetica', 50, 'bold' )
canvas.drawText( MAXWIDTH//2, MAXHEIGHT//2, "Unhappy Easter" )
# background color of image
canvas.setBackground( 'peach puff' )
win.wait()
win.close()
# main entry point for the program
main()
Output
Program 2
This program uses inheritance to define the car classes.
# hw11b.py
# Thuy Nguyen (ce)
# This program prints out an example of a wrapping paper print
# where the theme is cars, the background color is light pink,
# and displays "Happy Easter" as the message. The uses two
# different types of cars where the program, generates rows of cars
# alternating between the two types of cars. The message is
# displayed in the middle of the wrapping paper inside a light
# blue rectangle.
#
# -------------------------------------------------------------------
from graphics import GraphicsWindow
from random import seed
from random import randrange
MAXWIDTH = 800
MAXHEIGHT = 600
class Circle:
# a class containing 4 private member variables:
# - center x position of circle (integer)
# - center y position of circle (integer)
# - diameter of circle (integer)
# - color of circle (list of 3 integers between 0 and 255)
# methods:
# draw( canvas ): the circle draws itself
# constructor: initializes a circle with all fields
def __init__( self, x, y, diameter, color ):
self._x = x
self._y = y
self._diameter= diameter
self._color = color
# draws a circle at defined (x,y) coordinates with specified color
def draw( self, canvas ):
canvas.setFill( self._color[0], self._color[1], self._color[2] )
canvas.drawOval( self._x-self._diameter//2,
self._y-self._diameter//2,
self._diameter,
self._diameter )
class Wheel:
# a class containing 3 private member variables:
# - center x position of wheel (integer)
# - center y position of wheel (integer)
# - diameter of wheel (integer)
# methods:
# draw( canvas ): the wheel draws itself
# constructor: initializes two wheels using Circle class
def __init__( self, x, y, diameter ):
self._c1 = Circle( x, y, diameter, ( 0,0,0 ) )
self._c2 = Circle( x, y, diameter/2, ( 200, 200, 200 ) )
# draws two wheels
def draw( self, canvas ):
self._c1.draw( canvas )
self._c2.draw( canvas )
class Car:
# a class containing 5 private member variables:
# - x position of car (integer)
# - y position of car (integer)
# - width of car (integer)
# - height of car (integer)
# - color of car (list of 3 integers between 0 and 255)
# methods:
# draw( canvas ): the car draws itself
# constructor: initializes a car with all fields
def __init__( self, x, y, width, height, color ):
self._x = x
self._y = y
self._width = width
self._height = height
self._color = color
# build the body
self._body = Rectangle( x, y, width, height, color )
# build the wheels
self._w1 = Wheel( x + width//4, y + height, width//5 )
self._w2 = Wheel( x + 3*width//4, y + height, width//5 )
# draws a car with its body and wheels
def draw( self, canvas ):
self._body.draw( canvas )
self._w1.draw( canvas )
self._w2.draw( canvas )
class CarTop( Car ):
# a class inherited from Car class with one additional private member variable
# - the top hood of a car
# methods:
# draw( canvas ): the car with top draws itself
def __init__( self, x, y, width, height, color, topColor ):
super().__init__( x, y, width, height, color )
self._top = Rectangle( x+width//4, y-height//2, width//2, height//2, topColor )
# draws a car with a top hood
def draw( self, canvas ):
super().draw( canvas )
self._top.draw( canvas )
class CarTop2( Car ):
# a class inherited from Car class with two additional private member variables
# - the top hood of a car
# - the window of a car
# methods:
# draw( canvas ): the car with top and window draws itself
def __init__( self, x, y, width, height, color, topColor ):
super().__init__( x, y, width, height, color )
self._top = Rectangle( x+width//2, y-height//2, width//2, height//2, topColor )
self._window = Rectangle( x+width//3, y+height//4, width//3, height//3, ( 0,0,0 ) )
# draws a car with a top hood and window
def draw( self, canvas ):
super().draw( canvas )
self._top.draw( canvas )
self._window.draw( canvas )
class Rectangle:
# a class containing 5 private member variables
# - x position of rectangle (integer)
# - y position of rectanle (integer)
# - width of rectangle (integer)
# - height of rectangle (integer)
# - color of rectangle (list of 3 integers between 0 and 255)
# methods:
# draw( canvas ): the rectangle draws itself
# constructor: initializes rectangle with all fields
def __init__( self, x, y, width, height, color ):
self._x = x
self._y = y
self._width = width
self._height = height
self._color = color
# draws a rectangle
def draw( self, canvas ):
canvas.setFill( self._color[0], self._color[1], self._color[2] )
canvas.drawRectangle( self._x, self._y, self._width, self._height )
# --------------------------------------------------------------------------------
# setRandomColor(): sets a random color to a car's body and hood
# --------------------------------------------------------------------------------
def setRandomColor():
r = randrange( 255 )
g = randrange( 255 )
b = randrange( 255 )
return r, g, b
# --------------------------------------------------------------------------------
# multipleCars( canvas ): displays the cars such that they are organized into
# rows, one above the other, and alternating each type of car in separate rows
# --------------------------------------------------------------------------------
def multipleCars( canvas ):
width = 100
height = 25
for x in range( 0, MAXWIDTH, 11*width//10 ):
for y in range( 0, MAXHEIGHT, 4*height ):
color = setRandomColor()
topColor = setRandomColor()
c = CarTop( x, y, width, height, color, topColor )
c.draw( canvas )
for y in range( 2*height, MAXHEIGHT, 4*height ):
color = setRandomColor()
topColor = setRandomColor()
c2 = CarTop2( x, y, width, height, color, topColor )
c2.draw( canvas )
# ================================================
# Main Program
# ================================================
def main():
seed()
win = GraphicsWindow(MAXWIDTH, MAXHEIGHT)
canvas = win.canvas()
multipleCars( canvas )
canvas.setBackground( 'thistle1' )
canvas.setFill( 'azure' )
canvas.drawRectangle( MAXWIDTH // 3, 2*MAXHEIGHT // 5, 325, 60 )
canvas.setTextFont( "times", 40, "bold" )
canvas.drawText( MAXWIDTH // 3, 2*MAXHEIGHT // 5, "Happy Easter" )
win.wait()
win.close()
main()
