cs110_t3_shapes

  1### IGNORE EVERYTHING THAT STARTS WITH A _
  2from random import randint
  3from math import sqrt, pi, radians, sin, cos
  4
  5__docformat__ = "google"
  6
  7_a_canvas = None
  8
  9def rectangle(top_left=(0, 0), width=25, height=50, color="hotpink", outline="", tag="", **kwargs):
 10    """
 11    A reporter function that draws a rectangle.
 12    Args:
 13        top_left (`tuple`): A coordinate representing the top left-hand corner of the shape.
 14        width (`int`): How wide to draw the shape.
 15        height (`int`): How tall to draw the shape.
 16        color (`str`): What color to draw the shape.
 17        outline (`str`): What color should the border of the shape be.
 18        tag (`str`): The tag to assign to the shape.
 19
 20    Returns:
 21         `Shape`: The rectangle that was created.
 22    """      
 23    point_0 = top_left
 24    point_1 = (top_left[0] + width, top_left[1])
 25    point_2 = (top_left[0] + width, top_left[1] + height)
 26    point_3 = (top_left[0], top_left[1] + height)
 27    return _a_canvas.create_polygon(
 28        point_0, point_1, point_2, point_3, fill=color, tags=tag, **kwargs
 29    )
 30
 31
 32def square(top_left=(0, 0), size=25, color="hotpink", outline="", tag="", **kwargs):
 33    """
 34    A reporter function that draws a square.
 35    Args:
 36        top_left (`tuple`): A coordinate representing the top left-hand corner of the shape.
 37        size (`int`): How big to draw the shape.
 38        color (`str`): What color to draw the shape.
 39        outline (`str`): What color should the border of the shape be.
 40        tag (`str`): The tag to assign to the shape.
 41
 42    Returns:
 43         `Shape`: The square that was created.
 44    """
 45    return rectangle(top_left=top_left, width=size, height=size, color=color, tag=tag, **kwargs)
 46
 47
 48def oval(center=(0, 0), radius_x=25, radius_y=50, color="hotpink", outline="", tag="", **kwargs):
 49    """
 50    A reporter function that draws an oval.
 51    Args:
 52        center (`tuple`): A coordinate representing the center of the shape.
 53        radius_x (`int`): Specifies the oval's radius on the x-axis.
 54        radius_y (`int`): Specifies the oval's radius on the y-axis.
 55        color (`str`): What color to draw the shape.
 56        outline (`str`): What color should the border of the shape be.
 57        tag (`str`): The tag to assign to the shape.
 58
 59    Returns:
 60         `Shape`: The oval that was created.
 61    """
 62    x = center[0]
 63    y = center[1]
 64    x0, y0, x1, y1 = (x - radius_x, y - radius_y, x + radius_x, y + radius_y)
 65    steps = 100
 66    # major and minor axes
 67    a = (x1 - x0) / 2.0
 68    b = (y1 - y0) / 2.0
 69    # center
 70    xc = x0 + a
 71    yc = y0 + b
 72    point_list = []
 73    # create the oval as a list of points
 74    for i in range(steps):
 75        # Calculate the angle for this step
 76        theta = (pi * 2) * (float(i) / steps)
 77        x = a * cos(theta)
 78        y = b * sin(theta)
 79        point_list.append(round(x + xc))
 80        point_list.append(round(y + yc))
 81
 82    return _a_canvas.create_polygon(point_list, fill=color, tags=tag, **kwargs)
 83
 84
 85def circle(center=(0, 0), radius=25, color="hotpink", outline="", tag="", **kwargs):
 86    """
 87    A reporter function that draws a circle.
 88    Args:
 89        center (`tuple`): A coordinate representing the center of the shape.
 90        radius (`int`): Specifies the circle's radius.
 91        color (`str`): What color to draw the shape.
 92        outline (`str`): What color should the border of the shape be.
 93        tag (`str`): The tag to assign to the shape.
 94
 95    Returns:
 96         `Shape`: The circle that was created.
 97    """
 98    return oval(center=center, radius_x=radius, radius_y=radius, color=color, tag=tag, **kwargs)
 99
