def regression():
    filename = input("Please provide the name of the file including the extention: ")
    while not (os.path.exists(filename)):
        filename = input("Please provide a valid name for the file including the extention: ")
    ds = []
    file = open(filename)

    for line in file:
        coordinates = line.split()
        x = float(coordinates[0])
        y = float(coordinates[1])
        point = (x, y)
        ds.append(point)
    my_turtle = turtle.Turtle()
    turtle.title("Least Squares Regression Line")

    turtle.clearscreen()
    xmin = min(getXcoords(ds))
    xmax = max(getXcoords(ds))
    ymin = min(getYcoords(ds))
    ymax = max(getYcoords(ds))
    xborder = 0.2 * (xmax - xmin)
    yborder = 0.2 * (ymax - ymin)
    turtle.setworldcoordinates(xmin - xborder, ymin - yborder, xmax + xborder, ymax + yborder)
    plotPoints(my_turtle, ds)
    m, b = leastSquares(ds)
    print("The equation of the line is y=%fx+%f" % (m, b))
    plotLine(my_turtle, m, b, xmin, xmax)
    plotErrorBars(my_turtle, ds, m, b)
    print("Goodbye")

	def plot(self, node1, node2, debug=False):
		"""Plots wires and intersection points with python turtle"""
		tu.setup(width=800, height=800, startx=0, starty=0)
		tu.setworldcoordinates(-self.lav, -self.lav, self.sample_dimension+self.lav, self.sample_dimension+self.lav)
		tu.speed(0)
		tu.hideturtle()
		for i in self.index:
			if debug:
				time.sleep(2)   # Debug only
			tu.penup()
			tu.goto(self.startcoords[i][0], self.startcoords[i][1])
			tu.pendown()
			tu.goto(self.endcoords[i][0], self.endcoords[i][1])
		tu.penup()
		if self.list_of_nodes is None:
			intersect = self.intersections(noprint=True)
		else:
			intersect = self.list_of_nodes
		tu.goto(intersect[node1][0], intersect[node1][1])
		tu.dot(10, "blue")
		tu.goto(intersect[node2][0], intersect[node2][1])
		tu.dot(10, "blue")
		for i in intersect:
			tu.goto(i[0], i[1])
			tu.dot(4, "red")
		tu.done()
		return "Plot complete"

def drawSetup(title,xlimits,xscale,ylimits,yscale,axisThickness=None):
	turtle.title(title)
	xmin, xmax = xlimits
	ymin, ymax = ylimits
	#turtle.setup(xmax-xmin,ymax-ymin,0,0) #window-size
	globals()['xmin'] = xmin
	globals()['xmax'] = xmax
	globals()['ymin'] = ymin
	globals()['ymax'] = ymax
	globals()['xscale'] = xscale
	globals()['yscale'] = yscale

	turtle.setworldcoordinates(xmin,ymin,xmax,ymax)
	#turtle.speed(0) #turtle.speed() does nothing w/ turtle.tracer(0,0)
	turtle.tracer(0,0)

	drawGrid()
	#drawGridBorder()
	
	turtle.pensize(axisThickness)

	drawXaxis()
	drawXtickers()
	numberXtickers()
	
	drawYaxis()
	drawYtickers()
	numberYtickers()

	turtle.pensize(1)

 def __init__(self, T, lmbda, mu, speed=6, costofbalking=False):
     ##################
     bLx = -10 # This sets the size of the canvas (I think that messing with this could increase speed of turtles)
     bLy = -110
     tRx = 230
     tRy = 5
     setworldcoordinates(bLx,bLy,tRx,tRy)
     qposition = [(tRx+bLx)/2, (tRy+bLy)/2]  # The position of the queue
     ##################
     self.costofbalking = costofbalking
     self.T = T
     self.completed = []
     self.balked = []
     self.lmbda = lmbda
     self.mu = mu
     self.players = []
     self.queue = Queue(qposition)
     self.queuelengthdict = {}
     self.server = Server([qposition[0] + 50, qposition[1]])
     self.speed = max(0,min(10,speed))
     self.naorthreshold = False
     if type(costofbalking) is list:
         self.naorthreshold = naorthreshold(lmbda, mu, costofbalking[1])
     else:
         self.naorthreshold = naorthreshold(lmbda, mu, costofbalking)
     self.systemstatedict = {}

