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