def drawCloud(words, num = 20):
    """ Draws a wordcloud with 20 random words, sized by frequency found in 
    the WORDS dictionary. """
    t.reset()
    t.up()
    t.hideturtle()
    topCounts = sorted([words[word] for word in list(words.keys()) if len(word) > 3])
    largest = topCounts[0]
    normalized_counts = {}
    for item in list(words.keys()):
        if len(item) > 3:
            newSize = int(float(words[item]) / largest * 24)
            normalized_counts[item] = newSize
    
    size = t.screensize()
    width_dim = (int(-1 * size[0] / 1.5), int(size[0] / 2))
    height_dim = (int(-1 * size[1] / 1.5), int(size[1] / 1.5))
    

    for item in random.sample(list(normalized_counts.keys()), num):
        t.goto(random.randint(*width_dim), random.randint(*height_dim))
        t.color(random.choice(COLORS))
        try:
            t.write(item, font = ("Arial", int(normalized_counts[item]), "normal"))
        except:
            try:
                t.write(str(item, errors = 'ignore'), font = ("Arial", int(normalized_counts[item]), "normal"))
            except:
                pass

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 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 drawSootSprite(N, R):
    # reset direction
    turtle.reset()
    # draw star
    drawStar(N, R)
    # draw body
    turtle.dot(0.8*2*R)
    # draw right eyeball
    turtle.fd(0.2*R)
    turtle.dot(0.3*R, 'white')
    # draw right pupil
    turtle.pu()
    turtle.bk(0.1*R)
    turtle.pd()
    turtle.dot(0.05*R)
    turtle.pu()
    # centre
    turtle.setpos(0, 0)
    # draw left eyeball
    turtle.bk(0.2*R)
    turtle.pd()
    turtle.dot(0.3*R, 'white')
    # draw left pupil
    turtle.pu()
    turtle.fd(0.1*R)
    turtle.pd()
    turtle.dot(0.05*R)

    turtle.hideturtle()

def square():
    for i in range(4):
        turtle.forward(100)
        turtle.left(90)
    raw_input('Press Enter')    
    clear()
    turtle.reset()

def draw_walk(x, y, speed = 'slowest', scale = 20):
    ''' Animate a two-dimensional random walk.

    Args:
        x       x positions
        y       y positions
        speed   speed of the animation
        scale   scale of the drawing
    '''
    # Reset the turtle.
    turtle.reset()
    turtle.speed(speed)

    # Combine the x and y coordinates.
    walk = zip(x * scale, y * scale)
    start = next(walk)

    # Move the turtle to the starting point.
    turtle.penup()
    turtle.goto(*start)

    # Draw the random walk.
    turtle.pendown()
    for _x, _y in walk:
        turtle.goto(_x, _y)

def drawStar(N, R):
    turtle.reset()
    a = 360/N
    for i in range(N):
        turtle.fd(R)
        turtle.bk(R)
        turtle.left(a)

def SetupClock(radius):  
    # 建立表的外框  
    turtle.reset()  
    turtle.pensize(7)  
    for i in range(60):  
        Skip(radius)  
        if i % 5 == 0:  
            turtle.forward(20)  
            Skip(-radius - 20)  
             
            Skip(radius + 20)  
            if i == 0:  
                turtle.write(int(12), align="center", font=("Courier", 14, "bold"))  
            elif i == 30:  
                Skip(25)  
                turtle.write(int(i/5), align="center", font=("Courier", 14, "bold"))  
                Skip(-25)  
            elif (i == 25 or i == 35):  
                Skip(20)  
                turtle.write(int(i/5), align="center", font=("Courier", 14, "bold"))  
                Skip(-20)  
            else:  
                turtle.write(int(i/5), align="center", font=("Courier", 14, "bold"))  
            Skip(-radius - 20)  
        else:  
            turtle.dot(5)  
            Skip(-radius)  
        turtle.right(6)  

def spiral():
    n=5
    while n<100:
        turtle.circle(n, 180)
        n +=5
    raw_input('Press Enter')    
    clear()
    turtle.reset()

def tree(trunkLength,height):
    turtle.speed(1)
    turtle.reset()
    turtle.left(90)
    turtle.pu()
    turtle.backward(200)
    turtle.pd()
    grow(trunkLength,height)

def init_screen():
    # Delete the turtle's drawings from the screen, re-center the turtle and
    # set variables to the default values
    screen = turtle.Screen()
    screen.setup(width=500, height=500)
    screen.title('Yin Yang')
    turtle.reset()
    turtle.bgcolor('#E8E8F6')
    turtle.hideturtle()