def init():
    t.setworldcoordinates(0,0,
        WINDOW_WIDTH, WINDOW_HEIGHT)
    t.up()
    t.setheading(90)
    t.forward(75)
    t.title('Typography:Name')

 def __init__(self, world_size, beacons):
     self.beacons = beacons
     self.width = int(world_size)
     self.height = int(world_size)
     turtle.setworldcoordinates(0, 0, self.width, self.height)
     self.update_cnt = 0
     self.one_px = float(turtle.window_width()) / float(self.width) / 2

    def SCREEN( self, mode ):
        """
        SCREEN 0 ● Text mode only

        SCREEN 1 ● 320 × 200 pixel medium-resolution graphics ● 80 x 25 text

        SCREEN 2 ● 640 × 200 pixel high-resolution graphics ● 40 × 25 text

        SCREEN 7 ● 320 × 200 pixel medium-resolution graphics ● 40 × 25 text

        SCREEN 8 ● 640 × 200 pixel high-resolution graphics ● 80 × 25 text

        SCREEN 9 ● 640 × 350 pixel enhanced-resolution graphics ● 80 × 25 text

        SCREEN 10 ● 640 × 350 enhanced-resolution graphics ● 80 × 25 text
        """
        if mode == 8:
            # Officially 640x200 with rectangular pixels, appears as 640x480.
            turtle.setup( width=640, height=480 )
            turtle.setworldcoordinates(0,0,640,480)
            self.aspect_v = (200/640)*(4/3)
        elif mode == 9:
            # Official 640x350 with rectangular pixels, appears 640x480.
            turtle.setup( width=640, height=480 )
            turtle.setworldcoordinates(0,0,640,480)
            self.aspect_v = (350/640)*(4/3)

   def initialize_plot(self, positions):
      self.positions = positions
      self.minX = minX = min(x for x,y in positions.values())
      maxX = max(x for x,y in positions.values())
      minY = min(y for x,y in positions.values())
      self.maxY = maxY = max(y for x,y in positions.values())
      
      ts = turtle.getscreen()
      if ts.window_width > ts.window_height:
          max_size = ts.window_height()
      else:
          max_size = ts.window_width()
      self.width, self.height = max_size, max_size
      
      turtle.setworldcoordinates(minX-5,minY-5,maxX+5,maxY+5)
      
      turtle.setup(width=self.width, height=self.height)
      turtle.speed("fastest") # important! turtle is intolerably slow otherwise
      turtle.tracer(False)    # This too: rendering the 'turtle' wastes time
      turtle.hideturtle()
      turtle.penup()
      
      self.colors = ["#d9684c","#3d658e","#b5c810","#ffb160","#bd42b3","#0eab6c","#1228da","#60f2b7" ]

      for color in self.colors:         
         s = turtle.Shape("compound")
         poly1 = ((0,0),(self.cell_size,0),(self.cell_size,-self.cell_size),(0,-self.cell_size))
         s.addcomponent(poly1, color, "#000000")
         turtle.register_shape(color, s)
      
      s = turtle.Shape("compound")
      poly1 = ((0,0),(self.cell_size,0),(self.cell_size,-self.cell_size),(0,-self.cell_size))
      s.addcomponent(poly1, "#000000", "#000000")
      turtle.register_shape("uncolored", s)

