cs110_p1

   1## DON"T OPEN THIS FILE! USE THE PURPLE BUTTON ON THE ASSIGNMENT
   2##   to see what functions are available and what their inputs are!
   3
   4###################################################################
   5
   6## PROCEED AT YOUR OWN RISK! THERE BE DRAGONS!
   7
   8_VERSION = "2025.1.1"
   9
  10###################################################################
  11### IGNORE EVERYTHING THAT STARTS WITH A _
  12from random import randint
  13from math import sqrt, pi, radians, sin, cos, floor
  14from time import sleep
  15from tkinter import Tk, Canvas
  16
  17
  18__docformat__ = "google"
  19
  20_a_canvas = None
  21_resize_enabled = False
  22
  23
  24Shape_Drawing_Functions = ""
  25
  26
  27def arc(points=[], width=5, color="hot pink", line_steps=15, tag="", ):
  28    """
  29    A reporter function that draws an arc ("curve") given a list of points.
  30    Args:
  31        points (`list`): The points outlining the curve; this should be a list of tuples (coordinates).
  32            Make sure to give it at least 3 (x,y) coordinates that aren"t a straight line!
  33        color (`str`): What color to make the shape.
  34        tag (`str`): The tag to assign to the shape.
  35
  36    Returns:
  37        `Shape`: The arc that was created.
  38    """
  39    return _a_canvas.create_line(
  40        points,
  41        width=width,
  42        fill=color,
  43        splinesteps=line_steps,
  44        smooth=True,
  45        tags=tag,
  46        ,
  47    )
  48
  49
  50def car(top_left=(0, 0), size=100, body_color="#3D9970", wheel_color="black", tag=""):
  51    """
  52    Draws a cool car.
  53
  54    Args:
  55        top_left (`tuple`): A coordinate at which to draw the car.
  56        body_color (`str`): Color to make the body of the car.
  57        wheel_color (`str`): Color to make the wheel of the car.
  58        tag (`str`): The tag to assign to the shape.
  59    """
  60    x, y = top_left
  61    rectangle((x + 5 * size / 10, y), size, size / 10 * 4, color=body_color, tag=tag)
  62    rectangle(
  63        (x, y + size - 7 * size / 10),
  64        size * 2,
  65        size / 10 * 4.5,
  66        color=body_color,
  67        tag=tag,
  68    )
  69    circle(
  70        (x + 5 * size / 10, y + size - size / 5), size / 5, color=wheel_color, tag=tag
  71    )
  72    circle(
  73        (x + 15 * size / 10, y + size - size / 5), size / 5, color=wheel_color, tag=tag
  74    )
  75
  76
  77def circle(center=(0, 0), radius=25, color="hot pink", outline="", tag="", ):
  78    """
  79    A reporter function that draws a circle.
  80    Args:
  81        center (`tuple`): A coordinate representing the center of the shape.
  82        radius (`int`): Specifies the circle"s radius.
  83        color (`str`): What color to draw the shape.
  84        outline (`str`): What color should the border of the shape be.
  85        tag (`str`): The tag to assign to the shape.
  86
  87    Returns:
  88        `Shape`: The circle that was created.
  89    """
  90    return oval(
  91        center=center, radius_x=radius, radius_y=radius, color=color, tag=tag, 
  92    )
  93
  94
  95def cloud(center=(0, 0), size=30, color="white", tag=""):
  96    """
  97    Reporter function that draws a cloud to the screen.
  98    Args:
  99        center (`tuple`): the point on which to center the cloud
 100        size (`int`): how big (roughly) the cloud is drawn
 101        color (`str`): which determines the color of the cloud
 102        tag (`str`): to give the cloud a name
 103
 104    Returns:
 105        `Shape`: The cloud that was created.
 106    """
 107    for i in range(10):
 108        x_offset = randint((-1 * size * 1.333), (size * 1.333))
 109        y_offset = randint(0, (size * 0.667))
 110        circle(
 111            center=(center[0] + x_offset, center[1] + y_offset),
 112            radius=randint((size * 0.667), (size * 1.667)),
 113            color=color,
 114            tag=tag,
 115        )
 116    return tag
 117
 118
 119def diamond(
 120    center=(0, 0), width=25, height=50, color="hot pink", outline="", tag="", 
 121):
 122    """
 123    A reporter function that draws a rectangle.
 124    Args:
 125        center (`tuple`): A coordinate representing the center of the shape.
 126        width (`int`): How wide to draw the shape.
 127        height (`int`): How tall to draw the shape.
 128        color (`str`): What color to draw the shape.
 129        outline (`str`): What color should the border of the shape be.
 130        tag (`str`): The tag to assign to the shape.
 131
 132    Returns:
 133        `Shape`: The shape that was created.
 134    """
 135    point_0 = (center[0] - width / 2, center[1])
 136    point_1 = (center[0], center[1] - height / 2)
 137    point_2 = (center[0] + width / 2, center[1])
 138    point_3 = (center[0], center[1] + height / 2)
 139    return _a_canvas.create_polygon(
 140        point_0,
 141        point_1,
 142        point_2,
 143        point_3,
 144        fill=_safe_color(color),
 145        tags=tag,
 146        outline=outline,
 147        ,
 148    )
 149
 150
 151def grid(width=None, height=None, interval=100, show_labels=True):
 152    """
 153    Draws a grid on a screen with intervals of 100.
 154
 155    Args:
 156        width (`int`): The width of the grid to draw (defaults to the whole window)
 157        height (`int`): The height of the grid to draw (defaults to the whole window)
 158        interval (`int`): The interval to draw the grid on.
 159        show_labels (`bool`): Whether or not to show coordinate labels.
 160
 161    """
 162
 163    if width is None
 164        width = get_window_width()
 165
 166    if height is None
 167        height = get_window_height()
 168
 169    # Creates all vertical lines at intervals of 100
 170    for i in range(0, width, interval):
 171        _a_canvas.create_line(i, 0, i, height, tag="grid", fill="black")
 172    # Creates all horizontal lines at intervals of 100
 173    for i in range(0, height, interval):
 174        _a_canvas.create_line(0, i, width, i, tag="grid", fill="black")
 175
 176    if show_labels
 177        # Creates axis labels
 178        offset = 2
 179        for y in range(0, height, interval):
 180            for x in range(0, width, interval):
 181                _a_canvas.create_oval(
 182                    x - offset,
 183                    y - offset,
 184                    x + offset,
 185                    y + offset,
 186                    fill="black",
 187                    tag="grid",
 188                )
 189                _a_canvas.create_text(
 190                    x + offset,
 191                    y + offset,
 192                    text="({0}, {1})".format(x, y),
 193                    anchor="nw",
 194                    font=("Purisa", 8),
 195                    fill="black",
 196                    tag="grid",
 197                )
 198
 199
 200_cache = []
 201
 202
 203def image(image_path, position=(200, 200), rotation=None, scale=None, tag="", ):
 204    """
 205    Draws a given image on the screen. NOTE: Requires the `pillow` package to be installed - contact
 206    Prof. Bain or post on edSTEM if you"d like more details!
 207
 208    Args:
 209        image_path (`str`): Location of the image file on your computer.
 210        position (`tuple`): A coordinate at which to render the image.
 211        rotation (`int`): A number of degrees to rotate the given image.
 212        scale (`int`): A scaling factor to multiply the image size by.
 213        tag (`str`): A string representing the "name" fo this shape.
 214    """
 215    # import PIL libraries
 216    from PIL import Image, ImageTk
 217
 218    anchor = "nw"
 219
 220    import os
 221
 222    # 1. create PIL image and apply any image transformations:
 223    dir_path = os.path.dirname(os.path.realpath(__file__))
 224    image_path = os.path.join(dir_path, image_path)
 225    pil_image = Image.open(image_path)
 226    if scale
 227        size = (round(pil_image.size[0] * scale), round(pil_image.size[1] * scale))
 228        pil_image = pil_image.resize(size)
 229    if rotation
 230        pil_image = pil_image.rotate(rotation)  # note: returns a copy
 231
 232    # 2. convert to tkinter-compatible image format:
 233    tkinter_image = ImageTk.PhotoImage(pil_image)
 234    _cache.append(
 235        tkinter_image
 236    )  # workaround for known tkinter bug: http://effbot.org/pyfaq/why-do-my-tkinter-images-not-appear.htm
 237
 238    # 3. draw image on canvas:
 239    _a_canvas.create_image(
 240        *position, image=tkinter_image, anchor=anchor, tags=tag, 
 241    )
 242
 243
 244def line(points=[], curvy=False, color="hot pink", tag="", ):
 245    """
 246    A reporter function that draws a line given a list of points.
 247    Args:
 248        points (`list`): The points that define the line; this should be a list of tuples (coordinates).
 249        curvy (`bool`): Makes a curvy line instead.
 250        color (`str`): What color to make the shape.
 251        tag (`str`): The tag to assign to the shape.
 252
 253    Returns:
 254        `Shape`: The line that was created.
 255    """
 256    return _a_canvas.create_line(points, fill=color, smooth=curvy, tags=tag, )
 257
 258
 259def oval(
 260    center=(0, 0),
 261    radius_x=25,
 262    radius_y=50,
 263    color="hot pink",
 264    outline="",
 265    tag="",
 266    ,
 267):
 268    """
 269    A reporter function that draws an oval.
 270    Args:
 271        center (`tuple`): A coordinate representing the center of the shape.
 272        radius_x (`int`): Specifies the oval"s radius on the x-axis.
 273        radius_y (`int`): Specifies the oval"s radius on the y-axis.
 274        color (`str`): What color to draw the shape.
 275        outline (`str`): What color should the border of the shape be.
 276        tag (`str`): The tag to assign to the shape.
 277
 278    Returns:
 279        `Shape`: The oval that was created.
 280    """
 281    x = center[0]
 282    y = center[1]
 283    x0, y0, x1, y1 = (x - radius_x, y - radius_y, x + radius_x, y + radius_y)
 284    steps = 100
 285    # major and minor axes
 286    a = (x1 - x0) / 2.0
 287    b = (y1 - y0) / 2.0
 288    # center
 289    xc = x0 + a
 290    yc = y0 + b
 291    point_list = []
 292    # create the oval as a list of points
 293    for i in range(steps):
 294        # Calculate the angle for this step
 295        theta = (pi * 2) * (float(i) / steps)
 296        x = a * cos(theta)
 297        y = b * sin(theta)
 298        point_list.append(round(x + xc))
 299        point_list.append(round(y + yc))
 300
 301    return _a_canvas.create_polygon(
 302        point_list, fill=_safe_color(color), tags=tag, 
 303    )
 304
 305
 306def pixel_art(top_left, artwork, palette, pixel=10, tag=""):
 307    """
 308    Draws a pixel art design!
 309
 310    Args:
 311        top_left (`tuple`): the top left coordinate of the pixel art
 312        artwork (sequence of sequences): the art to draw
 313        palette (sequence): the palette of colors to use for each different square
 314        pixel (`int`): how big each individual pixel should be
 315        tag (`str`): the tag to assign to every square in the row
 316
 317    Note: this doesn"t return anything so make sure to use a tag if you want to animate / modify.
 318    """
 319    x = top_left[0]
 320    y = top_left[1]
 321    for row in artwork
 322        # draw each row at the specified (x, y) position:
 323        _draw_row(row, (x, y), colors=palette, pixel=pixel, tag=tag)
 324        # ...and don"t forget to shift the y-value down by the proper
 325        #  amount so that the next row won"t draw on top of the first one:
 326        y += pixel
 327
 328
 329def polygon(points=[], color="hot pink", outline="", tag="", ):
 330    """
 331    A reporter function that draws a polygon given a list of points.
 332    Args:
 333        points (`list`): The points outlining the polygon; this should be a list of tuples (coordinates).
 334            defaults to an empty list.
 335        outline (`str`): What color should the border of the shape be.
 336        color (`str`): What color to make the shape.
 337
 338    Returns:
 339        `Shape`: The polygon that was created.
 340    """
 341    return _a_canvas.create_polygon(points, fill=_safe_color(color), tags=tag, )
 342
 343
 344def rectangle(
 345    top_left=(0, 0), width=25, height=50, color="hot pink", outline="", tag="", 
 346):
 347    """
 348    A reporter function that draws a rectangle.
 349    Args:
 350        top_left (`tuple`): A coordinate representing the top left-hand corner of the shape.
 351        width (`int`): How wide to draw the shape.
 352        height (`int`): How tall to draw the shape.
 353        color (`str`): What color to draw the shape.
 354        outline (`str`): What color should the border of the shape be.
 355        tag (`str`): The tag to assign to the shape.
 356
 357    Returns:
 358        `Shape`: The rectangle that was created.
 359    """
 360    point_0 = top_left
 361    point_1 = (top_left[0] + width, top_left[1])
 362    point_2 = (top_left[0] + width, top_left[1] + height)
 363    point_3 = (top_left[0], top_left[1] + height)
 364    return _a_canvas.create_polygon(
 365        point_0, point_1, point_2, point_3, fill=_safe_color(color), tags=tag, 
 366    )
 367
 368
 369def spiral(
 370    center=(0, 0), width=100, roughness=0.01, start=0, spirals=5, line_width=1, 
 371):
 372    """
 373    A reporter function that draws a spiral.
 374    Args:
 375        center (`tuple`): A coordinate representing the center of the shape.
 376        width (`int`): Specifies the total width of the spiral.
 377        roughness (`float`): Controls how spiral-y the shape is (lower is less spiral-y)
 378        start (`int`): Where on the spiral to start drawing.
 379        spirals (`int`): How many loops to draw.
 380        line_width (`int`): How wide for the line to be drawn.
 381        tag (`str`): The tag to assign to the shape.
 382
 383    Returns:
 384        `Shape`: The spiral that was created.
 385    """
 386    theta = 0.0
 387    r = start
 388    all_points = []
 389    prev_pos = _polar_to_cartesian(r, theta)
 390    distance = width / 4 / pi / spirals
 391    all_points.append((prev_pos[0] + center[0], prev_pos[1] + center[1]))
 392    while theta < 2 * spirals * pi
 393        theta += roughness
 394        r = start + distance * theta
 395        pos = _polar_to_cartesian(r, theta)
 396        all_points.append((pos[0] + center[0], pos[1] + center[1]))
 397
 398    return arc(points=all_points, width=line_width, )
 399
 400
 401def square(top_left=(0, 0), size=25, color="hot pink", outline="", tag="", ):
 402    """
 403    A reporter function that draws a square.
 404    Args:
 405        top_left (`tuple`): A coordinate representing the top left-hand corner of the shape.
 406        size (`int`): How big to draw the shape.
 407        color (`str`): What color to draw the shape.
 408        outline (`str`): What color should the border of the shape be.
 409        tag (`str`): The tag to assign to the shape.
 410
 411    Returns:
 412        `Shape`: The square that was created.
 413    """
 414    return rectangle(
 415        top_left=top_left, width=size, height=size, color=color, tag=tag, 
 416    )
 417
 418
 419def star(
 420    center=(0, 0),
 421    radius=50,
 422    color="hot pink",
 423    outer_radius=75,
 424    points=5,
 425    outline="",
 426    tag="",
 427    ,
 428):
 429    """
 430    A reporter function that draws a star.
 431    Args:
 432        center (`tuple`): A coordinate representing the center of the shape.
 433        radius (`int`): Specifies the radius of the inside part of the star.
 434        color (`str`): Specifies the color of the star.
 435        outer_radius (`int`): Specifies the radius of the outside part of the star.
 436        points (`int`): Specifies the number of points for the star.
 437        outline (`str`): What color should the border of the shape be.
 438        tag (`str`): The tag to assign to the shape.
 439
 440    Returns:
 441        `Shape`: The star that was created.
 442    """
 443    arc_segment = 360 / points
 444    vertices = []
 445    for i in range(points):
 446        inner_point = (
 447            radius * cos(radians(arc_segment * i)) + center[0],
 448            -1 * radius * sin(radians(arc_segment * i)) + center[1],
 449        )
 450        vertices.append(inner_point)
 451        outer_point = (
 452            outer_radius * cos(radians(arc_segment * i + arc_segment / 2)) + center[0],
 453            -1 * outer_radius * sin(radians(arc_segment * i + arc_segment / 2))
 454            + center[1],
 455        )
 456        vertices.append(outer_point)
 457    return polygon(vertices, color=color, tag=tag, )
 458
 459
 460def text(
 461    top_left=(0, 0), text="", font=("Purisa", 32), color="black", tag="", 
 462):
 463    """
 464    A reporter function that draws text to the screen
 465    Args:
 466        top_left (`tuple`): coordinate pair to specify the location.
 467        text (`str`): What text to draw.
 468        font (`tuple`): A tuple where the first element is a string for the font name and the second is an
 469           int with the font size.
 470        color (`str`): What color should the text be.
 471        tag (`str`): The name to tag this thing with.
 472
 473    Returns:
 474        `Shape`: The text that was created.
 475    """
 476    return _a_canvas.create_text(
 477        top_left, text=text, font=font, fill=color, tags=tag, 
 478    )
 479
 480
 481def triangle(
 482    bottom_center=(0, 0),
 483    width=25,
 484    top_shift=0,
 485    height=0,
 486    color="hot pink",
 487    outline="",
 488    tag="",
 489    ,
 490):
 491    """
 492    A reporter function that draws a triangle.
 493    Args:
 494        bottom_center (`tuple`): A coordinate representing the bottom center of the shape.
 495        width (`int`): Specifies the width of the base of the triangle.
 496        top_shift (`int`): Specifies the how far to the left or right to shift the top of
 497            the triangle from the bottom center.
 498        height (`int`): Specifies the triangle"s height.
 499        color (`str`): What color to draw the shape.
 500        outline (`str`): What color should the border of the shape be.
 501        tag (`str`): The tag to assign to the shape.
 502
 503    Returns:
 504        `Shape`: The triangle that was created.
 505    """
 506    if height == 0
 507        height = width * sqrt(3) / 2
 508    point_0 = (bottom_center[0] - width / 2, bottom_center[1])
 509    point_1 = (bottom_center[0] + width / 2, bottom_center[1])
 510    point_2 = (bottom_center[0] + top_shift, bottom_center[1] - height)
 511
 512    return _a_canvas.create_polygon(
 513        point_0, point_1, point_2, fill=_safe_color(color), tags=tag, 
 514    )
 515
 516
 517def wedge(
 518    center=(0, 0), radius=25, angle=180, color="hot pink", outline="", tag="", 
 519):
 520    """
 521    A reporter function that draws a circle.
 522    Args:
 523        center (`tuple`): A coordinate representing the center of the shape.
 524        radius (`int`): Specifies the circle"s radius.
 525        angle (`int`): A number between 0 and 360 that specifies how much of the circle to draw.
 526        color (`str`): What color to draw the shape.
 527        outline (`str`): What color should the border of the shape be.
 528        tag (`str`): The tag to assign to the shape.
 529
 530    Returns:
 531        `Shape`: The wedge that was created.
 532    """
 533    point_list = [center[0], center[1]]
 534    for i in range(0, 0 + angle):
 535        x1 = center[0] + radius * cos(radians(i))
 536        point_list.append(x1)
 537        y1 = center[1] + radius * sin(radians(i))
 538        point_list.append(y1)
 539
 540    point_list.append(center[0])
 541    point_list.append(center[1])
 542
 543    return _a_canvas.create_polygon(
 544        point_list, fill=_safe_color(color), outline=outline, tags=tag, 
 545    )
 546
 547
 548Shape_Modifier_Functions = ""
 549
 550
 551def above(shape1, shape2, offset_x=0, offset_y=0):
 552    """
 553    A reporter function that places shape1 above shape2 (vertically). It does this by moving shape 1"s center
 554    to shape 2"s center, moving shape 1 in the y-direction the exact height of shape 2, and then applying any
 555    specified offset.
 556
 557    Args:
 558        shape1 (`Shape` or Tag): The first shape to use.
 559        shape2 (`Shape` or Tag): The second shape to use.
 560        offset_x (`int`): How much to shift shape 2 in the x-direction after moving it.
 561        offset_y (`int`): How much to shift shape 2 in the x-direction after moving it.
 562
 563    Returns:
 564        `Shape`: The modified shape1.
 565    """
 566    overlay(shape1, shape2)
 567    _a_canvas.move(
 568        shape1,
 569        0 + offset_x,
 570        -1 * (get_height(shape2) + get_height(shape1)) / 2 + offset_y,
 571    )
 572    return shape1
 573
 574
 575def align(shape1, shape2, via="middle", offset_x=0, offset_y=0):
 576    """
 577    A reporter function that aligns `shape1` with `shape2`. It does this by moving `shape1` to align with
 578    whatever property of `shape2` is selected with the `via` input.
 579
 580    Args:
 581        shape1 (`Shape` or Tag): The first shape to use.
 582        shape2 (`Shape` or Tag): The second shape to use.
 583        via (`str`): Has to be one of, the following options: `"center"` (horizontal center),
 584            `"middle"` (vertical center), `"top"`, `"bottom"`, `"left"`, or `"right"`
 585        offset_x (`int`): How much to shift in the x-axis after alignment
 586        offset_y (`int`): How much to shift in the y-axis after alignment
 587
 588    Returns:
 589        `Shape`: The modified shape1.
 590    """
 591    via_options = ["center", "middle", "top", "bottom", "left", "right"]
 592    if via not in via_options
 593        raise ValueError(
 594            "The via input must be one of "
 595            + (via_options)
 596            + " but instead we found "
 597            + (via)
 598        )
 599
 600    outline1 = _get_outline(shape1)
 601    outline2 = _get_outline(shape2)
 602
 603    if via == "center"
 604        _a_canvas.move(
 605            shape1, (outline2["center"][0] - outline1["center"][0]) + offset_x, offset_y
 606        )
 607
 608    elif via == "middle"
 609        _a_canvas.move(
 610            shape1, offset_x, (outline2["center"][1] - outline1["center"][1]) + offset_y
 611        )
 612
 613    elif via == "top"
 614        _a_canvas.move(shape1, offset_x, (outline2["top"] - outline1["top"]) + offset_y)
 615
 616    elif via == "bottom"
 617        _a_canvas.move(
 618            shape1, offset_x, (outline2["bottom"] - outline1["bottom"]) + offset_y
 619        )
 620
 621    elif via == "left"
 622        _a_canvas.move(
 623            shape1, (outline2["left"] - outline1["left"]) + offset_x, offset_y
 624        )
 625
 626    elif via == "right"
 627        _a_canvas.move(
 628            shape1, (outline2["right"] - outline1["right"]) + offset_x, offset_y
 629        )
 630
 631    return shape1
 632
 633
 634def beside(shape1, shape2, offset_x=0, offset_y=0):
 635    """
 636    A reporter function that places shape1 beside shape2 (horizontally). It does this by moving shape 1"s center
 637    to shape 2"s center, moving shape 1 in the x-direction the exact width of shape 2, and then applying any
 638    specified offset.
 639
 640    Args:
 641        shape1 (`Shape` or Tag): The first shape to use.
 642        shape2 (`Shape` or Tag): The second shape to use.
 643        offset_x (`int`): How much to shift shape 2 in the x-direction after moving it.
 644        offset_y (`int`): How much to shift shape 2 in the x-direction after moving it.
 645
 646    Returns:
 647        `Shape`: The modified shape1.
 648    """
 649    overlay(shape1, shape2)
 650    _a_canvas.move(
 651        shape1,
 652        (get_width(shape2) + get_width(shape1)) / 2 + offset_x,
 653        0 + offset_y,
 654    )
 655    return shape1
 656
 657
 658def below(shape1, shape2, offset_x=0, offset_y=0):
 659    """
 660    A reporter function that places shape1 below shape2 (vertically). It does this by moving shape 1"s center
 661    to shape 2"s center, moving shape 1 in the y-direction the exact height of shape 2, and then applying any
 662    specified offset.
 663
 664    Args:
 665        shape1 (`Shape` or Tag): The first shape to use.
 666        shape2 (`Shape` or Tag): The second shape to use.
 667        offset_x (`int`): How much to shift shape 2 in the x-direction after moving it.
 668        offset_y (`int`): How much to shift shape 2 in the x-direction after moving it.
 669
 670    Returns:
 671        `Shape`: The modified shape1.
 672    """
 673    overlay(shape1, shape2)
 674    _a_canvas.move(
 675        shape1,
 676        0 + offset_x,
 677        (get_height(shape2) + get_height(shape1)) / 2 + offset_y,
 678    )
 679    return shape1
 680
 681
 682def change_color(shape, color):
 683    """
 684    Change the fill color of a tagged object.
 685
 686    Args:
 687        shape (`Shape` or Tag): The shape or tag to re-fill.
 688        color (`str`): A color name or hex code to re-fill with.
 689    """
 690    ids = _a_canvas.find_withtag(shape)
 691    for id in ids
 692        _a_canvas.itemconfig(id, fill=color)
 693
 694
 695def delete(shape):
 696    """
 697    A function that deletes a shape from our screen.
 698
 699    Args:
 700        shape (`Shape` or Tag): The shape to delete.
 701    """
 702    _a_canvas.delete(shape)
 703
 704
 705def duplicate(shape, color=None):
 706    """
 707    A reporter function that perfectly copies a shape and returns that copy.
 708
 709    Args:
 710        shape (`Shape` or Tag): The shape to duplicate.
 711        color (`str`): A new color to use with the duplicated shape.
 712
 713    Returns:
 714        `Shape`: The new duplicated shape.
 715    """
 716    shape_type = _a_canvas.type(shape)
 717    shape_config = _a_canvas.itemconfig(shape)
 718    shape_coords = _a_canvas.coords(shape)
 719    the_copy = None
 720    if shape_type == "polygon"
 721        new_config = {key shape_config[key][-1] for key in shape_config.keys()}
 722        if color != None
 723            new_config["fill"] = color
 724        the_copy = _a_canvas.create_polygon(shape_coords, new_config)
 725        return the_copy
 726
 727
 728def mirror(shape):
 729    """
 730    A function that takes a shape and flips it across its vertical
 731    axis, returning the modified shape.
 732
 733    Args:
 734        shape (`Shape` or Tag): The shape in question.
 735
 736    """
 737    center = get_center(shape)[0]
 738    shape_ids = _a_canvas.find_withtag(shape)
 739    for shape_id in shape_ids
 740        flipped_coordinates = []
 741        shape_coords = _a_canvas.coords(shape_id)
 742        counter = 0
 743        for num in shape_coords
 744            if counter % 2 == 0
 745                if num < center
 746                    flipped_coordinates.append(num + 2 * (center - num))
 747                elif num > center
 748                    flipped_coordinates.append(num - 2 * (num - center))
 749                else
 750                    flipped_coordinates.append(num)
 751            else
 752                flipped_coordinates.append(num)
 753            counter += 1
 754        _a_canvas.coords(shape_id, flipped_coordinates)
 755
 756
 757def move(shape, x_shift=0, y_shift=0):
 758    """
 759    Purpose: Move the x and y position of all shapes that have been tagged
 760    with the tag argument
 761
 762    Args:
 763        shape (`Shape` or Tag): The shape in question.
 764        x_shift (`int`): amount to move in the x direction
 765        y_shift (`int`): amount to move in the y direction
 766    """
 767    shape_ids = _a_canvas.find_withtag(shape)
 768    for id in shape_ids
 769        _a_canvas.move(id, x_shift, y_shift)
 770
 771
 772def move_to(tag, to, anchor="center"):
 773    """
 774    Move the given tagged item to a particular `point` maintaining some `anchor`.
 775    Note: this is NOT the same as the `move` function which moves an object by a specific amount.
 776
 777    Args:
 778        tag (Shape or `str`): the shape (or shapes) to move
 779        to (`tuple`): the `(x, y)` coordinate to which you wish to move the tagged object
 780        anchor (`str`): which point on the shape do you want to move toward the given tuple. You can
 781            use either `"center"` (default), `"top_left"`, `"top_right"`, `"bottom_left"`, or `"bottom_right"`.
 782    """
 783    anchor_options = ["center", "top_left", "top_right", "bottom_left", "bottom_right"]
 784    if anchor not in anchor_options
 785        raise ValueError(
 786            "The anchor input must be one of "
 787            + (anchor_options)
 788            + " but instead we found "
 789            + (anchor)
 790        )
 791
 792    outline = _get_outline(tag)
 793    delta_x = 0
 794    delta_y = 0
 795
 796    if anchor == "top_left"
 797        delta_x = to[0] - outline["left"]
 798        delta_y = to[1] - outline["top"]
 799    elif anchor == "top_right"
 800        delta_x = to[0] - outline["right"]
 801        delta_y = to[1] - outline["top"]
 802    elif anchor == "bottom_right"
 803        delta_x = to[0] - outline["right"]
 804        delta_y = to[1] - outline["bottom"]
 805    elif anchor == "bottom_left"
 806        delta_x = to[0] - outline["left"]
 807        delta_y = to[1] - outline["bottom"]
 808    elif anchor == "center"
 809        delta_x = to[0] - outline["center"][0]
 810        delta_y = to[1] - outline["center"][1]
 811
 812    _a_canvas.move(tag, delta_x, delta_y)
 813
 814
 815def overlay(shape1, shape2, offset_x=0, offset_y=0):
 816    """
 817    A reporter function that overlays shape1 onto shape2. It does this by moving shape 1"s center
 818    to shape 2"s center, and then applying any specified offset.
 819    Args:
 820        shape1 (`Shape` or Tag): The first shape to use.
 821        shape2 (`Shape` or Tag): The second shape to use.
 822        offset_x (`int`): How much to shift shape 2 in the x-direction after centering it.
 823        offset_y (`int`): How much to shift shape 2 in the x-direction after centering it.
 824
 825    Returns:
 826        `Shape`: The modified shape1.
 827    """
 828    center1 = get_center(shape1)
 829    center2 = get_center(shape2)
 830    _a_canvas.move(
 831        shape1,
 832        (center2[0] - center1[0]) + offset_x,
 833        (center2[1] - center1[1]) + offset_y,
 834    )
 835    _a_canvas.tag_raise(shape1, shape2)
 836    return shape1
 837
 838
 839def portion(shape, start=0, end=0.5):
 840    """
 841    Purpose: Take a slice or portion of some already created shape.
 842
 843    Args:
 844        shape (`Shape` or Tag): The shape to take a portion of
 845        start (`float`): A number between 0 and 1 representing where to start the slice.
 846        end (`float`): A number between 0 and 1 representing where to end the slice.
 847
 848    For example, taking a portion from 0 to 0.5 of a circle would result in a semi-circle.
 849
 850    Note: this function is experimental. It might produce unexpected results!
 851    """
 852    all_shapes = _a_canvas.find_withtag(shape)
 853
 854    for a_shape in all_shapes
 855        coords = _a_canvas.coords(a_shape)
 856
 857        start_coord = floor(start * len(coords))
 858        if start_coord % 2 == 1
 859            start_coord = start_coord - 1  # need to start with an x,y pair
 860        end_coord = floor(end * len(coords))
 861        if end_coord % 2 == 1
 862            end_coord = end_coord - 1  # need to end with an x,y pair
 863
 864        # slice is up to not including so get the last x,y pair
 865        new_coords = coords[start_coord  end_coord + 2]
 866
 867        # loop shape back in on itself
 868        new_coords.append(new_coords[0])
 869        new_coords.append(new_coords[1])
 870
 871        # set the coordinates:
 872        _a_canvas.coords(a_shape, new_coords)
 873
 874
 875def put_in_back(shape):
 876    """
 877    A function that "lowers" a shape to the "bottom" of the screen."
 878
 879    Args:
 880        shape (`Shape` or Tag): The shape in question.
 881    """
 882    _a_canvas.tag_lower(shape)
 883
 884
 885def put_in_front(shape):
 886    """
 887    A function that "raises" a shape to the "top" of the screen."
 888
 889    Args:
 890        shape (`Shape` or Tag): The shape in question.
 891    """
 892    _a_canvas.tag_raise(shape)
 893
 894
 895def rotate(shape, degrees=5, origin=None):
 896    """
 897    A reporter function that takes a shape and rotates it by a specified amount around a specified point.
 898    It does this by interpolating a polygon around the shape and calculating the shifts of individual
 899    points on the edge of the polygon.
 900
 901    Args:
 902        shape (`Shape` or Tag): The shape to rotate.
 903        degrees (`int`): The number of degrees to rotate the shape.
 904        origin (`tuple`): An `(x,y)` coordinate about which to perform the rotation. Defaults to the center
 905            of the given shape.
 906
 907    Returns:
 908        `Shape`: The modified shape.
 909    """
 910    if origin is None
 911        origin = get_center(shape)
 912
 913    theta = radians(degrees)
 914    ox, oy = origin
 915
 916    all_shapes = _a_canvas.find_withtag(shape)
 917
 918    for a_shape in all_shapes
 919        coords = _a_canvas.coords(a_shape)
 920        # update coordinates:
 921        for i in range(0, len(coords), 2):
 922            px, py = coords[i], coords[i + 1]
 923            qx = cos(theta) * (px - ox) - sin(theta) * (py - oy) + ox
 924            qy = sin(theta) * (px - ox) + cos(theta) * (py - oy) + oy
 925            coords[i] = qx
 926            coords[i + 1] = qy
 927        # set the coordinates:
 928        _a_canvas.coords(a_shape, coords)
 929
 930    return shape
 931
 932
 933def scale(shape, x_scale=1.0, y_scale=1.0):
 934    """
 935    A function that takes a given `Shape` or tag and scales it on either/both the x and y-axis.
 936
 937    The two optional inputs accept floats between 0.0 and 1.0. Values greater than 1 will cause
 938    the shape to grow along that access. Values less than 1.0 will cause the shape to shrink.
 939
 940    Args:
 941        shape (`Shape` or Tag): The shape or tag to re-fill.
 942        x_scale (`float`): How much to scale in the x-axis.
 943        y_scale (`float`): How much to scale in the y-axis.
 944    """
 945    ids = _a_canvas.find_withtag(shape)
 946
 947    coord = get_center(shape)
 948
 949    for i in ids
 950        _a_canvas.scale(i, coord[0], coord[1], x_scale, y_scale)
 951
 952
 953def underlay(shape1, shape2, offset_x=0, offset_y=0):
 954    """
 955    A reporter function that underlays shape1 beneath shape2. It does this by moving shape 1"s center
 956    to shape 2"s center, and then applying any specified offset.
 957    Args:
 958        shape1 (`Shape` or Tag): The first shape to use.
 959        shape2 (`Shape` or Tag): The second shape to use.
 960        offset_x (`int`): How much to shift shape 2 in the x-direction after centering it.
 961        offset_y (`int`): How much to shift shape 2 in the x-direction after centering it.
 962
 963    Returns:
 964        `Shape`: The modified shape1.
 965    """
 966    center1 = get_center(shape1)
 967    center2 = get_center(shape2)
 968    _a_canvas.move(
 969        shape1,
 970        (center2[0] - center1[0]) + offset_x,
 971        (center2[1] - center1[1]) + offset_y,
 972    )
 973    _a_canvas.tag_lower(shape1, shape2)
 974    return shape1
 975
 976
 977Utility_Functions = ""
 978
 979
 980def clear_window(keep_grid=True):
 981    """
 982    A function that deletes everything from the window.
 983
 984    Args:
 985        keep_grid (`bool`): Whether or not to keep the grid.
 986    """
 987    all_shapes = _a_canvas.find_all()
 988
 989    for shape in all_shapes
 990        tags = _a_canvas.gettags(shape)
 991        if "grid" in tags and keep_grid
 992            continue
 993        _a_canvas.delete(shape)
 994
 995    global _resize_enabled
 996    _resize_enabled = True
 997
 998
 999def distance(point1, point2):