100
101def triangle(
102    bottom_center=(0, 0), width=25, top_shift=0, height=0, color="hotpink", outline="", tag="", **kwargs
103):
104    """
105    A reporter function that draws a triangle.
106    Args:
107        bottom_center (`tuple`): A coordinate representing the bottom center of the shape.
108        width (`int`): Specifies the width of the base of the triangle.
109        top_shift (`int`): Specifies the how far to the left or right to shift the top of 
110            the triangle from the bottom center.
111        height (`int`): Specifies the triangle's height.
112        color (`str`): What color to draw the shape.
113        outline (`str`): What color should the border of the shape be.
114        tag (`str`): The tag to assign to the shape.
115
116    Returns:
117         `Shape`: The triangle that was created.
118    """
119    if height == 0:
120        height = width * sqrt(3) / 2
121    point_0 = (bottom_center[0] - width / 2, bottom_center[1])
122    point_1 = (bottom_center[0] + width / 2, bottom_center[1])
123    point_2 = (bottom_center[0] + top_shift, bottom_center[1] - height)
124
125    return _a_canvas.create_polygon(point_0, point_1, point_2, fill=color, tags=tag, **kwargs)
126
127
128def line(points=[], curvy=False, color="hotpink", tag="", **kwargs):
129    """
130    A reporter function that draws a line given a list of points.
131    Args:
132        points (`list`): The points that define the line; this should be a list of tuples (coordinates).
133        curvy (`bool`): Makes a curvy line instead.
134        color (`str`): What color to make the shape.
135        tag (`str`): The tag to assign to the shape.
136
137    Returns:
138        `Shape`: The line that was created.
139    """
140    return _a_canvas.create_line(points, fill=color, smooth=curvy, tags=tag, **kwargs)
141
142
143def arc(points=[], width=5, color="hotpink", line_steps=15, tag="", **kwargs):
144    """
145    A reporter function that draws an arc ("curve") given a list of points.
146    Args:
147        points (`list`): The points outlining the curve; this should be a list of tuples (coordinates).
148            Make sure to give it at least 3 (x,y) coordinates that aren't a straight line!
149        color (`str`): What color to make the shape.
150        tag (`str`): The tag to assign to the shape.
151
152    Returns:
153        `Shape`: The arc that was created.
154    """
155    return _a_canvas.create_line(
156        points,  
157        width=width,
158        fill=color,
159        splinesteps=line_steps,
160        smooth=True,
161        tags=tag,
162        **kwargs
163    )
164
165
166def star(center=(0, 0), radius=50, color="hotpink", outer_radius=75, points=5, outline="", tag="", **kwargs):
167    """
168    A reporter function that draws a star.
169    Args:
170        center (`tuple`): A coordinate representing the center of the shape.
171        radius (`int`): Specifies the radius of the inside part of the star.
172        color (`str`): Specifies the color of the star.
173        outer_radius (`int`): Specifies the radius of the outside part of the star.
174        points (`int`): Specifies the number of points for the star.
175        outline (`str`): What color should the border of the shape be.
176        tag (`str`): The tag to assign to the shape.
177
178    Returns:
179         `Shape`: The star that was created.
180    """
181    arc_segment = 360 / points
182    vertices = []
183    for i in range(points):
184        inner_point = (
185            radius * cos(radians(arc_segment * i)) + center[0],
186            -1 * radius * sin(radians(arc_segment * i)) + center[1],
187        )
188        vertices.append(inner_point)
189        outer_point = (
190            outer_radius * cos(radians(arc_segment * i + arc_segment / 2)) + center[0],
191            -1 * outer_radius * sin(radians(arc_segment * i + arc_segment / 2))
192            + center[1],
193        )
194        vertices.append(outer_point)
195    return polygon(vertices, color=color, tag=tag, **kwargs)
196
197def polygon(points=[], color="hotpink", outline="", tag="", **kwargs):
198    """
199    A reporter function that draws a polygon given a list of points.
200    Args:
201        points (`list`): The points outlining the polygon; this should be a list of tuples (coordinates).
202            defaults to an empty list.
203        outline (`str`): What color should the border of the shape be.
204        color (`str`): What color to make the shape.
205
206    Returns:
207        `Shape`: The polygon that was created.
208   """
209    return _a_canvas.create_polygon(points, fill=color, tags=tag, **kwargs)
210
211def _polar_to_cartesian(r, theta):
212    return int(r*cos(theta)), int(r*sin(theta))
213
214def spiral(center=(0, 0), width=100, roughness=0.01, start=0, spirals=5, line_width=1, **kwargs):
215    """
216    A reporter function that draws a spiral.
217    Args:
218        center (`tuple`): A coordinate representing the center of the shape.
219        width (`int`): Specifies the total width of the spiral.
220        roughness (`float`): Controls how spiral-y the shape is (lower is less spiral-y)
221        start (`int`): Where on the spiral to start drawing.
222        spirals (`int`): How many loops to draw.
223        line_width (`int`): How wide for the line to be drawn.
224        tag (`str`): The tag to assign to the shape.
225
226    Returns:
227         `Shape`: The spiral that was created.
228    """
229    theta = 0.0
230    r = start
231    all_points = []
232    prev_pos = _polar_to_cartesian(r, theta)
233    distance = width / 4 / pi / spirals 
234    all_points.append((prev_pos[0] + center[0], prev_pos[1] + center[1]))
235    while theta < 2 * spirals * pi:
236        theta += roughness
237        r = start + distance*theta
238        pos = _polar_to_cartesian(r, theta)
239        all_points.append((pos[0] + center[0], pos[1] + center[1]))
240
241    return arc(points=all_points, width=line_width, **kwargs)
242
243def move(shape, x_shift=0, y_shift=0):
244    """
245    Purpose: Move the x and y position of all shapes that have been tagged
246    with the tag argument
247    Args:
248        shape (tag or id): the shape (or shapes) to move
249        x_shift (`int`; optional): amount to move in the x direction
250        y_shift (`int`; optional): amount to move in the y direction
251    """
252    shape_ids = _a_canvas.find_withtag(shape)
253    for id in shape_ids:
254        _a_canvas.move(id,
255                        x_shift,
256                        y_shift)
257
258def put_in_front(shape):
259    """
260    A function that "raises" a shape to the "top" of the screen."
261
262    Args:
263        shape (tag or id): The shape to raise.
264    """
265    _a_canvas.tag_raise(shape)
266
267def put_in_back(shape):
268    """
269    A function that "lowers" a shape to the "bottom" of the screen."
270
271    Args:
272        shape (tag or id): The shape to raise.
273    """
274    _a_canvas.tag_lower(shape)
275
276def overlay(shape1, shape2, offset_x=0, offset_y=0):
277    """
278    A reporter function that overlays shape1 onto shape2. It does this by moving shape 1's center
279    to shape 2's center, and then applying any specified offset.
280    Args:
281        shape1 (tag or id): The first shape to use.
282        shape2 (tag or id): The second shape to use.
283        offset_x (`int`): How much to shift shape 2 in the x-direction after centering it.
284        offset_y (`int`): How much to shift shape 2 in the x-direction after centering it.
285        tag (`str`): The tag to assign to the shape.
286
287    Returns:
288        `Shape`: The modified shape1.
289   """
290    center1 = get_center(shape1)
291    center2 = get_center(shape2)
292    _a_canvas.move(
293        shape1,
294        (center2[0] - center1[0]) + offset_x,
295        (center2[1] - center1[1]) + offset_y,
296    )
297    _a_canvas.tag_raise(shape1, shape2)
298    return shape1
299
300
301def underlay(shape1, shape2, offset_x=0, offset_y=0):
302    """
303    A reporter function that underlays shape1 beneath shape2. It does this by moving shape 1's center
304    to shape 2's center, and then applying any specified offset.
305    Args:
306        shape1 (tag or id): The first shape to use.
307        shape2 (tag or id): The second shape to use.
308        offset_x (`int`): How much to shift shape 2 in the x-direction after centering it.
309        offset_y (`int`): How much to shift shape 2 in the x-direction after centering it.
310
311    Returns:
312        `Shape`: The modified shape1.
313   """
314    center1 = get_center(shape1)
315    center2 = get_center(shape2)
316    _a_canvas.move(
317        shape1,
318        (center2[0] - center1[0]) + offset_x,
319        (center2[1] - center1[1]) + offset_y,
320    )
321    _a_canvas.tag_lower(shape1, shape2)
322    return shape1
323
324
325def above(shape1, shape2, offset_x=0, offset_y=0):
326    """
327    A reporter function that places shape1 above shape2 (vertically). It does this by moving shape 1's center
328    to shape 2's center, moving shape 1 in the y-direction the exact height of shape 2, and then applying any
329    specified offset.
330
331    Args:
332        shape1 (tag or id): The first shape to use.
333        shape2 (tag or id): The second shape to use.
334        offset_x (`int`): How much to shift shape 2 in the x-direction after moving it.
335        offset_y (`int`): How much to shift shape 2 in the x-direction after moving it.
336
337    Returns:
338        `Shape`: The modified shape1.  
339    """
340    overlay(shape1, shape2)
341    _a_canvas.move(
342        shape1,
343        0 + offset_x,
344        -1 * (get_height(shape2) + get_height(shape1)) / 2 + offset_y,
345    )
346    return shape1
347
348
349def beside(shape1, shape2, offset_x=0, offset_y=0):
350    """
351    A reporter function that places shape1 beside shape2 (horizontally). It does this by moving shape 1's center
352    to shape 2's center, moving shape 1 in the x-direction the exact width of shape 2, and then applying any
353    specified offset.
354
355    Args:
356        shape1 (tag or id): The first shape to use.
357        shape2 (tag or id): The second shape to use.
358        offset_x (`int`): How much to shift shape 2 in the x-direction after moving it.
359        offset_y (`int`): How much to shift shape 2 in the x-direction after moving it.
360
361    Returns:
362        `Shape`: The modified shape1.  
363    """
364    overlay(shape1, shape2)
365    _a_canvas.move(
366        shape1,
367        (get_width(shape2) + get_width(shape1)) / 2 + offset_x,
368        0 + offset_y,
369    )
370    return shape1
371
372
373def below(shape1, shape2, offset_x=0, offset_y=0):
374    """
375    A reporter function that places shape1 below shape2 (vertically). It does this by moving shape 1's center
376    to shape 2's center, moving shape 1 in the y-direction the exact height of shape 2, and then applying any
377    specified offset.
378
379    Args:
380        shape1 (tag or id): The first shape to use.
381        shape2 (tag or id): The second shape to use.
382        offset_x (`int`): How much to shift shape 2 in the x-direction after moving it.
383        offset_y (`int`): How much to shift shape 2 in the x-direction after moving it.
384
385    Returns:
386        `Shape`: The modified shape1.  
387    """
388    overlay(shape1, shape2)
389    _a_canvas.move(
390        shape1,
391        0 + offset_x,
392        (get_height(shape2) + get_height(shape1)) / 2 + offset_y,
393    )
394    return shape1
395
396def delete(shape):
397    """
398    A function that deletes a shape from our screen.
399
400    Args:
401        shape (tag or id): The shape to delete.
402    """
403    _a_canvas.delete(shape)
404
405def duplicate(shape, color=None):
406    """
407    A reporter function that perfectly copies a shape and returns that copy.
408
409    Args:
410        shape (tag or id): The shape to duplicate.
411        color (`str`): A new color to use with the duplicated shape.
412
413    Returns:
414        `Shape`: The new duplicated shape.  
415    """
416    shape_type = _a_canvas.type(shape)
417    shape_config = _a_canvas.itemconfig(shape)
418    shape_coords = _a_canvas.coords(shape)
419    the_copy = None
420    if shape_type == "polygon":
421        new_config = {key: shape_config[key][-1] for key in shape_config.keys()}
422        if color != None:
423            new_config["fill"] = color
424        the_copy = _a_canvas.create_polygon(shape_coords, **new_config)
425        return the_copy
426
427def mirror(shape):
428    """
429    A reporter function that takes a shape and flips it across its vertical
430    axis, returning the tag or ID of the modified shape.
431        
432    Args:
433        shape (tag or id): The shape in question.
434
435    Returns:
436        The modified shape.
437    """
438    center = get_center(shape)[0]
439    shape_ids = _a_canvas.find_withtag(shape)
440    for shape_id in shape_ids:
441        flipped_coordinates = []
442        shape_coords = _a_canvas.coords(shape_id)
443        counter = 0
444        for num in shape_coords:
445            if counter % 2 == 0:
446                if num < center:
447                    flipped_coordinates.append(num + 2 * (center - num))
448                elif num > center:
449                    flipped_coordinates.append(num - 2 * (num - center))
450                else:
451                    flipped_coordinates.append(num)
452            else:
453                flipped_coordinates.append(num)
454            counter += 1
455        _a_canvas.coords(shape_id, flipped_coordinates)
456
457def rotate(shape, degrees=5, origin=None):
458    """
459    A reporter function that takes a shape and rotates it by a specified amount around a specified point.
460    It does this by interpolating a polygon around the shape and calculating the shifts of individual
461    points on the edge of the polygon.
462
463    Args:
464        shape (tag or id): The shape to rotate.
465        degrees (`int`): The number of degrees to rotate the shape.
466        origin (`tuple`): An `(x,y)` coordinate about which to perform the rotation. Defaults to the center
467            of the given shape.
468
469    Returns:
470        `Shape`: The modified shape.  
471    """
472    if origin is None:
473        origin = get_center(shape)
474
475    theta = radians(degrees)
476    ox, oy = origin
477
478    all_shapes = _a_canvas.find_withtag(shape)
479
480    for a_shape in all_shapes:
481        coords = _a_canvas.coords(a_shape)
482        # update coordinates:
483        for i in range(0, len(coords), 2):
484            px, py = coords[i], coords[i + 1]
485            qx = cos(theta) * (px - ox) - sin(theta) * (py - oy) + ox
486            qy = sin(theta) * (px - ox) + cos(theta) * (py - oy) + oy
487            coords[i] = qx
488            coords[i + 1] = qy
489        # set the coordinates:
490        _a_canvas.coords(a_shape, coords)
491
492    return shape 
493
494def distance(point1, point2):
495    """
496    A reporter function calculates the distance between two `(x, y)` coordinates.
497          
498    Args:
499        point1 (`tuple`): The first `(x, y)` coordinate.
500        point2 (`tuple`): The second `(x, y)` coordinate.
501
502    Returns:
503         A `float` representing the distance between the two points.
504    """
505    return sqrt(((point1[0] - point2[0]) ** 2) + ((point1[1] - point2[1]) ** 2))
506
507def update_color(shape, color):
508    '''
509    Change the fill color of a tagged object.
510
511    Args:
512        shape (tag or id): The tag of the object to re-fill.
513        color (`str`): A color name or hex code to re-fill with.
514    '''
515    ids = _a_canvas.find_withtag(shape)
516    for id in ids:
517        _a_canvas.itemconfig(id, fill=color)
518
519def interpolate_colors(color1, color2, frac):
520    """
521    A reporter function that generates a new color between two given colors.
522    Args:
523        color1 (`str`): The path of the file to wrap
524        color2 (`str`): The path of the file to wrap
525        frac (`float`): What fraction of each color to take. An input of 0 returns
526            color1, an input of 1 returns color2, an input of 0.5 returns a color
527            perfectly between the two.
528
529    Returns:
530         A color (as a hex `str`) to be used elsewhere
531   """
532    if "#" not in color1:
533        color1 = tuple((c // 256 for c in _a_canvas.winfo_rgb(color1)))
534    else:
535        color1 = _tupelize_color(color1)
536    if "#" not in color2:
537        color2 = tuple((c // 256 for c in _a_canvas.winfo_rgb(color2)))
538    else:
539        color2 = _tupelize_color(color2)
540    return _interpolate_tuple(color1, color2, frac)
541
542def get_center(shape):
543    """
544    A reporter function calculates the a coordinate at the center of some shape.
545        
546    Args:
547        shape (tag or id): The shape in question.
548
549    Returns:
550         A `tuple` representing center of the given shape.
551    """
552    bbox = _safe_bbox(shape)
553
554    if bbox is None:
555        raise Exception(f"We couldn't find the shape with id/tag {shape}. Make sure it exists!")
556
557    return (((bbox[2] + bbox[0]) / 2), ((bbox[1] + bbox[3]) / 2))
558
559
560def get_top(shape):
561    """
562    A reporter function calculates the **minimum** y-value of a given shape (since the y-axis is flipped).
563
564    Args:
565        shape (tag or id): The shape in question.
566
567    Returns:
568         A `int` representing the minimum y-coordinate of the shape.
569    """
570    bbox = _safe_bbox(shape)
571    return bbox[1]
572
573
574def get_bottom(shape):
575    """
576    A reporter function calculates the **maximum** y-value of a given shape (since the y-axis is flipped).
577    
578    Args:
579        shape (tag or id): The shape in question.
580
581    Returns:
582         A `int` representing the maximum y-coordinate of the shape.
583    """
584    bbox = _safe_bbox(shape)
585    return bbox[3]
586
587
588def get_left(shape):
589    """
590    A reporter function calculates the **minimum** x-value of a given shape.
591        
592    Args:
593        shape (tag or id): The shape in question.
594
595    Returns:
596         A `int` representing the minimum x-coordinate of the shape.
597    """
598    bbox = _safe_bbox(shape)
599    return bbox[0]
600
601
602def get_right(shape):
603    """
604    A reporter function calculates the **maximum** x-value of a given shape.
605        
606    Args:
607        shape (tag or id): The shape in question.
608
609    Returns:
610         A `int` representing the maximum x-coordinate of the shape.
611    """ 
612    bbox = _safe_bbox(shape)
613    return bbox[2]
614
615
616def get_height(shape):
617    """
618    A reporter function calculates the height of some given shape.
619        
620    Args:
621        shape (tag or id): The shape in question.
622
623    Returns:
624         A `int` representing the height of the shape.
625    """
626    bbox = _safe_bbox(shape)
627    return bbox[3] - bbox[1] - 1
628
629
630def get_width(shape):
631    """
632    A reporter function calculates the width of some given shape.
633        
634    Args:
635        shape (tag or id): The shape in question.
636
637    Returns:
638         An `int` representing width of the shape.
639    """
640    bbox = _safe_bbox(shape)
641    return bbox[2] - bbox[0] - 1
642
643def make_grid(c, w, h):
644    """
645    Draws a grid on a screen with intervals of 100.
646
647    Args:
648        w (`int`): The width of the grid to draw
649        h (`int`): The height of the grid to draw
650    """
651    interval = 100
652    # Creates all vertical lines at intervals of 100
653    for i in range(0, w, interval):
654        _a_canvas.create_line(i, 0, i, h, tag="grid_line")
655    # Creates all horizontal lines at intervals of 100
656    for i in range(0, h, interval):
657        _a_canvas.create_line(0, i, w, i, tag="grid_line")
658    # Creates axis labels
659    offset = 2
660    for y in range(0, h, interval):
661        for x in range(0, w, interval):
662            _a_canvas.create_oval(
663                x - offset, y - offset, x + offset, y + offset, fill="black"
664            )
665            _a_canvas.create_text(
666                x + offset,
667                y + offset,
668                text="({0}, {1})".format(x, y),
669                anchor="nw",
670                font=("Purisa", 8),
671            )
672
673def _safe_bbox(shape):
674    try:
675        bbox = _a_canvas.bbox(shape)
676        if bbox is None:
677            Exception(f"We couldn't find the shape with tag/id: {shape}. Make sure this shape exists!") 
678        return bbox
679    except:
680        raise Exception(f"We couldn't find the shape with tag/id: {shape}. Make sure this shape exists!") 
681
682def _tupelize_color(color):
683    R = int(color[1:3], 16)
684    G = int(color[3:5], 16)
685    B = int(color[5:7], 16)
686    return R, G, B
687
688
689def _interpolate_tuple(startcolor, goalcolor, frac):
690    R = startcolor[0]
691    G = startcolor[1]
692    B = startcolor[2]
693
694    targetR = goalcolor[0]
695    targetG = goalcolor[1]
696    targetB = goalcolor[2]
697
698    DiffR = targetR - R
699    DiffG = targetG - G
700    DiffB = targetB - B
701
702    iR = int(R + (DiffR * frac))
703    iG = int(G + (DiffG * frac))
704    iB = int(B + (DiffB * frac))
705
706    hR = hex(iR).replace("0x", "")
707    hG = hex(iG).replace("0x", "")
708    hB = hex(iB).replace("0x", "")
709
710    if len(hR) == 1:
711        hR = "0" + hR
712    if len(hB) == 1:
713        hB = "0" + hB
714    if len(hG) == 1:
715        hG = "0" + hG
716
717    color = ("#" + hR + hG + hB).upper()
718
719    return color
720
721def does_tag_exist(shape):
722    '''
723    Returns `True` if a given tag exists otherwise returns `False`.
724
725    Args:
726        shape (tag or id): [Required] The tag of the object to lookup.
727
728    '''
729    result = _a_canvas.find_withtag(shape)
730
731    if result:
732        return True
733    else:
734        return False
735
736def random_color():
737    '''
738    Returns a random color as a `string` to be used with `tkinter`.
739    It does not accept any inputs.
740    '''
741    r = lambda: randint(0,255)
742    return '#%02X%02X%02X' % (r(), r(), r())
743
744from tkinter import Tk, Canvas
745
746def setup_shapes(title, background="white", width=600, height=600):
747    """
748    A static function that sets up the pop-up window. **DO NOT USE THIS FUNCTION**.
749    """
750    global _a_canvas
751    gui = Tk()
752    gui.title(title)
753    _a_canvas = Canvas(gui, background=background, width=width, height=width)
754    _a_canvas.pack()
755    make_grid(_a_canvas, width, height)
756    return _a_canvas