def main():
  ap = ArgumentParser()
  ap.add_argument('--speed', type=int, default=10,
                  help='Number 1-10 for drawing speed, or 0 for no added delay')
  ap.add_argument('program')
  args = ap.parse_args()

  for kind, number, path in parse_images(args.program):
    title = '%s #%d, path length %d' % (kind, number, path.shape[0])
    print(title)
    if not path.size:
      continue
    pen_up = (path==0).all(axis=1)
    # convert from path (0 to 65536) to turtle coords (0 to 655.36)
    path = path / 100.
    turtle.title(title)
    turtle.speed(args.speed)
    turtle.setworldcoordinates(0, 655.36, 655.36, 0)
    turtle.pen(shown=False, pendown=False, pensize=10)
    for i,pos in enumerate(path):
      if pen_up[i]:
        turtle.penup()
      else:
        turtle.setpos(pos)
        turtle.pendown()
        turtle.dot(size=10)
    _input('Press enter to continue')
    turtle.clear()
  turtle.bye()

def initBannerCanvas( numChars, numLines ):
    """
    Set up the drawing canvas to draw a banner numChars wide and numLines high.
    The coordinate system used assumes all characters are 20x20 and there
    are 10-point spaces between them.
    Postcondition: The turtle's starting position is at the bottom left
    corner of where the first character should be displayed.
    """
    # This setup function uses pixels for dimensions.
    # It creates the visible size of the canvas.
    canvas_height = 80 * numLines 
    canvas_width = 80 * numChars 
    turtle.setup( canvas_width, canvas_height )

    # This setup function establishes the coordinate system the
    # program perceives. It is set to match the planned number
    # of characters.
    height = 30 
    width = 30  * numChars
    margin = 5 # Add a bit to remove the problem with window decorations.
    turtle.setworldcoordinates(
        -margin+1, -margin+1, width + margin, numLines*height + margin )

    turtle.reset()
    turtle.up()
    turtle.setheading( 90 )
    turtle.forward( ( numLines - 1 ) * 30 )
    turtle.right( 90 )
    turtle.pensize( 2 * scale)

	def __init__(self, mazeFileName):
		rowsInMaze = 0
		columnsInMaze = 0
		self.mazelist = []
		mazeFile = open(mazeFileName, 'r')
		for line in mazeFile:
			rowList = []
			col = 0
			for ch in line[:-1]:
				rowList.append(ch)
				if ch == 'S':
					self.startRow = rowsInMaze
					self.startCol = col
				col = col + 1
			rowsInMaze = rowsInMaze + 1
			self.mazelist.append(rowList)
			columnsInMaze = len(rowList)

		self.rowsInMaze = rowsInMaze
		self.columnsInMaze = columnsInMaze
		self.xTranslate = -columnsInMaze / 2
		self.yTranslate = rowsInMaze / 2

		self.t = turtle.Turtle()
		self.t.shape('turtle')
		self.wn = turtle.Screen()
		turtle.setup(width = 600, height = 600)
		turtle.setworldcoordinates(-(columnsInMaze - 1)/2 - .5,
											  -(rowsInMaze - 1) / 2 - .5,
											  (columnsInMaze - 1)/ 2 + .5,
											  (rowsInMaze - 1) / 2 + .5 )

def init_board():
    board = turtle.Turtle()
    wn = turtle.Screen()
    turtle.setworldcoordinates(-400,-400,400,400)
    wn.bgcolor('green')
    board.ht()
    board.speed(0)
    board.pensize(4)
    board.pencolor('black')

    coordinate = [[-300,-400,90,None,800],
		  [-200,-400,None,None,800],
		  [-100,-400,None,None,800],
		  [0,-400,None,None,800],
		  [100,-400,None,None,800],
		  [200,-400,None,None,800],
		  [300,-400,None,None,800],
		  [-400,-300,None,90,800],
		  [-400,-200,None,None,800],
		  [-400,-100,None,None,800],
		  [-400,0,None,None,800],
		  [-400,100,None,None,800],
		  [-400,200,None,None,800],
		  [-400,300,None,None,800]]
		  
    for i in range(14):
        X=0
        Y=1
        LEFT=2
        RIGHT=3
        FORWARD=4