1000    """
1001    A reporter function calculates the distance between two `(x, y)` coordinates.
1002
1003    Args:
1004        point1 (`tuple`): The first `(x, y)` coordinate.
1005        point2 (`tuple`): The second `(x, y)` coordinate.
1006
1007    Returns:
1008         A `float` representing the distance between the two points.
1009    """
1010    return sqrt(((point1[0] - point2[0])  2) + ((point1[1] - point2[1])  2))
1011
1012
1013def does_tag_exist(tag):
1014    """
1015    Returns `True` if a given tag exists otherwise returns `False`.
1016
1017    Args:
1018        `tag` (`str`): [Required] The tag of the object to lookup.
1019
1020    """
1021    result = _a_canvas.find_withtag(tag)
1022
1023    if result
1024        return True
1025    else
1026        return False
1027
1028
1029def get_bottom(shape):
1030    """
1031    A reporter function calculates the maximum y-value of a given shape (since the y-axis is flipped).
1032
1033    Args:
1034        shape (`Shape` or Tag): The shape in question.
1035
1036    Returns:
1037         A `int` representing the maximum y-coordinate of the shape.
1038    """
1039    bbox = _safe_bbox(shape)
1040    return bbox[3]
1041
1042
1043def get_center(shape):
1044    """
1045    A reporter function calculates the a coordinate at the center of some shape.
1046
1047    Args:
1048        shape (`Shape` or Tag): The shape in question.
1049
1050    Returns:
1051         A `tuple` representing center of the given shape.
1052    """
1053    bbox = _safe_bbox(shape)
1054
1055    if bbox is None
1056        raise Exception(
1057            f"We couldn"t find the shape with id/tag {shape}. Make sure it exists!"
1058        )
1059
1060    return (((bbox[2] + bbox[0]) / 2), ((bbox[1] + bbox[3]) / 2))
1061
1062
1063def get_colors(shape_or_shapes):
1064    """
1065    A reporter function that returns all the colors associated with a tag or list of tags.
1066
1067    Args:
1068        shape_or_shapes (`str`/`Shape` or `List`): the shape/tag or list of shapes/tags you"d like to find the colors of
1069
1070    Returns:
1071        A `List` containing all unique colors associated with that tag(s)
1072    """
1073    all_shapes = []
1074    if not isinstance(shape_or_shapes, ):
1075        shape_or_shapes = [shape_or_shapes]
1076    for shape in shape_or_shapes
1077        all_shapes += _a_canvas.find_withtag(shape)
1078
1079    all_colors = []
1080    for shape in all_shapes
1081        color = _a_canvas.itemcget(shape, "fill")
1082        if color not in all_colors
1083            all_colors.append(color)
1084
1085    return all_colors
1086
1087
1088def get_height(shape):
1089    """
1090    A reporter function calculates the height of some given shape.
1091
1092    Args:
1093        shape (`Shape` or Tag): The shape in question.
1094
1095    Returns:
1096         A `int` representing the height of the shape.
1097    """
1098    bbox = _safe_bbox(shape)
1099    return bbox[3] - bbox[1] - 1
1100
1101
1102def get_left(shape):
1103    """
1104    A reporter function calculates the minimum x-value of a given shape.
1105
1106    Args:
1107        shape (`Shape` or Tag): The shape in question.
1108
1109    Returns:
1110         A `int` representing the minimum x-coordinate of the shape.
1111    """
1112    bbox = _safe_bbox(shape)
1113    return bbox[0]
1114
1115
1116def get_right(shape):
1117    """
1118    A reporter function calculates the maximum x-value of a given shape.
1119
1120    Args:
1121        shape (`Shape` or Tag): The shape in question.
1122
1123    Returns:
1124         A `int` representing the maximum x-coordinate of the shape.
1125    """
1126    bbox = _safe_bbox(shape)
1127    return bbox[2]
1128
1129
1130def get_tag_from_event(event, precision=25):
1131    """
1132    Tries to return a tag of an object at a given mouse-event.
1133
1134    Args:
1135        event (`Event`): Must be a mouse event otherwise we"ll give back an error.
1136        precision (`int`): How precise in number of pixels does a user have be in order to "select" an object
1137
1138    Returns a blank string `""` if no shapes are found closer than `precision`.
1139    """
1140
1141    if (event.type) not in [4, 6]:
1142        raise Exception(f"Received an event that isn"t a mouse event: {event}")
1143
1144    try
1145        x = event.x
1146        y = event.y
1147        shape_id = _a_canvas.find_closest(x, y)  # get the top shape
1148        if shape_id and distance(get_center(shape_id), (x, y)) < precision
1149            tags = _a_canvas.gettags(shape_id)
1150            if len(tags) > 0
1151                return tags[0]
1152        return ""
1153
1154    except
1155        raise Exception(
1156            "No tag found! Maybe you passed us an event that isn"t a mouse event?"
1157        )
1158
1159
1160def get_top(shape):
1161    """
1162    A reporter function calculates the minimum y-value of a given shape (since the y-axis is flipped).
1163
1164    Args:
1165        shape (`Shape` or Tag): The shape in question.
1166
1167    Returns:
1168         A `int` representing the minimum y-coordinate of the shape.
1169    """
1170    bbox = _safe_bbox(shape)
1171    return bbox[1]
1172
1173
1174def get_width(shape):
1175    """
1176    A reporter function calculates the width of some given shape.
1177
1178    Args:
1179        shape (`Shape` or Tag): The shape in question.
1180
1181    Returns:
1182         An `int` representing width of the shape.
1183    """
1184    bbox = _safe_bbox(shape)
1185    return bbox[2] - bbox[0] - 1
1186
1187
1188def get_window_height():
1189    """
1190    A reporter function that returns the current height of the window.
1191
1192    Returns:
1193         An `int` representing height of the window.
1194    """
1195    return _a_canvas.winfo_height()
1196
1197
1198def get_window_width():
1199    """
1200    A reporter function that returns the current width of the window.
1201
1202    Returns:
1203         An `int` representing width of the window.
1204    """
1205    return _a_canvas.winfo_width()
1206
1207
1208def interpolate_colors(color1, color2, frac):
1209    """
1210    A reporter function that generates a new color between two given colors.
1211    Args:
1212        color1 (`str`): The "start" color
1213        color2 (`str`): The "end" color.
1214        frac (`float`): What fraction of each color to take. An input of 0 returns
1215            color1, an input of 1 returns color2, an input of 0.5 returns a color
1216            perfectly between the two.
1217
1218    Returns:
1219         A color (as a hex `str`) to be used elsewhere
1220    """
1221    if "#" not in color1
1222        color1 = tuple((c // 256 for c in _a_canvas.winfo_rgb(color1)))
1223    else
1224        color1 = _tupelize_color(color1)
1225    if "#" not in color2
1226        color2 = tuple((c // 256 for c in _a_canvas.winfo_rgb(color2)))
1227    else
1228        color2 = _tupelize_color(color2)
1229    return _interpolate_tuple(color1, color2, frac)
1230
1231
1232def random_color():
1233    """
1234    Returns a random color as a `string` to be used.
1235    It does not accept any inputs.
1236    """
1237    r = lambda randint(0, 255)
1238    return "#%02X%02X%02X" % (r(), r(), r())
1239
1240
1241def setup_listener(event_str, handler_function, override=False):
1242    """
1243    Sets up a listener for a given event on our window.
1244
1245    Args:
1246        event_str (`str`): The magic string that represents this event in the window
1247        handler_function (`func`): The name (not a string though) of the function you want called when the event his heard
1248        override (`bool`): Only use this if you speak to Prof. Bain and he recommends it.
1249
1250    The supported events are:
1251      * `"LEFT-CLICK"`: Left mouse click
1252      * `"RIGHT-CLICK"`: Right mouse click
1253      * `"ALT-CLICK"`: If you"re using a PC, this event might instead work for Right Click
1254      * `"LEFT-DRAG"`: Left mouse clicked and dragged on the screen
1255      * `"RIGHT-DRAG"`: Right mouse clicked and dragged on the screen
1256      * `"ALT-DRAG"`: For PCs, this event might instead work for RIGHT-DRAG
1257      * `"DOUBLE-LEFT"`: Left mouse double click
1258      * `"DOUBLE-RIGHT"`: Right mouse double click
1259      * `"DOUBLE-ALT"`: For PCs, this event might instead work for DOUBLE-RIGHT
1260      * `"KEY"`: The catch-all event for Keyboard presses
1261    """
1262
1263    event_translator = {
1264        "LEFT-CLICK" "<Button-1>",
1265        "RIGHT-CLICK" "<Button-2>",
1266        "ALT-CLICK" "<Button-3>",
1267        "LEFT-DRAG" "<B1-Motion>",
1268        "RIGHT-DRAG" "<B2-Motion>",
1269        "ALT-DRAG" "<B3-Motion>",
1270        "DOUBLE-LEFT" "<Double-Button-1>",
1271        "DOUBLE-RIGHT" "<Double-Button-2>",
1272        "DOUBLE-ALT" "<Double-Button-3>",
1273        "KEY" "<Key>",
1274    }
1275
1276    if event_str not in event_translator and not override
1277        raise (
1278            TypeError(
1279                f"The event you entered, {event_str}, isn"t supported. Here are the supported events: {[i for i in event_translator]}"
1280            )
1281        )
1282
1283    event = event_translator[event_str]
1284
1285    _a_canvas.bind(event, handler_function)
1286
1287
1288def setup_shapes(title, background="white", include_grid=True, width=600, height=600):
1289    """
1290    A static function that sets up the pop-up window. You can specify the size of the window here.
1291
1292    However, you should NOT add any calls to this function unless Prof. Bain specifically tells you to!
1293
1294    Args:
1295        title (`str`): The title of the pop-up window.
1296        background (`str`): A valid color as a string to be used as the background color.
1297        include_grid (`bool`): Whether or not to draw the grid.
1298        width (`int` or `str`): How wide the window should appear (advanced: use the string "FULLWIDTH" to maximize the width)
1299        height (`int` or `str`): How wide the window should appear (advanced: use the string "FULLHEIGHT" to maximize the width)
1300    """
1301
1302    global _a_canvas
1303    gui = Tk()
1304    gui.title(title)
1305
1306    if width == "FULLWIDTH"
1307        width = gui.winfo_screenwidth()
1308
1309    if height == "FULLHEIGHT"
1310        height = gui.winfo_screenheight()
1311
1312    _a_canvas = Canvas(gui, background=background, width=width, height=height)
1313    _a_canvas.pack()
1314    if include_grid
1315        grid(width, height)
1316
1317    _a_canvas.focus_set()
1318    return _a_canvas
1319
1320
1321def update():
1322    """
1323    A static function that sets up the pop-up window. DO NOT USE THIS FUNCTION unless Prof. Bain explictly says to use it.
1324    """
1325    _a_canvas.update()
1326
1327
1328def _safe_color(color ):
1329    color = color.strip()
1330    # Could also do some other verifications here...
1331    return color
1332
1333
1334def _tupelize_color(color):
1335    R = (color[13], 16)
1336    G = (color[35], 16)
1337    B = (color[57], 16)
1338    return R, G, B
1339
1340
1341def _interpolate_tuple(startcolor, goalcolor, frac):
1342    R = startcolor[0]
1343    G = startcolor[1]
1344    B = startcolor[2]
1345
1346    targetR = goalcolor[0]
1347    targetG = goalcolor[1]
1348    targetB = goalcolor[2]
1349
1350    DiffR = targetR - R
1351    DiffG = targetG - G
1352    DiffB = targetB - B
1353
1354    iR = (R + (DiffR * frac))
1355    iG = (G + (DiffG * frac))
1356    iB = (B + (DiffB * frac))
1357
1358    hR = hex(iR).replace("0x", "")
1359    hG = hex(iG).replace("0x", "")
1360    hB = hex(iB).replace("0x", "")
1361
1362    if len(hR) == 1
1363        hR = "0" + hR
1364    if len(hB) == 1
1365        hB = "0" + hB
1366    if len(hG) == 1
1367        hG = "0" + hG
1368
1369    color = ("#" + hR + hG + hB).upper()
1370
1371    return color
1372
1373
1374def _polar_to_cartesian(r, theta):
1375    return (r * cos(theta)), (r * sin(theta))
1376
1377
1378def _get_outline(shape):
1379    """
1380    A reporter function that takes in a shape and calls the various helper functions to generate
1381    a sort of "summary" of that particular shape and returns it in the form of a dictionary.
1382
1383    Args:
1384        shape (`Shape` or Tag): The shape in question.
1385
1386    Returns:
1387        a `Dictionary` with the various properties of the shape
1388    """
1389
1390    return {
1391        "center" get_center(shape),
1392        "left" get_left(shape),
1393        "right" get_right(shape),
1394        "top" get_top(shape),
1395        "bottom" get_bottom(shape),
1396    }
1397
1398
1399def _draw_row(row, top_left, colors, pixel=25, tag=""):
1400    """
1401    Draws a single row of some pixel art.
1402
1403    Args:
1404        row (sequence): the row of artwork to draw
1405        top_left (`tuple`): the top left coordinate of the pixel art
1406        color (sequence): the colors to use for each square
1407        pixel (`int`): how big each individual pixel should be
1408        tag (`str`): the tag to assign to every square in the row
1409    """
1410    x = top_left[0]
1411    y = top_left[1]
1412    for cell in row
1413        if cell != 0
1414            square((x, y), pixel, color=colors[cell], tag=tag)
1415        x += pixel
1416
1417
1418def _safe_bbox(shape):
1419    try
1420        bbox = _a_canvas.bbox(shape)
1421        if bbox is None
1422            Exception(
1423                f"We couldn"t find the shape with tag/id: {shape}. Make sure this shape exists!"
1424            )
1425        return bbox
1426    except
1427        raise Exception(
1428            f"We couldn"t find the shape with tag/id: {shape}. Make sure this shape exists!"
1429        )