def trianglespiral():
    n=10
    while n<100:
        turtle.forward(n)
        turtle.left(120)
        n +=10
    raw_input('Press Enter')    
    clear()
    turtle.reset()

def circle():
    import math
    circunference = 2 * math.pi * 10
    n = int(circunference / 3) + 1
    length = circunference / n
    polygon(18, n, length)
    raw_input('Press Enter')
    clear()
    turtle.reset()

def new():
    """Aids save and load functionality, and provides a 'blank-slate' method.

    Clears the current command list of all commands, refreshes the screen and
    returns the turtle to home.
    """
    global commandList
    commandList = []
    turtle.reset()

 def __setScreen(self):
     """set the screen/window depending on view static attributes."""
     turtle.resizemode('noresize')
     self.width = self.GRID_MARGINLEFT + 2 * self.gridWidth + self.GAP_BETWEEN_GRIDS + self.GRID_MARGINRIGHT
     self.height = self.GRID_MARGINTOP + self.gridWidth + self.GRID_MARGINBOTTOM
     turtle.setup(width=self.width + 10, height=self.height + 10)
     turtle.screensize(self.width, self.height)
     turtle.bgpic("Ressources/fire_ocean.gif")
     turtle.reset()

def rectangle():
    for i in range(2):
        turtle.forward(100)
        turtle.left(90)
        turtle.forward(50)
        turtle.left(90)
    raw_input('Press Enter')    
    clear()
    turtle.reset()

def triangle():
    turtle.forward(100)
    turtle.left(120)
    turtle.forward(100)
    turtle.left(120)
    turtle.forward(100)
    turtle.left(120)
    raw_input('Press Enter')
    clear()
    turtle.reset()

def main():
    """
    :pre:(relative) pos (0,0), heading (east), up
    :post:(relative) pos (X,0), heading (east), up
    :return: none 
    """
    
    numberOfTree=int(raw_input("How many trees in your forest ?"))
    treeHome=["Mapel","Pine","bodhiTree"]
    dummy_house=raw_input("Is there a house in the forest (y/n)?")
    highestHeight=50

    treeHomeRandom=[treeHome[r.randint(0,2)] for n in range(numberOfTree) ]
    if dummy_house in ['Y','y']:
        if numberOfTree>2:
           treeHomeRandom.insert(r.randint(1,numberOfTree-2),"House")
        elif numberOfTree<=2:
             treeHomeRandom.insert(1,"House")  
    if numberOfTree <= 11:
        if dummy_house in ['Y','y']:
          init(-(numberOfTree+1)*100/2,-100)
        else: 
          init(-(numberOfTree)*100/2,-100)
    else:
         init(-600,-100)

    #print(treeHomeRandom)
    totalWood=0
    for myTree in treeHomeRandom:
       (length,totalWood)=treeAndHouse(myTree,totalWood)
       if length>highestHeight:
           highestHeight=length
       t.up()
       t.forward(100)
       t.down()
    t.up()
    t.back(100)
    star2(highestHeight+10)
    
    raw_input("Night is done Press Enter for day")
    
    t.reset()
    print("We have " + str(totalWood) +" units of lumber for building." )
    print ("We will build a house with walls " + str((totalWood)/(2+math.sqrt(2)))+ " tall.")
    init(0,-300)
    house((totalWood)/(2+math.sqrt(2)))
    t.left(90)
    t.forward(3*abs((totalWood)/(2+math.sqrt(2)))/2+30)
    t.right(90)
    maple_shape(30)
    t.right(90)
    t.up()
    t.back(3*abs((totalWood)/(2+math.sqrt(2)))/2+30)
    t.right(90)
    raw_input("Day is done, house is build, Press enter to quit")

def show_result(convex,usetime,color,algorithm):
    drawpoint(pointset,'black')
    drawpoint(convex,color)
    drawline(convex,color)
    turtle.up()
    #turtle.pensize(400)
    turtle.goto(-60,min_y-30)
    turtle.down()
    turtle.write('%s,use time:%s'%(algorithm,str(usetime)))
    time.sleep(10)
    turtle.reset()

 def __init__(self,actions,drawColour="black"):
     self.actions = actions
     self.stack = []
     t.setup()
     # Try to make the animation of drawing reasonably fast.
     t.tracer(100,0) # Only draw every 50th update, set delay to zero.
     t.title ("Jose Javier's L System demo")
     t.reset()
     t.degrees()
     t.color(drawColour)
     t.hideturtle() # don't draw the turtle; increase drawing speed.