def initBannerCanvas( numChars , numLines, scale ):
    """
    Set up the drawing canvas to draw a banner numChars wide and numLines high.
    The coordinate system used assumes all characters are 20x20 and there
    are 10-point spaces between them.
    Precondition: The initial canvas is default size, then input by the first
    two user inputs, every input after that defines each letter's scale, probably between
    1 and 3 for the scale values to have the window visible on the screen.
    Postcondition: The turtle's starting position is at the bottom left
    corner of where the first character should be displayed, the letters are printed.
    """
    scale = int(input("scale, integer please"))
    
    # This setup function uses pixels for dimensions.
    # It creates the visible size of the canvas.
    canvas_height = 80 * numLines *scale
    canvas_width = 80 * numChars *scale
    turtle.setup( canvas_width *scale, canvas_height *scale)

    # This setup function establishes the coordinate system the
    # program perceives. It is set to match the planned number
    # of characters.
    height = 30 *scale
    width = 30 * numChars *scale
    margin = 5 # Add a bit to remove the problem with window decorations.
    turtle.setworldcoordinates(
        -margin+1 * scale, -margin+1 * scale, width + margin* scale, numLines*height + margin * scale)

    turtle.reset()
    turtle.up()
    turtle.setheading( 90 )
    turtle.forward( ( numLines - 1 ) * 30 )
    turtle.right( 90 )
    turtle.pensize( 1  *scale)

def init():
    """
    sets the window size and the title of the program
    """
    t.setworldcoordinates(0, 0, WINDOW_LENGTH, WINDOW_HEIGHT)
    t.title('Forest')
    t.up()
    t.forward(100)

    def __init__(self, dim_x, dim_y, maze):
        # 'maze' is a list of pairs of points, which represent the endpoints
        # of each line segment.
        self.maze = maze

        self.dim_x = dim_x
        self.dim_y = dim_y

        turtle.setworldcoordinates(0, 0, self.dim_x, self.dim_y)
        self.update_cnt = 0

def init():
    turtle.setworldcoordinates(-WINDOW_WIDTH / 2, -WINDOW_WIDTH / 2,
                               WINDOW_WIDTH / 2, WINDOW_HEIGHT / 2)
    turtle.up()
    turtle.setheading(0)
    turtle.hideturtle()
    turtle.title('Snakes')
    turtle.showturtle()
    turtle.setx(-225)
    turtle.speed(0)

def init():
    """
    Initialize the canvas
    :pre: relative (0,0), heading east, up
    :post: relative (0,0), heading east, up
    :return: None
    """
    t.setworldcoordinates(-BOUNDARY/2, -BOUNDARY/2, BOUNDARY, BOUNDARY)
    t.title("SQUARES")
    t.speed(0)

def drawcurve(points):
    myTurtle = turtle.Turtle(shape="turtle")
    turtle.screensize(500,500)
    turtle.setworldcoordinates(400,400,500,500)
    myTurtle.penup()
    y = points[0]
    myTurtle.setposition(y[0], y[1])
    myTurtle.pendown()
    for x in points:
        myTurtle.setposition(x[0], x[1])
    turtle.getscreen()._root.mainloop()

def _init():
    root = Tk()
    menubar = Menu(root)
    menubar.add_command(label="Save", command=save_image) 
    menubar.add_command(label="Clear", command=_clear)
    root.config(menu=menubar)
    turtle.speed(0)
    turtle.delay(0)
    turtle.setworldcoordinates(-xCoor,-yCoor,xCoor,yCoor)
    turtle.up()
    turtle.setpos(0,0)
    turtle.down()

    def __init__(self):
        #Creates display for visualization. 
        self.window = turtle.Screen()
        turtle.setworldcoordinates(-5, -5, 5, 5)
        turtle.speed(0)

        #Initializes ROS and subscribes to particle filter. 
        rospy.init_node('particle_visualizer', anonymous=True)
        rospy.Subscriber('particle_filter', Particle_vector, self.update)

        #Initializes list of particles. 
        self.particles = []