I'm trying to generate an output of Sierpinski Triangle. I was wondering how to use the midpt function in the 2d point class to achieve this output?

Question

I have to generate the Sierpinski Triangle using a 2d point class and tkinter canvas.The midpt function is essentially going to take input from a randomly chosen vertex and the last plotted midpoint. You can choose any vertices to plot the first midpoint. The points also need to be instances of the 2d point class. I desperately need help because I can't seem to figure this out. Here is what the output is supposed to look like.

This is what I have done so far, but it is not using the 2d point class to generate the triangle.

import math
from fractions import Fraction
from random import randrange
from Tkinter import *
# the 2D point class
class Point(object):
    def __init__(self, x=0, y=0):
        self.x = x
        self.y = y

    # Mutators and Accessors
    @property
    def x(self):
        return self._x

    @x.setter
    def x(self, value):
        self._x = value

    @property
    def y(self):
        return self._y

    @y.setter
    def y(self, value):
        self._y = value

    # String function
    def __str__(self):
        floatX = float(str(self.x))
        floatY = float(str(self.y))
        return "({},{})".format(floatX, floatY)

    # Distance function
    def dist(self, other):
        distance = math.sqrt(((self.x - other.x)**2)+((self.y - other.y)**2))
        return "{}".format(distance)

    # Midpoint function
    def midpt(self, other):
        x0 = float(str(((self.x + other.x))))/2
        y0 = float(str(((self.y + other.y)/2)))
        return Point(x0, y0)

# the coordinate system class: (0,0) is in the top-left corner
# inherits from the Canvas class of Tkinter
class ChaosGame(Canvas):
    def __init__(self, master):
        Canvas.__init__(self, master, bg = "white")
        self.pack(fill = BOTH, expand = 1)

    def plotPoints(self, triangle, NumberPoints):
        x0, y0 = WIDTH / 2, HEIGHT / 2
        direction = center
        for i in range(NumberPoints):
            point = randrange(len(triangle))
            direction = triangle[point]
            x0 = (direction[0] + x0) / 2
            y0 = (direction[1] + y0) / 2
            color = direction[1]
            self.plot(x0, y0)
        self.plotV(5, 510)
        self.plotV(290, 5)
        self.plotV(590, 510)

    def plot(self, x, y):
        POINT_COLORS=["black"]
        RADIUS = 0
        color = POINT_COLORS
        self.create_oval(x, y, x+2, y+2, outline = color, fill = color)

    def plotV(self, x, y):
        POINT_COLORS=["red"]
        RADIUS = 3
        color = POINT_COLORS
        self.create_oval(x, y, x+RADIUS*2, y+RADIUS*2, outline = color, fill = color)

##########################################################
# ***DO NOT MODIFY OR REMOVE ANYTHING BELOW THIS POINT!***
# the default size of the canvas is 600x520
WIDTH = 600
HEIGHT = 520
# the number of points to plot
NumberPoints = 50000

# the vertices
A = (5, 510)
B = (290, 5)
C = (590, 510)
triangle = (A, B, C)
center = (WIDTH/2, HEIGHT/2)

# create the window
window = Tk()
window.geometry("{}x{}".format(WIDTH, HEIGHT))
window.title("2D Points...Plotted")
# create the chaos game as a Tkinter canvas inside the window
s = ChaosGame(window)
# plot some random points
s.plotPoints(triangle, NumberPoints)
# wait for the window to close
window.mainloop()

Answer 1

The problem was that you were duplicating the Point-based code in the midpt() method in your plotPoints() method, but for tuples instead of Points. Since the triangle is handed to us as a list of tuples, we convert that to a list of Points, and modify our plot() method to accept a Point, and run the whole plotPoints() method in terms of Points:

from random import choice
from Tkinter import *

class Point(object):
    ''' a 2D point class '''

    def __init__(self, x=0, y=0):
        self.x = float(x)
        self.y = float(y)

    # Mutators and Accessors
    @property
    def x(self):
        return self._x

    @x.setter
    def x(self, value):
        self._x = float(value)

    @property
    def y(self):
        return self._y

    @y.setter
    def y(self, value):
        self._y = float(value)

    # String function
    def __str__(self):
        return "({},{})".format(self.x, self.y)

    # Midpoint function
    def midpt(self, other):
        x0 = (self.x + other.x) / 2
        y0 = (self.y + other.y) / 2
        return Point(x0, y0)

class ChaosGame(Canvas):
    ''' Plotting class that inherits from Canvas class of Tkinter '''

    VERTEX_RADIUS = 3
    VERTEX_COLORS = ["red"]

    POINT_RADIUS = 1
    POINT_COLORS = ["black"]

    def __init__(self, master):
        Canvas.__init__(self, master, bg="white")
        self.pack(fill=BOTH, expand=1)

    def plotPoints(self, triangle, NumberPoints):
        point = Point(WIDTH / 2, HEIGHT / 2)

        deltoid = [Point(x, y) for x, y in triangle]  # tuples -> Points

        for _ in range(NumberPoints):
            point = point.midpt(choice(deltoid))
            self.plot(point)

        for vertex in deltoid:
            self.plotV(vertex)

    def plot(self, point):
        radius = self.POINT_RADIUS
        color = self.POINT_COLORS
        x, y = point.x, point.y

        self.create_oval(x, y, x + radius*2, y + radius*2, outline=color, fill=color)

    def plotV(self, vertex):
        radius = self.VERTEX_RADIUS
        color = self.VERTEX_COLORS
        x, y = vertex.x, vertex.y

        self.create_oval(x, y, x + radius*2, y + radius*2, outline=color, fill=color)

The stuff beyond:

##########################################################
# ***DO NOT MODIFY OR REMOVE ANYTHING BELOW THIS POINT!***

not duplicated here. I also dealt with some whackiness in your Point methods in the way that they insisted on converting numbers to strings and back to numbers, e.g.:

x0 = float(str(((self.x + other.x))))/2

Instead doing:

x0 = (self.x + other.x) / 2

and forcing self.x to be a float when the Point is created.