def run_test_draw_lines_from_rectangles(): """ Tests the draw_lines_from_rectangles function. """ print() print('--------------------------------------------------') print('Testing the draw_lines_from_rectangles function:') print(' See the graphics windows that pop up.') print('--------------------------------------------------') # TWO tests on ONE window. title = 'Tests 1 & 2 of DRAW_LINES_FROM_RECTANGLES:' title += ' 5 lines, 8 lines!' window1 = rg.RoseWindow(900, 400, title) rectangle1 = rg.Rectangle(rg.Point(100, 25), rg.Point(150, 125)) rectangle2 = rg.Rectangle(rg.Point(300, 150), rg.Point(400, 175)) rectangle1.outline_color = 'red' rectangle2.outline_color = 'blue' draw_lines_from_rectangles(rectangle1, rectangle2, 5, window1) rectangle1 = rg.Rectangle(rg.Point(870, 30), rg.Point(750, 100)) rectangle2 = rg.Rectangle(rg.Point(700, 90), rg.Point(650, 60)) rectangle2.outline_color = 'green' draw_lines_from_rectangles(rectangle1, rectangle2, 8, window1) window1.close_on_mouse_click() # A third test on ANOTHER window. title = 'Test 3 of DRAW_LINES_FROM_RECTANGLES: 11 lines!' window2 = rg.RoseWindow(700, 700, title) rectangle1 = rg.Rectangle(rg.Point(550, 200), rg.Point(650, 100)) rectangle2 = rg.Rectangle(rg.Point(600, 50), rg.Point(650, 75)) rectangle1.outline_color = 'brown' rectangle2.outline_color = 'cyan' rectangle2.outline_thickness = 10 draw_lines_from_rectangles(rectangle1, rectangle2, 11, window2) window2.close_on_mouse_click()
def run_test_draw_lines_from_rectangles(): """ Tests the draw_lines_from_rectangles function. """ print() print('--------------------------------------------------') print('Testing the draw_lines_from_rectangles function:') print(' See the graphics windows that pop up.') print('--------------------------------------------------') # TWO tests on ONE window. title = 'Tests 1 & 2 of DRAW_LINES_FROM_RECTANGLES:' title += ' 10 lines, 14 lines.' window1 = rg.RoseWindow(1000, 1000, title) rectangle1 = rg.Rectangle(rg.Point(575, 550), rg.Point(425, 450)) rectangle2 = rg.Rectangle(rg.Point(445, 400), rg.Point(450, 300)) rectangle1.outline_color = 'red' rectangle2.outline_color = 'blue' draw_lines_from_rectangles(rectangle1, rectangle2, 10, window1) rectangle1 = rg.Rectangle(rg.Point(140, 100), rg.Point(600, 200)) rectangle2 = rg.Rectangle(rg.Point(100, 140), rg.Point(625, 35)) rectangle2.outline_color = 'green' draw_lines_from_rectangles(rectangle1, rectangle2, 14, window1) window1.close_on_mouse_click() # A third test on ANOTHER window. title = 'Test 3 of DRAW_LINES_FROM_RECTANGLES: 14 lines.' window2 = rg.RoseWindow(700, 700, title) rectangle1 = rg.Rectangle(rg.Point(550, 200), rg.Point(650, 100)) rectangle2 = rg.Rectangle(rg.Point(600, 50), rg.Point(650, 75)) rectangle1.outline_color = 'blue' rectangle2.outline_color = 'green' rectangle2.outline_thickness = 10 draw_lines_from_rectangles(rectangle1, rectangle2, 14, window2) window2.close_on_mouse_click()
def __init__(self, intersection_center, width, height, letter_thickness): """ *** See dimensions.pdf to understand the following! *** What comes in: -- self -- an rg.Point for the intersection center of the CapitalT -- This point is also center of the horizontal rectangle. -- a int for the width of the CapitalT (that is, the width of the horizontal rectangle) -- a int for the height of the CapitalT (that is, the height of the vertical rectangle) -- a int for the CapitalT's thickness, that is, the height of the horizontal rectangle and also the width of the vertical rectangle. What goes out: Nothing (i.e., None). Side effects: Sets two instance variables named: -- h_rect (to represent the horizontal rectangle in the T, that is, the top bar) -- v_rect (to represent the vertical rectangle in the T, that is, the | part of the T) *** See dimensions.pdf to understand the above! *** Each rectangle is an rg.Rectangle. IMPORTANT RESTRICTION: Unlike prior modules you are NOT allowed to make any other instance variables than h_rect and v_rect. You must figure out how to do the problem with ONLY those two instance variables. Example: t1 = CapitalT(rg.Point(300, 50), 100, 200, 20) -- t1.h_rect would have an upper left corner of (250, 40) -- t1.h_rect would have an lower right corner of (350, 60) -- t1.v_rect would have an upper left corner of (290, 40) -- t1.v_rect would have an lower right corner of (310, 240) *** Make sure that you understand this example before *** *** proceeding. See dimensions.pdf to understand it! *** Type hints: :type intersection_center: rg.Point :type width: int :type height: int :type letter_thickness: int """ # --------------------------------------------------------------------- # DONE: 3. # READ the above specification, including the Example. # Implement this method, using the instance variables # h_rect # v_rect # and *** NO OTHER INSTANCE VARIABLES. *** # Note: Implement attach_to before testing this __init__ method. # --------------------------------------------------------------------- self.h_rect = rg.Rectangle( rg.Point(intersection_center.x - width / 2, intersection_center.y + letter_thickness / 2), rg.Point(intersection_center.x + width / 2, intersection_center.y - letter_thickness / 2)) self.v_rect = rg.Rectangle( rg.Point(intersection_center.x - letter_thickness / 2, intersection_center.y - letter_thickness / 2), rg.Point(intersection_center.x + letter_thickness / 2, intersection_center.y + (height - letter_thickness / 2)))
def __init__(self, intersection_center, width, height, letter_thickness): """ What comes in: -- self -- an rg.Point for the intersection center of the CapitalT -- This point is also center of the horizontal rectangle. -- a int for the width of the CapitalT (the width of the horizontal rectangle) -- a int for the height of the CapitalT (the height of the vertical rectangle) -- a int for the thickness of each rectangle (the letter's thickness) What goes out: Nothing (i.e., None). Side effects: Sets two instance variables named: -- h_rect (to represent the horizontal rectangle in the T, the top bar) -- v_rect (to represent the vertical rectangle in the T, the | part of the T) *** See the dimensions PDF for the exact placement of the rectangles in the T. *** Each rectangle is an rg.Rectangle. Unlike prior modules you are NOT allowed to make any other instance variables. You may only use exactly these two and must figure out how to do the problem with ONLY those two instance variables. Example: t1 = CapitalT(rg.Point(300, 50), 100, 200, 20) -- t1.h_rect would have an upper left corner of (250, 40) -- t1.h_rect would have an lower right corner of (350, 60) -- t1.v_rect would have an upper left corner of (290, 40) -- t1.v_rect would have an lower right corner of (310, 240) Type hints: :type intersection_center: rg.Point :type width: int :type height: int :type letter_thickness: int """ # -------------------------------------------------------------- # Done: 3. # READ the above specification, including the Example. # Implement this method # Note: you will need to also implement attach_to before testing # -------------------------------------------------------------- self.intersection_center = intersection_center self.width = width self.height = height self.letter_thickness = letter_thickness h_rect_point_start = (rg.Point( self.intersection_center.x - (self.width / 2), self.intersection_center.y - self.letter_thickness / 2)) h_rect_point_end = (rg.Point( self.intersection_center.x + (self.width / 2), self.intersection_center.y + self.letter_thickness / 2)) h_rect = rg.Rectangle(h_rect_point_start, h_rect_point_end) v_rect_point_start = (rg.Point( self.intersection_center.x - (self.letter_thickness / 2), self.intersection_center.y - self.letter_thickness / 2)) v_rect_point_end = (rg.Point( self.intersection_center.x + (self.letter_thickness / 2), self.intersection_center.y + (self.height - self.letter_thickness / 2))) v_rect = rg.Rectangle(v_rect_point_start, v_rect_point_end) self.h_rect = h_rect self.v_rect = v_rect
def many_hourglasses(window, square, m, colors): """ See many_hourglasses_picture.pdf in this project for pictures that may help you better understand the following specification: Displays m rectangles, where: -- Each rectangle has an hourglass of circles inside it, per the hourglass function above. -- The circles in the hourglasses are all the same size. -- The leftmost rectangle is the given square, and it contains an hourglass with a single circle that fills the square. -- Each successive rectangle is immediately to the right of the previous rectangle, and each contains an hourglass with the hourglass' n being one greater than the n used for the previous rectangle. -- The colors for the hourglass figures use the given sequence of colors, "wrapping" if m exceeds the length of the sequence. Preconditions: :type window: rg.RoseWindow :type square: rg.Square :type m: int :type colors: (list | tuple) of str where m is positive and colors is a sequence of strings, each of which denotes a color that rosegraphics understands. """ # ------------------------------------------------------------------ # TODO: 3. Implement and test this function. # We provided some tests for you (above). # ------------------------------------------------------------------ #################################################################### # IMPORTANT: # 1. Partial credit if you draw JUST the rectangles. # 2. No additional credit unless you CALL the hourglass function # in the PREVIOUS problem appropriately # to draw the hourglass figures. #################################################################### # ------------------------------------------------------------------ # DIFFICULTY AND TIME RATINGS (see top of this file for explanation) # DIFFICULTY: 7 (assuming that you already have # a correct "hourglass" function above) # TIME ESTIMATE: 20 minutes (warning: this problem is challenging) # ------------------------------------------------------------------ center = square.center centerx = square.center.x centery = square.center.y length = square.length_of_each_side original_length = length ul = rg.Point(square.center.x - (original_length / 2), square.center.y - (original_length / 2)) original_ul = ul lr = rg.Point(square.center.x + (original_length / 2), square.center.y + (original_length / 2)) original_lr = lr ulx = ul.x original_ulx = ulx uly = ul.y original_uly = uly lrx = lr.x original_lrx = lrx lry = lr.y original_lry = lry index = 0 for k in range(m): rect = rg.Rectangle(rg.Point(ulx, uly), rg.Point(lrx, lry)) rect.attach_to(window) hourglass(window, k + 1, rect.get_center(), length / 2, colors[index]) window.render() index = index + 1 if index == len(colors): index = 0 ulx = ulx + (k + 1) * length uly = uly - (length) * (1 / 1.15) lrx = lrx + ((1 + (k + 1)) * length) lry = lry + length * (1 / 1.15)
def circle_and_rectangle(): """ -- Constructs an rg.RoseWindow. -- Constructs and draws a rg.Circle and rg.Rectangle on the window such that: -- They fit in the window and are easily visible. -- The rg.Circle is filled with 'blue' -- Prints (on the console, on SEPARATE lines) the following data associated with your rg.Circle: -- Its outline thickness. -- Its fill color. -- Its center. -- Its center's x coordinate. -- Its center's y coordinate. -- Prints (on the console, on SEPARATE lines) the same data but for your rg.Rectangle. -- Waits for the user to press the mouse, then closes the window. Here is an example of the output on the console, for one particular circle and rectangle: 1 blue Point(180.0, 115.0) 180 115 1 None Point(75.0, 150.0) 75.0 150.0 """ window = rg.RoseWindow(500, 500) cp1 = rg.Point(400, 400) circle1 = rg.Circle(cp1, 30) circle1.fill_color = 'blue' circle1.attach_to(window) p1 = rg.Point(50, 50) p2 = rg.Point(200, 200) rect = rg.Rectangle(p1, p2) rect.attach_to(window) window.render() cthickness = circle1.outline_thickness ccolor = circle1.fill_color ccenter = circle1.center cxcoor = ccenter.x cycoor = ccenter.y print(cthickness) print(ccolor) print(ccenter) print(cxcoor) print(cycoor) rthickness = rect.outline_thickness rcolor = rect.fill_color rcenter = rect.get_center() rxcoor = rcenter.x rycoor = rcenter.y print(rthickness) print(rcolor) print(rcenter) print(rxcoor) print(rycoor) window.close_on_mouse_click()
def draw_squares_from_circle(n, circle, window): """ What comes in: Three arguments: -- A positive integer n. -- An rg.Circle. -- An rg.RoseWindow. What goes out: Nothing (i.e., None). Side effects: See draw_squares_from_circle.pdf in this project for pictures that may help you better understand the following specification: First draws the given rg.Circle on the given rg.RoseWindow. Then draws n rg.Squares on the given rg.RoseWindow, such that: -- The first rg.Square circumscribes the given rg.Circle. -- Each subsequent rg.Square has its upper-left quarter on top of the lower-right quarter of the previous rg.Square, so that the squares form an overlapping sequence that goes down and to the right. Must ** render ** but ** NOT close ** the window. Type hints: :type n: int :type circle: rg.Circle :type window: rg.RoseWindow """ # ------------------------------------------------------------------ # done: 2. Implement and test this function. # Tests have been written for you (above). # # C ONSIDER using the ACCUMULATOR IN GRAPHICS pattern, # as in draw_row_of_circles in m1e, # instead of directly using the loop variable. # #################################################################### # HINT: To figure out the code that computes the necessary # positions of each square, # ** FIRST DO A CONCRETE EXAMPLE BY HAND! ** #################################################################### # ------------------------------------------------------------------ center = circle.center fill_color = circle.fill_color x = center.x y = center.y radius = circle.radius circle = rg.Circle(center, radius) circle.fill_color = fill_color # Attach the object(s) to the window. circle.attach_to(window) for k in range(n): # ------------------------------------------------------------------ # Rectangle: needs two opposite corners. # ------------------------------------------------------------------ point1 = rg.Point(x - radius, y - radius) point2 = rg.Point(x + radius, y + radius) rectangle = rg.Rectangle(point1, point2) rectangle.attach_to(window) x = x + radius y = y + radius # ------------------------------------------------------------------ # render: Draw ALL the objects attached to this window. # ------------------------------------------------------------------ window.render()
def draw_circles_from_rectangle(m, n, rectangle, window): """ What comes in: Four arguments: -- Positive integers m and n. -- An rg.Rectangle. -- An rg.RoseWindow. What goes out: Nothing (i.e., None). Side effects: See draw_circles_from_rectangle.pdf in this project for pictures that may help you better understand the following specification: First draws the given rg.Rectangle on the given rg.RoseWindow. Then draws m rg.Circles on the given rg.RoseWindow, such that: -- The diameter of each rg.Circle is the same as the height of the given rg.Rectangle. -- The first rg.Circle is immediately to the left of the given rg.Rectangle -- Each subsequent rg.Circle is immediately to the left of the previous rg.Circle, so that the circles form a row that goes to the left. -- Each rg. Circle has the same fill_color as the given rg.Rectangle (and has no outline_color). Then draws n rg.Circles on the given RoseWindow, such that: -- The diameter of each rg.Circle is the same as the width of the given rg.Rectangle. -- The first rg.Circle is immediately above the given rg.Rectangle -- Each subsequent rg.Circle is immediately above the previous rg.Circle, so that the circles form a column that goes up. -- Each rg.Circle has the same outline_color as the given rg.Rectangle (and has no fill_color). Must ** render ** but ** NOT close ** the window. Type hints: :type m: int :type n: int :type rectangle: rg.Rectangle :type window: rg.RoseWindow """ # ------------------------------------------------------------------ # done: 4. Implement and test this function. # Tests have been written for you (above). # # C ONSIDER using the ACCUMULATOR IN GRAPHICS pattern, # as in draw_row_of_circles in m1e, # instead of directly using the loop variable. # #################################################################### # HINT: To figure out the code that computes the necessary # positions of each circle, # ** FIRST DO A CONCRETE EXAMPLE BY HAND! ** #################################################################### # ------------------------------------------------------------------ point1 = rectangle._upper_left_corner point2 = rectangle._lower_right_corner fill_color = rectangle.fill_color outline = rectangle.outline_color thick = rectangle.outline_thickness rectangle = rg.Rectangle(point1, point2) rectangle.fill_color = fill_color rectangle.outline_color = outline rectangle.outline_thickness = thick rectangle.attach_to(window) # Horizontal Circles radius = (point2.y - point1.y) / 2 x = point1.x - radius for k in range(m): y = (point1.y + point2.y) / 2 center = rg.Point(x, y) circle = rg.Circle(center, radius) circle.fill_color = fill_color circle.attach_to(window) x = x - 2 * radius # Vertical Circles radius = (point2.x - point1.x) / 2 y = point1.y - radius for k in range(n): x = (point1.x + point2.x) / 2 center = rg.Point(x, y) circle = rg.Circle(center, radius) circle.outline_color = outline circle.attach_to(window) y = y - 2 * radius # ------------------------------------------------------------------ # render: Draw ALL the objects attached to this window. # ------------------------------------------------------------------ window.render()
def circle_and_rectangle(): """ -- Constructs an rg.RoseWindow. -- Constructs and draws a rg.Circle and rg.Rectangle on the window such that: -- They fit in the window and are easily visible. -- The rg.Circle is filled with 'blue' -- Prints (on the console, on SEPARATE lines) the following data associated with your rg.Circle: -- Its outline thickness. -- Its fill color. -- Its center. -- Its center's x coordinate. -- Its center's y coordinate. -- Prints (on the console, on SEPARATE lines) the same data but for your rg.Rectangle. -- Waits for the user to press the mouse, then closes the window. Here is an example of the output on the console, for one particular circle and rectangle: 1 blue Point(180.0, 115.0) 180 115 1 None Point(75.0, 150.0) 75.0 150.0 """ # ------------------------------------------------------------------------- # DONE: 3. Implement this function, per its green doc-string above. # -- ANY objects that meet the criteria are fine. # Put a statement in main to test this function # (by calling this function). # # IMPORTANT: Use the DOT TRICK to guess the names of the relevant # instance variables for outline thickness, etc. # ------------------------------------------------------------------------- window = rg.RoseWindow(400, 400) circle = rg.Circle(rg.Point(50, 50), 10) color = 'red' circle.fill_color = color print('circle color :', color) thick = 5 circle.outline_thickness = thick print('thickness:', thick) x_coor = 50 y_coor = 50 print('center point :', x_coor, ',', y_coor) circle.center = rg.Point(x_coor, y_coor) print("x coorinate of circle :", x_coor) print('y coordinate of circle :', y_coor) circle.attach_to(window) print(' ') rec = rg.Rectangle(rg.Point(100, 100), rg.Point(200, 20)) color2 = 'blue' rec.fill_color = color2 print('rectangle color:', color2) thick_rec = 10 rec.outline_thickness = thick_rec print('thickness of rec', thick_rec) x = 100 + (50 / 2) y = 20 + (80 / 2) print('center point rec', x, ',', y) print('x coor. center of rec:', x) print('y coor. center of rec :', y) rec.attach_to(window) window.render() window.close_on_mouse_click()
def circle_and_rectangle(): """ -- Constructs an rg.RoseWindow. -- Constructs and draws a rg.Circle and rg.Rectangle on the window such that: -- They fit in the window and are easily visible. -- The rg.Circle is filled with 'blue' -- Prints (on the console, on SEPARATE lines) the following data associated with your rg.Circle: -- Its outline thickness. -- Its fill color. -- Its center. -- Its center's x coordinate. -- Its center's y coordinate. -- Prints (on the console, on SEPARATE lines) the same data but for your rg.Rectangle. -- Waits for the user to press the mouse, then closes the window. Here is an example of the output on the console, for one particular circle and rectangle: 1 blue Point(180.0, 115.0) 180 115 1 None Point(75.0, 150.0) 75.0 150.0 """ # ------------------------------------------------------------------------- # Done: 3. Implement this function, per its green doc-string above. # -- ANY objects that meet the criteria are fine. # Put a statement in main to test this function # (by calling this function). # # IMPORTANT: Use the DOT TRICK to guess the names of the relevant # instance variables for outline thickness, etc. # ------------------------------------------------------------------------- window = rg.RoseWindow(400, 400) circlecenter = rg.Point(100,100) circleradius = 10 circle = rg.Circle(circlecenter, circleradius) circle.fill_color = "blue" circle.attach_to(window) print(1) print("blue") print(circlecenter) print(100) print(100) rectanglebotleft = rg.Point(350, 200) rectangletopright = rg.Point(375, 150) rectangle = rg.Rectangle(rectanglebotleft,rectangletopright) rectangle.attach_to(window) print(1) print("None") print("Point(363.0, 175.0)") print(363) print(175) window.render() window.close_on_mouse_click()
def circle_and_rectangle(): """ -- Constructs an rg.RoseWindow. -- Constructs and draws a rg.Circle and rg.Rectangle on the window such that: -- They fit in the window and are easily visible. -- The rg.Circle is filled with 'blue' -- Prints (on the console, on SEPARATE lines) the following data associated with your rg.Circle: -- Its outline thickness. -- Its fill color. -- Its center. -- Its center's x coordinate. -- Its center's y coordinate. -- Prints (on the console, on SEPARATE lines) the same data but for your rg.Rectangle. -- Waits for the user to press the mouse, then closes the window. Here is an example of the output on the console, for one particular circle and rectangle: 1 blue Point(180.0, 115.0) 180 115 1 None Point(75.0, 150.0) 75.0 150.0 """ window = rg.RoseWindow() # Sets circle Instance Variables center = rg.Point(180, 115) radius1 = 20 # Sets rectangle Instance Variables corner1 = rg.Point(70, 50) corner2 = rg.Point(300, 200) # Constructs and attaches both objects to window # Fills circle circle = rg.Circle(center, radius1) circle.fill_color = 'blue' circle.attach_to(window) rectangle = rg.Rectangle(corner1, corner2) rectangle.attach_to(window) # prints circle information print(circle.outline_thickness) print(circle.fill_color) print(circle.center) print(circle.center.x) # X coordinate print(circle.center.y) # Y coordinate # prints rectangle information print(rectangle.outline_thickness) print(rectangle.fill_color) print(rectangle.get_center()) print(rectangle.get_center().x) # X coordinate print(rectangle.get_center().y) # Y coordinate window.render() window.close_on_mouse_click()
def circle_and_rectangle(): """ -- Constructs an rg.RoseWindow. -- Constructs and draws a rg.Circle and rg.Rectangle on the window such that: -- They fit in the window and are easily visible. -- The rg.Circle is filled with 'blue' -- Prints (on the console, on SEPARATE lines) the following data associated with your rg.Circle: -- Its outline thickness. -- Its fill color. -- Its center. -- Its center's x coordinate. -- Its center's y coordinate. -- Prints (on the console, on SEPARATE lines) the same data but for your rg.Rectangle. -- Waits for the user to press the mouse, then closes the window. Here is an example of the output on the console, for one particular circle and rectangle: 1 blue Point(180.0, 115.0) 180 115 1 None Point(75.0, 150.0) 75.0 150.0 """ # ------------------------------------------------------------------------- # DONE: 3. Implement this function, per its green doc-string above. # -- ANY objects that meet the criteria are fine. # Put a statement in main to test this function # (by calling this function). # # IMPORTANT: Use the DOT TRICK to guess the names of the relevant # instance variables for outline thickness, etc. # ------------------------------------------------------------------------- window2 = rg.RoseWindow() gordan = rg.Circle(rg.Point(145, 79), 5) gordan.fill_color = 'blue' gordan.attach_to(window2) garfield = rg.Rectangle(rg.Point(132, 45), rg.Point(76, 184)) garfield.attach_to(window2) window2.render() window2.close_on_mouse_click() print('The thickness of the circle is:', gordan.outline_thickness) print('The fill color is', gordan.outline_color) print('The Point is', gordan.center) print('X coordinate is', gordan.center.x) print('Y coordinate is', gordan.center.y) print('The thickness of the square is', garfield.outline_thickness) print('The fill color is', garfield.fill_color) print('The Point is', garfield.corner_1) print('X coordinate', garfield.corner_1.x) print('Y coordinate', garfield.corner_2.y)
def circle_and_rectangle(x, y, r, a, b, c, d): """ -- Constructs an rg.RoseWindow. -- Constructs and draws a rg.Circle and rg.Rectangle on the window such that: -- They fit in the window and are easily visible. -- The rg.Circle is filled with 'blue' -- Prints (on the console, on SEPARATE lines) the following data associated with your rg.Circle: -- Its outline thickness. -- Its fill color. -- Its center. -- Its center's x coordinate. -- Its center's y coordinate. -- Prints (on the console, on SEPARATE lines) the same data but for your rg.Rectangle. -- Waits for the user to press the mouse, then closes the window. Here is an example of the output on the console, for one particular circle and rectangle: 1 blue Point(180.0, 115.0) 180 115 1 None Point(75.0, 150.0) 75.0 150.0 """ # ------------------------------------------------------------------------- # DONE: 3. Implement this function, per its green doc-string above. # -- ANY objects that meet the criteria are fine. # Put a statement in main to test this function # (by calling this function). # # IMPORTANT: Use the DOT TRICK to guess the names of the relevant # instance variables for outline thickness, etc. # ------------------------------------------------------------------------- window = rg.RoseWindow() p = rg.Point(x, y) circle = rg.Circle(p, r) circle.attach_to(window) circle.fill_color = 'pink' circle.outline_thickness = 4 print(circle.outline_thickness) print(circle.fill_color) print(p) print(x) print(y) e = rg.Point(a, b) f = rg.Point(c, d) rec = rg.Rectangle(e, f) rec.outline_thickness = 5 rec.attach_to(window) print(rec.outline_thickness) print(rec.fill_color) print(e) print(c - a) print(b - d) window.render() window.close_on_mouse_click()
def many_hourglasses(window, square, m, colors): """ See many_hourglasses_picture.pdf in this project for pictures that may help you better understand the following specification: Displays m rectangles, where: -- Each rectangle has an hourglass of circles inside it, per the hourglass function above. -- The circles in the hourglasses are all the same size. -- The leftmost rectangle is the given square, and it contains an hourglass with a single circle that fills the square. -- Each successive rectangle is immediately to the right of the previous rectangle, and each contains an hourglass with the hourglass' n being one greater than the n used for the previous rectangle. -- The colors for the hourglass figures use the given sequence of colors, "wrapping" if m exceeds the length of the sequence. Preconditions: :type window: rg.RoseWindow :type square: rg.Square :type m: int :type colors: (list | tuple) of str where m is positive and colors is a sequence of strings, each of which denotes a color that rosegraphics understands. """ # ------------------------------------------------------------------------- # DONE: 3. Implement and test this function. # We provided some tests for you (above). # ------------------------------------------------------------------------- ########################################################################### # IMPORTANT: # 1. Partial credit if you draw JUST the rectangles. # 2. No additional credit unless you CALL the hourglass function # in the PREVIOUS problem appropriately # to draw the hourglass figures. ########################################################################### # ------------------------------------------------------------------------- # DIFFICULTY AND TIME RATINGS (see top of this file for explanation) # DIFFICULTY: 7 (assuming that you already have # a correct "hourglass" function above) # TIME ESTIMATE: 20 minutes (warning: this problem is challenging) # ------------------------------------------------------------------------- #square.attach_to(window) radius = square.length_of_each_side / 2 x = square.center.x y = square.center.y count = 0 for k in range(m): if k % len(colors) == 0: count = count + 1 newk = k - len(colors) * count + len(colors) #print(len(colors),k,newk) blc = rg.Point(x - radius * (k + 1), y + radius * (math.sqrt(3) * k + 1)) trc = rg.Point(x + radius * (k + 1), y - radius * (math.sqrt(3) * k + 1)) rectangle = rg.Rectangle(blc, trc) rectangle.attach_to(window) hourglass(window, k + 1, rg.Point(x, square.center.y), radius, colors[newk]) x = x + radius * (k + 1) + radius * (k + 2)
def many_hourglasses(window, square, m, colors): """ See many_hourglasses_picture.pdf in this project for pictures that may help you better understand the following specification: Displays m rectangles, where: -- Each rectangle has an hourglass of circles inside it, per the hourglass function above. -- The circles in the hourglasses are all the same size. -- The leftmost rectangle is the given square, and it contains an hourglass with a single circle that fills the square. -- Each successive rectangle is immediately to the right of the previous rectangle, and each contains an hourglass with the hourglass' n being one greater than the n used for the previous rectangle. -- The colors for the hourglass figures use the given sequence of colors, "wrapping" if m exceeds the length of the sequence. Preconditions: :type window: rg.RoseWindow :type square: rg.Square :type m: int :type colors: (list | tuple) of str where m is positive and colors is a sequence of strings, each of which denotes a color that rosegraphics understands. """ # ------------------------------------------------------------------ # DONE: 3. Implement and test this function. # We provided some tests for you (above). # ------------------------------------------------------------------ #################################################################### # IMPORTANT: # 1. Partial credit if you draw JUST the rectangles. # 2. No additional credit unless you CALL the hourglass function # in the PREVIOUS problem appropriately # to draw the hourglass figures. #################################################################### # ------------------------------------------------------------------ # DIFFICULTY AND TIME RATINGS (see top of this file for explanation) # DIFFICULTY: 7 (assuming that you already have # a correct "hourglass" function above) # TIME ESTIMATE: 20 minutes (warning: this problem is challenging) # ------------------------------------------------------------------ radius = square.length_of_each_side / 2 wrap = 0 center = square.center upper_left = rg.Point(center.x - radius, center.y - radius) lower_right = rg.Point(center.x + radius, center.y + radius) for k in range(m): if k < len(colors): hourglass(window, k + 1, center, radius, colors[k]) else: if wrap < len(colors): hourglass(window, k + 1, center, radius, colors[wrap]) wrap = wrap + 1 else: wrap = 0 hourglass(window, k + 1, center, radius, colors[wrap]) wrap = wrap + 1 rectangle = rg.Rectangle(upper_left, lower_right) rectangle.attach_to(window) window.render() center.x = center.x + radius + ((k + 1) * 4 * radius * math.sin(0.524)) upper_left.x = upper_left.x + (2 * radius * (k + 1)) lower_right.x = lower_right.x + (2 * radius) + ( (k + 1) * 4 * radius * math.sin(0.524)) upper_left.y = upper_left.y - (2 * radius * math.cos(0.524)) lower_right.y = lower_right.y + (2 * radius * math.cos(0.524))
def circle_and_rectangle(): """ -- Constructs an rg.RoseWindow. -- Constructs and draws a rg.Circle and rg.Rectangle on the window such that: -- They fit in the window and are easily visible. -- The rg.Circle is filled with 'blue' -- Prints (on the console, on SEPARATE lines) the following data associated with your rg.Circle: -- Its outline thickness. -- Its fill color. -- Its center. -- Its center's x coordinate. -- Its center's y coordinate. -- Prints (on the console, on SEPARATE lines) the same data but for your rg.Rectangle. -- Waits for the user to press the mouse, then closes the window. Here is an example of the output on the console, for one particular circle and rectangle: 1 blue Point(180.0, 115.0) 180 115 1 None Point(75.0, 150.0) 75.0 150.0 """ window = rg.RoseWindow(800, 600) x1 = 200 y1 = 200 centerpoint1 = rg.Point(x1, y1) radius = 100 x2 = 300 y2 = 300 x3 = 500 y3 = 400 cornerpoint1 = rg.Point(x2, y2) cornerpoint2 = rg.Point(x3, y3) centerpoint2 = rg.Point(x3 - x2, y3 - y2) circle = rg.Circle(centerpoint1, radius) circle.fill_color = 'blue' rectangle = rg.Rectangle(cornerpoint1, cornerpoint2) circle.attach_to(window) rectangle.attach_to(window) print(circle.outline_thickness) print(circle.fill_color) print(centerpoint1) print(x1) print(y1) print(rectangle.outline_thickness) print(centerpoint2) print(x3 - x2) print(y3 - y2) window.render() window.close_on_mouse_click()
def run_test_draw_circles_from_rectangle(): """ Tests the draw_circles_from_rectangle function. """ print() print('--------------------------------------------------') print('Testing the draw_circles_from_rectangle function:') print(' See the graphics windows that pop up.') print('--------------------------------------------------') # ------------------------------------------------------------------ # done: 3. Implement this TEST function. # It TESTS the draw_circles_from_rectangle function # defined below. Include at least ** 3 ** tests, of which # *** at least TWO tests are on ONE window and # *** at least ONE test is on a DIFFERENT window. # #################################################################### # HINT: C onsider using the same test cases as suggested by the # pictures in draw_circles_from_rectangle.pdf in this project. # Follow the same form as the example in a previous problem. #################################################################### # ------------------------------------------------------------------ # ------------------------------------------------------------------ # TWO tests on ONE window. # ------------------------------------------------------------------ window1 = rg.RoseWindow(720, 500) # Test 1: point1 = rg.Point(400, 250) point2 = rg.Point(440, 325) rectangle = rg.Rectangle(point1, point2) rectangle.fill_color = 'green' rectangle.outline_color = 'black' rectangle.outline_thickness = 5 draw_circles_from_rectangle(4, 5, rectangle, window1) # Test 2: point1 = rg.Point(500, 450) point2 = rg.Point(600, 400) rectangle = rg.Rectangle(point1, point2) rectangle.fill_color = 'blue' rectangle.outline_color = 'red' rectangle.outline_thickness = 3 draw_circles_from_rectangle(8, 3, rectangle, window1) window1.close_on_mouse_click() # ------------------------------------------------------------------ # A third test on ANOTHER window. # ------------------------------------------------------------------ window2 = rg.RoseWindow(620, 380) # Test 3: point1 = rg.Point(350, 280) point2 = rg.Point(375, 330) rectangle = rg.Rectangle(point1, point2) rectangle.fill_color = 'yellow' rectangle.outline_color = 'red' rectangle.outline_thickness = 5 draw_circles_from_rectangle(6, 10, rectangle, window2) window2.close_on_mouse_click()
# Upper Row go_along_row(ring_size, row_start_x, row_start_y, width, colors[k % len(colors)], window) # Left column go_along_column(ring_size, row_start_x, row_start_y, width, colors[k % len(colors)], window) # Lower Row lower_x = row_start_x lower_y = row_start_y + width * (ring_size - 1) go_along_row(ring_size, lower_x, lower_y, width, colors[k % len(colors)], window) # Right column upper_right_x = row_start_x + width * (ring_size - 1) upper_right_y = row_start_y go_along_column(ring_size, upper_right_x, upper_right_y, width, colors[k % len(colors)], window) # after we drew the row... row_start_x = row_start_x - width row_start_y = row_start_y - width window1 = rg.RoseWindow(1600, 900, "squares 1") squares(rg.Rectangle(rg.Point(450, 450), rg.Point(475, 475)), 15, ['cyan', 'pink', 'blue'], window1) window1.close_on_mouse_click()
def draw_lines_from_rectangles(rectangle1, rectangle2, n, window): """ What comes in: Four arguments: -- Two rg.Rectangles. -- A positive integer n. -- An rg.RoseWindow. What goes out: Nothing (i.e., None). Side effects: See draw_lines_from_rectangles.pdf in this project for pictures that may help you better understand the following specification: First draws the given rg.Rectangles on the given rg.RoseWindow. Then draws n rg.Lines on the given rg.RoseWindow, such that: -- The 1st rg.Line goes from the center of one of the 1st rg.Rectangle to the center of the 2nd rg.Rectangle. -- The 2nd rg.Line goes from the lower-left corner of the 1st rg.Rectangle and is parallel to the 1st rg.Line, with the same length and direction as the 1st rg.Line. -- Subsequent rg.Lines are shifted from the previous rg.Line in the same way that the 2nd rg.Line is shifted from the 1st. -- Each of the rg.Lines has thickness 5. -- The colors of the rg.Lines alternate, as follows: - The 1st, 3rd, 5th, ... rg.Line has color R1_color - The 2nd, 4th, 6th, ... rg.Line has color R2_color where - R1_color is the outline color of the 1st rg.Rectangle - R2_color is the outline color of the 2nd rg.Rectangle Must ** render ** but ** NOT close ** the window. Type hints: :type rectangle1: rg.Rectangle :type rectangle2: rg.Rectangle :type n: int :type window: rg.RoseWindow """ # ------------------------------------------------------------------ # TODO: 5. Implement and test this function. # Tests have been written for you (above). # # C ONSIDER using the ACCUMULATOR IN GRAPHICS pattern, # as in draw_row_of_circles in m1e, # instead of directly using the loop variable. # #################################################################### # HINT: To figure out the code that computes the necessary # endpoints for each line, # ** FIRST DO A CONCRETE EXAMPLE BY HAND! ** #################################################################### # ------------------------------------------------------------------ # Draw First Rectangle point1 = rectangle1._upper_left_corner point2 = rectangle1._lower_right_corner outline1 = rectangle1.outline_color thick = rectangle1.outline_thickness rectangle = rg.Rectangle(point1, point2) rectangle.outline_color = outline1 rectangle.outline_thickness = thick rectangle.attach_to(window) centerx = (point1.x + point2.x) / 2 centery = (point1.y + point2.y) / 2 center1 = rg.Point(centerx, centery) # Draw Second Rectangle point1 = rectangle2._upper_left_corner point2 = rectangle2._lower_right_corner outline2 = rectangle2.outline_color thick = rectangle2.outline_thickness rectangle = rg.Rectangle(point1, point2) rectangle.outline_color = outline2 rectangle.outline_thickness = thick rectangle.attach_to(window) centerx = (point1.x + point2.x) / 2 centery = (point1.y + point2.y) / 2 center2 = rg.Point(centerx, centery) # Draw Lines count = 1 point1 = center1 point2 = center2 for _ in range(n): line = rg.Line(point1, point2) line.thickness = 3 if count == 1: line.color = outline1 line.attach_to(window) count = count - 1 else: line.color = outline2 line.attach_to(window) count = count + 1 xdis = (rectangle1._lower_right_corner.x - \ rectangle1._upper_left_corner.x) / 2 ydis = (rectangle1._lower_right_corner.y - \ rectangle1._upper_left_corner.y) / 2 point1 = rg.Point(point1.x - xdis, point1.y + ydis) point2 = rg.Point(point2.x - xdis, point2.y + ydis) # ------------------------------------------------------------------ # render: Draw ALL the objects attached to this window. # ------------------------------------------------------------------ window.render()
def circle_and_rectangle(): """ -- Constructs an rg.RoseWindow. -- Constructs and draws a rg.Circle and rg.Rectangle on the window such that: -- They fit in the window and are easily visible. -- The rg.Circle is filled with 'blue' -- Prints (on the console, on SEPARATE lines) the following data associated with your rg.Circle: -- Its outline thickness. -- Its fill color. -- Its center. -- Its center's x coordinate. -- Its center's y coordinate. -- Prints (on the console, on SEPARATE lines) the same data but for your rg.Rectangle. -- Waits for the user to press the mouse, then closes the window. Here is an example of the output on the console, for one particular circle and rectangle: 1 blue Point(180.0, 115.0) 180 115 1 None Point(75.0, 150.0) 75.0 150.0 """ # ------------------------------------------------------------------------- # DONE: 3. Implement this function, per its green doc-string above. # -- ANY objects that meet the criteria are fine. # Put a statement in main to test this function # (by calling this function). # # IMPORTANT: Use the DOT TRICK to guess the names of the relevant # instance variables for outline thickness, etc. # ------------------------------------------------------------------------- window = rg.RoseWindow() x = 200 y = 150 color = 'blue' ccenter = rg.Point(x, y) point = rg.Point(x, y) radius = 50 circle = rg.Circle(point, radius) circle.outline_thickness = 1 circle.fill_color = color circle.attach_to(window) point1 = rg.Point(50, 50) point2 = rg.Point(100, 100) z = 75 w = 75 rcenter = rg.Point(z, w) rectangle = rg.Rectangle(point1, point2) rectangle.outline_thickness = 1 rectangle.attach_to(window) window.render() window.close_on_mouse_click() print('1') print(color) print(ccenter) print(x) print(y) print('1') print('None') print(rcenter) print(z) print(w)
def circle_and_rectangle(): """ -- Constructs an rg.RoseWindow. -- Constructs and draws a rg.Circle and rg.Rectangle on the window such that: -- They fit in the window and are easily visible. -- The rg.Circle is filled with 'blue' -- Prints (on the console, on SEPARATE lines) the following data associated with your rg.Circle: -- Its outline thickness. -- Its fill color. -- Its center. -- Its center's x coordinate. -- Its center's y coordinate. -- Prints (on the console, on SEPARATE lines) the same data but for your rg.Rectangle. -- Waits for the user to press the mouse, then closes the window. Here is an example of the output on the console, for one particular circle and rectangle: 1 blue Point(180.0, 115.0) 180 115 1 None Point(75.0, 150.0) 75.0 150.0 """ # ------------------------------------------------------------------------- # DONE: 3. Implement this function, per its green doc-string above. # -- ANY objects that meet the criteria are fine. # Put a statement in main to test this function # (by calling this function). # # IMPORTANT: Use the DOT TRICK to guess the names of the relevant # instance variables for outline thickness, etc. # ------------------------------------------------------------------------- window = rg.RoseWindow() cthick = 2 cx = 100 cy = 100 ccolor = 'blue' ccenter = rg.Point(cx, cy) rthick = 4 rx1 = 150 ry1 = 150 rx2 = 300 ry2 = 250 rcenterx = math.fabs(rx1 + rx2) / 2 rcentery = math.fabs(ry1 + ry2) / 2 rcenter = rg.Point(rcenterx, rcentery) rcolor = 'red' print( "--------------------------------------------------------------------------" ) print("Circle Variables") print( "--------------------------------------------------------------------------" ) print("Outline Thickness:", cthick) print("Fill Color:", ccolor) print("Center:", ccenter) print("Center's x Coordinate:", cx) print("Center's y Coordinate:", cy) print( "--------------------------------------------------------------------------" ) print("Rectangle Variables") print( "--------------------------------------------------------------------------" ) print("Outline Thickness:", rthick) print("Fill Color:", rcolor) print("Center:", rcenter) print("Center's x Coordinate:", rcenterx) print("Center's y Coordinate:", rcentery) circle = rg.Circle(ccenter, 50) circle.fill_color = ccolor circle.outline_thickness = cthick rectangle = rg.Rectangle(rg.Point(rx1, ry1), rg.Point(rx2, ry2)) rectangle.outline_thickness = rthick rectangle.fill_color = rcolor circle.attach_to(window) rectangle.attach_to(window) window.render() window.close_on_mouse_click()
# Author: Jaclyn Setina import rosegraphics as rg window = rg.RoseWindow(700, 400) center = rg.Point(100, 50) circle = rg.Circle(center, 40) circle.fill_color = 'red' circle.attach_to(window) corner_1 = rg.Point(100, 150) corner_2 = rg.Point(300, 250) rectangle = rg.Rectangle(corner_1, corner_2) rectangle.outline_color = 'blue' rectangle.attach_to(window) window.render() window.continue_on_mouse_click() start_point = rg.Point(300, 150) end_point = rg.Point(100, 250) line = rg.Line(start_point, end_point) line.arrow = 'last' line.attach_to(window) window.render() window.continue_on_mouse_click() circle.fill_color = 'blue' circle.attach_to(window)
def problem2b(rect, n, delta, win): """ See problem2b_picture.pdf in this project for pictures that may help you better understand the following specification: What comes in: -- An rg.Rectangle. -- A positive integer n. -- A positive integer delta. -- An rg.RoseWindow. What goes out: Nothing (i.e., None). Side effects: Draws n rg.Rectangles on the given rg.RoseWindow such that: -- The first rg.Rectangle is the given one. -- Subsequent rg.Rectangles have the same center as the given rg.Rectangle, but their width and height are each (2 * delta) greater than the width and height of the previous rg.Rectangle. That is, the distance from each line of each rg.Rectangle to the corresponding line of the rg.Rectangle next to it is delta. (See problem2b_picture.) Must render but ** NOT close ** the window. Type hints: :type rect: rg.Rectangle :type n: int :type delta: int :type win: rg.RoseWindow """ # ------------------------------------------------------------------------- # D: 3. Implement and test this function. # Tests have been written for you (above). # ------------------------------------------------------------------------- # ------------------------------------------------------------------------- # DIFFICULTY AND TIME RATINGS (see top of this file for explanation) # DIFFICULTY: 7 # TIME ESTIMATE: 15 to 25 minutes. # ------------------------------------------------------------------------- rect.attach_to(win) center = rect.get_center() height = rect.get_height() width = rect.get_width() cor1x = (center.x - (width / 2)) cor1y = (center.y - (height / 2)) cor2x = (center.x + (width / 2)) cor2y = (center.y + (height / 2)) for k in range(n - 1): cor1x = cor1x - delta cor1y = cor1y - delta cor1 = rg.Point(cor1x, cor1y) cor2x = cor2x + delta cor2y = cor2y + delta cor2 = rg.Point(cor2x, cor2y) rectangle = rg.Rectangle(cor1, cor2) rectangle.attach_to(win) win.render()
def circle_and_rectangle(center_x, center_y, radius, rectangle_corner1_x, rectangle_corner1_y, rectangle_corner2_x, rectangle_corner2_y): """ -- Constructs an rg.RoseWindow. -- Constructs and draws a rg.Circle and rg.Rectangle on the window such that: -- They fit in the window and are easily visible. -- The rg.Circle is filled with 'blue' -- Prints (on the console, on SEPARATE lines) the following data associated with your rg.Circle: -- Its outline thickness. -- Its fill color. -- Its center. -- Its center's x coordinate. -- Its center's y coordinate. -- Prints (on the console, on SEPARATE lines) the same data but for your rg.Rectangle. -- Waits for the user to press the mouse, then closes the window. Here is an example of the output on the console, for one particular circle and rectangle: 1 blue Point(180.0, 115.0) 180 115 1 None Point(75.0, 150.0) 75.0 150.0 """ # ------------------------------------------------------------------------- # DONE: 3. Implement this function, per its green doc-string above. # -- ANY objects that meet the criteria are fine. # Put a statement in main to test this function # (by calling this function). # # IMPORTANT: Use the DOT TRICK to guess the names of the relevant # instance variables for outline thickness, etc. # ------------------------------------------------------------------------- print('CIRCLE Parts') circle = rg.Circle(rg.Point(center_x, center_y), radius) circle.fill_color = ('blue') circle.attach_to(window1) print(circle.center) print(center_x) print(center_y) print('blue') circle.outline_thickness = 1 print(circle.outline_thickness) print('RECTANGLE Parts') rectangle_corner1 = rg.Point(rectangle_corner1_x, rectangle_corner1_y) rectangle_corner2 = rg.Point(rectangle_corner2_x, rectangle_corner2_y) rectangle = rg.Rectangle(rectangle_corner1, rectangle_corner2) rectangle.attach_to(window1) print(rectangle.outline_thickness) print(rectangle.fill_color) print(rectangle.get_center()) print(rectangle.get_center().x) print(rectangle.get_center().y) window1.render() return
def shapes(): print("rg.Point.x=5 should give an error") try: rg.Point.x = 5 except: print("Got the error!") traceback.print_exc() # raise # Demonstrates/tests the __repr__ methods: point1 = rg.Point(100, 200) point2 = rg.Point(300, 400) circle = rg.Circle(point1, 50) rectangle = rg.Rectangle(point1, point2) square = rg.Square(point1, 40) line = rg.Line(point1, point2) for shape in (point1, point2, circle, rectangle, square, line): print(shape) for shape in (circle, rectangle, square): shape.fill_color = 'red' shape.outline_color = 'blue' shape.outline_thickness = 5 line.color = 'green' line.thickness = 10 for shape in (point1, point2, circle, rectangle, square, line): print(shape) w = rg.RoseWindow(500, 300, 'hello') w.close_on_mouse_click() window1 = rg.RoseWindow(title='An empty window', make_initial_canvas=False) window1.close_on_mouse_click() window2 = rg.RoseWindow( 500, 300, 'Blue window with yellow canvas', # window_color='blue', # Mark: I assume most students # won't use this. canvas_color='yellow') center = rg.Point(300, 100) circle = rg.Circle(center, 40) circle.attach_to(window2.initial_canvas) circle.fill_color = 'red' window2.render(1) circle.fill_color = '' print("Emptied the fill color.") print(window2.width, window2.height) window2.render() window2.get_next_mouse_click() center.move_by(-200, -50) circle = rg.Circle(center, 70) circle.attach_to(window2.initial_canvas) circle.fill_color = None print(window2.width, window2.height) window2.render() window2.close_on_mouse_click() window3 = rg.RoseWindow() p1 = rg.Point(100, 50) p2 = rg.Point(200, 90) rect = rg.Rectangle(p1, p2) # rect.attach_to(window2.initial_canvas) # DCM: Two windows open, # confusing. rect.attach_to(window3.initial_canvas) window3.render(1) rect.fill_color = 'red' center.attach_to(window3.initial_canvas) window3.render(1) center.move_by(50, 0) window3.render() window3.close_on_mouse_click()
def problem2a(circle, rectangle, window): """ See problem2a_picture.pdf in this project for pictures that may help you better understand the following specification: What comes in: -- An rg.Circle. -- An rg.Rectangle. -- An rg.RoseWindow. What goes out: Nothing (i.e., None). Side effects: -- Draws the given rg.Circle and rg.Rectangle on the given rg.RoseWindow, then waits for the user to click the window. -- Then draws an rg.Line from the upper-right corner of the rg.Rectangle to its lower-left corner, with the line drawn as an arrow, then waits for the user to click the window. -- Changes the fill color of the given rg.Circle to the outline color of the given rg.Rectangle, then renders the window again (with no waiting for a click from the user this time). Must ** NOT close ** the window. Type hints: :type circle: rg.Circle :type rectangle: rg.Rectangle :type window: rg.RoseWindow """ # ------------------------------------------------------------------------- # DONE: 2. Implement and test this function. # Tests have been written for you (above). # ------------------------------------------------------------------------- # ------------------------------------------------------------------------- # DIFFICULTY AND TIME RATINGS (see top of this file for explanation) # DIFFICULTY: 6 # TIME ESTIMATE: 10 to 15 minutes. # ------------------------------------------------------------------------- r = circle.radius x1 = circle.center.x y1 = circle.center.y start_x = rectangle.get_upper_left_corner().x start_y = rectangle.get_upper_left_corner().y end_y = rectangle.get_lower_right_corner().y end_x = rectangle.get_lower_right_corner().x c1_color = rectangle.outline_color circle = rg.Circle(rg.Point(x1, y1), r) rectangle = rg.Rectangle(rg.Point(start_x, start_y), rg.Point(end_x, end_y)) circle.attach_to(window) rectangle.attach_to(window) window.render() window.continue_on_mouse_click() line = rg.Line(rg.Point(start_x, start_y), rg.Point(end_x, end_y)) line.attach_to(window) window.render() window.continue_on_mouse_click() circle.fill_color = c1_color window.render()
def circle_and_rectangle(): """ -- Constructs an rg.RoseWindow. -- Constructs and draws a rg.Circle and rg.Rectangle on the window such that: -- They fit in the window and are easily visible. -- The rg.Circle is filled with 'blue' -- Prints (on the console, on SEPARATE lines) the following data associated with your rg.Circle: -- Its outline thickness. -- Its fill color. -- Its center. -- Its center's x coordinate. -- Its center's y coordinate. -- Prints (on the console, on SEPARATE lines) the same data but for your rg.Rectangle. -- Waits for the user to press the mouse, then closes the window. Here is an example of the output on the console, for one particular circle and rectangle: 1 blue Point(180.0, 115.0) 180 115 1 None Point(75.0, 150.0) 75.0 150.0 """ # ------------------------------------------------------------------ # DONE: 3. Implement this function, per its doc-string above. # -- ANY objects that meet the criteria are fine. # Put a statement in main to test this function # (by calling this function). # # IMPORTANT: Use the DOT TRICK to guess the names of the relevant # instance variables for outline thickness, etc. # ------------------------------------------------------------------ window = rg.RoseWindow(400, 400) circle = rg.Circle(rg.Point(120, 120), 100) circle.fill_color = 'blue' circle.attach_to(window) print(circle.outline_thickness) print(circle.fill_color) print(circle.center) print(circle.center.x) print(circle.center.y) rectangle = rg.Rectangle(rg.Point(190, 200), rg.Point(390, 300)) rectangle.attach_to(window) rectangle.fill_color = 'SteelBlue' print(rectangle.outline_thickness) print(rectangle.fill_color) print(rectangle.corner_1) print(rectangle.corner_1.x) print(rectangle.corner_1.y) print(rectangle.corner_2) print(rectangle.corner_2.x) print(rectangle.corner_2.y) window.render() window.close_on_mouse_click()
def problem2b(rect, n, delta, win): """ See problem2b_picture.pdf in this project for pictures that may help you better understand the following specification: What comes in: -- An rg.Rectangle. -- A positive integer n. -- A positive integer delta. -- An rg.RoseWindow. What goes out: Nothing (i.e., None). Side effects: Draws n rg.Rectangles on the given rg.RoseWindow such that: -- The first rg.Rectangle is the given one. -- Subsequent rg.Rectangles have the same center as the given rg.Rectangle, but their width and height are each (2 * delta) greater than the width and height of the previous rg.Rectangle. That is, the distance from each line of each rg.Rectangle to the corresponding line of the rg.Rectangle next to it is delta. (See problem2b_picture.) Must render but ** NOT close ** the window. Type hints: :type rect: rg.Rectangle :type n: int :type delta: int :type win: rg.RoseWindow """ movex = delta movey = delta x1 = rect.corner_1.x y1 = rect.corner_1.y x2 = rect.corner_2.x y2 = rect.corner_2.y if x1 <= x2: xtopright = x2 xbottomleft = x1 if x2 <= x1: xbottomleft = x2 xtopright = x1 if y1 <= y2: ytopright = y1 ybottomleft = y2 if y2 <= y1: ybottomleft = y1 ytopright = y2 for _ in range(n): xtopright += movex ytopright -= movey xbottomleft -= movex ybottomleft += movey topright = rg.Point(xtopright, ytopright) bottomleft = rg.Point(xbottomleft, ybottomleft) rectangle = rg.Rectangle(topright, bottomleft) rectangle.attach_to(win) win.render()
def run_test_swap_colors(): """ Tests the swap_colors function. """ print() print('--------------------------------------------------') print('Testing the swap_colors function:') print('--------------------------------------------------') # ------------------------------------------------------------------ # Test 1: Note that it tests both: # -- what was SUPPOSED to be mutated (fill_color) and # -- what was NOT supposed to be mutated (all else). # The code passes this test if the expected value printed # is the same as the actual value printed. # ------------------------------------------------------------------ circle = rg.Circle(rg.Point(100, 150), 50) circle.fill_color = 'blue' rectangle = rg.Rectangle(rg.Point(200, 30), rg.Point(350, 150)) rectangle.fill_color = 'green' expected_c = 'Circle: center=(100, 150), radius=50,' expected_c += ' fill_color=green, outline_color=black,' expected_c += ' outline_thickness=1.' expected_r = 'Rectangle: corner_1=(200, 30), corner_2=(350, 150),' expected_r += ' fill_color=blue, outline_color=black,' expected_r += ' outline_thickness=1.' swap_colors(circle, rectangle) print() print('Expected circle after the function call:') print(expected_c) print('Actual circle after the function call:') print(circle) print() print('Expected rectangle after the function call:') print(expected_r) print('Actual rectangle after the function call:') print(rectangle) # ------------------------------------------------------------------ # Test 2: This is a VISUAL test. # The code passes this test if the objects are drawn per the test. # # Here, that means that when the window pauses and asks the user # to press any key to continue: # -- the circle is black_filled and # -- the rectangle is red_filled # and then when the user presses a key and the window pauses # again, now the reverse is true: # -- the circle is red_filled and # -- the rectangle is black_filled. # ------------------------------------------------------------------ title = 'The code passes the test if the fill colors of the circle' title += ' and rectangle get SWAPPED.' window = rg.RoseWindow(700, 400, title) circle = rg.Circle(rg.Point(100, 50), 40) circle.fill_color = 'black' circle.attach_to(window) rectangle = rg.Rectangle(rg.Point(200, 280), rg.Point(350, 350)) rectangle.fill_color = 'red' rectangle.attach_to(window) msg1 = 'At this point, the circle should be filled with BLACK\n' msg1 += 'and the rectangle should be filled with RED' message = rg.Text(rg.Point(400, 100), msg1) message.attach_to(window) # At this point, the CIRCLE should be filled with BLACK # and the RECTANGLE filled with RED. window.render() window.continue_on_mouse_click() swap_colors(circle, rectangle) # At this point, the CIRCLE should be filled with RED # and the RECTANGLE filled with BLACK. msg2 = 'Now, the circle should be filled with RED\n' msg2 += 'and the rectangle should be filled with BLACK.\n' msg2 += 'If so, and if nothing else changed,\n' msg2 += 'the code passed this test.' message.text = msg2 window.render() window.close_on_mouse_click()
def run_test_fill_from_colors(): """ Tests the fill_from_colors function. """ print('--------------------------------------------------') print('Testing the fill_from_colors function:') print('See the two graphics windows that pop up.') print('--------------------------------------------------') # ------------------------------------------------------------------ # Test 1: Flashes red, white, blue -- 5 times. # ------------------------------------------------------------------ title = 'Red, white and blue, repeated 5 times!' window = rg.RoseWindow(400, 180, title, canvas_color='dark gray') circle = rg.Circle(rg.Point(150, 100), 40) circle.attach_to(window.initial_canvas) number_of_cycles = 5 window.continue_on_mouse_click('Click anywhere in here to start') for _ in range(number_of_cycles): fill_from_colors(window, circle, ['red', 'white', 'blue']) window.close_on_mouse_click() # ------------------------------------------------------------------ # Test 2: Flashes through a bunch of colors, looping through the # list forwards in a rectangle, then backwards in an ellipse. # ------------------------------------------------------------------ colors = [ 'red', 'white', 'blue', 'chartreuse', 'chocolate', 'DodgerBlue', 'LightPink', 'maroon', 'yellow', 'green', 'SteelBlue', 'black' ] title = 'Loop through 12 colors, forwards then backwards!' window = rg.RoseWindow(450, 250, title, canvas_color='yellow') rect_width = 100 rect_height = 40 rect_center = rg.Point(125, 100) rectangle = rg.Rectangle( rg.Point(rect_center.x - (rect_width / 2), rect_center.y - (rect_height / 2)), rg.Point(rect_center.x + (rect_width / 2), rect_center.y + (rect_height / 2))) oval_width = 70 oval_height = 160 oval_center = rg.Point(300, 100) ellipse = rg.Ellipse( rg.Point(oval_center.x - (oval_width / 2), oval_center.y - (oval_height / 2)), rg.Point(oval_center.x + (oval_width / 2), oval_center.y + (oval_height / 2))) rectangle.attach_to(window) ellipse.attach_to(window) window.render() window.continue_on_mouse_click('Click anywhere in here to start') # This function call iterates through the colors, # filling the rectangle with those colors: fill_from_colors(window, rectangle, colors) # The reverse method reverses its list IN PLACE # (i.e., it "mutates" its list -- more on that in future sessions). colors.reverse() window.continue_on_mouse_click() # This function call iterates through the colors, # filling the ellipse (oval) with those colors: fill_from_colors(window, ellipse, colors) window.close_on_mouse_click()