diamond square algorithm

#
#   diamond square algorithm
#

import random

class Point:
    def __init__(self, X, Y, Height=0.0):
        self.X = X
        self.Y = Y
        self.Height = Height

class Quad:
    Points = {'NE':None, 'NW':None, 'SW':None, 'SE':None, 'N':None, 'S':None, 'E':None, 'W':None, 'Centre':None}
    Children = {'NE':None, 'NW':None, 'SW': None, 'SE':None}
    rangeMin = 0
    rangeMax = 100

    def __init__(self, TL, TR, BL, BR, rangeMin, rangeMax):
        self.Points['NW'] = TL
        self.Points['NE'] = TR
        self.Points['SW'] = BL
        self.Points['SE'] = BR
        centrePointX = self.getPoint('NE').X - self.getPoint('NW').X
        centrePointY = self.Points['SE'].Y - self.getPoint('NE').Y
        centrePoint = Point(centrePointX, centrePointY)
        self.Points['Centre'] = centrePoint
        self.rangeMin = rangeMin
        self.rangeMax = rangeMax

    def getPoint(self, name):
        try:
            x = self.Points[name]
            return x
        except:
            print()
            print('''getPoint(name) > "name" must be: ''')
            print('''"NE", "NW", "SE", "SW", "N", "S", "E", "W or "Centre"''')
            print()

    def findPoint(self, X, Y):

        X = round(X)
        Y = round(Y)

        tr = self.Points['NE']
        tl = self.Points['NW']
        br = self.Points['SE']
        bl = self.Points['SW']
        t = self.Points['N']
        b = self.Points['S']
        l = self.Points['W']
        r = self.Points['E']
        c = self.Points['Centre']

        if l == None:
            self.generateChildren()

        if X >= l.X and X <= r.X and Y >= t.Y and Y <= b.Y:
            for i in self.Points.values():
                if round(i.X) == X and round(i.Y) == Y:
                    return i
            if X < round(c.X) and Y < round(c.Y):
                return self.getChild('NW').findPoint(X,Y)
            elif X > round(c.X) and Y < round(c.Y):
                return self.getChild('NE').findPoint(X,Y)
            elif X < round(c.X) and Y > round(c.Y):
                return self.getChild('SW').findPoint(X,Y)
            elif X > round(c.X) and Y > round(c.Y):
                return self.getChild('SE').findPoint(X,Y)

    def getChild(self, name):
        try:
            x = self.Children[name]
            return x
        except:
            pass

    # Note: randomRange should be from 1-100
    #   height of middle point = (tl+tr+bl+br+randrange(randomrangemin,randomrangemax)/100)/5
    #                          = somewhere between 0 and 1 (float)
    #   height of sides = (adjacent points + randrange(randomrangemin/2,randomrangemax/2)/100)/5
    #                   = somewhere between 0 and 1 (float)
    def generateChildren(self):
        rangeMin = self.rangeMin
        rangeMax = self.rangeMax

        tl = self.Points['NW']
        tr = self.Points['NE']
        bl = self.Points['SW']
        br = self.Points['SE']
        self.Points['Centre'].Height = (tl.Height + tr.Height + bl.Height + br.Height + random.randrange(int(rangeMin), int(rangeMax))/100.0)/5.0
        c = self.Points['Centre']

        # north point
        nX = (tr.X - tl.X)/2.0
        print(self.getPoint('NW').X)
        nY = tr.Y
        nH = (tl.Height + tr.Height + c.Height + random.randrange(int(rangeMin/2), int(rangeMax/2))/100.0)/4.0
        n = Point(nX, nY, nH)
        self.Points['N'] = n

        # south point
        sX = (br.X - bl.X)/2.0
        sY = br.Y
        sH = (br.Height + bl.Height + c.Height + random.randrange(int(rangeMin/2), int(rangeMax/2))/100.0)/4.0
        s = Point(sX, sY, sH)
        self.Points['S'] = s
        print(self.getPoint('NW').X)

        # east point
        eX = br.X
        eY = (br.Y - tr.Y)/2
        eH = (br.Height + tr.Height + c.Height + random.randrange(int(rangeMin/2), int(rangeMax/2))/100.0)/4.0
        e = Point(eX, eY, eH)
        self.Points['E'] = e
        print(self.getPoint('NW').X)

        # west point
        wX = bl.X
        wY = (bl.Y - tl.Y)/2
        wH = (bl.Height + tl.Height + c.Height + random.randrange(int(rangeMin/2), int(rangeMax/2))/100.0)/4.0
        w = Point(wX, wY, wH)
        self.Points['W'] = w
        print(self.getPoint('NW').X)

        # random ranges
        rmi = (self.rangeMin+self.rangeMax)/4.0
        rma = rmi*3.0
        print(self.getPoint('NW').X)

        #quads
        self.Children['NW'] = Quad(tl, n, w, c, rmi, rma)
        self.Children['NE'] = Quad(n, tr, c, e, rmi, rma)
        self.Children['SW'] = Quad(w, c, bl, s, rmi, rma)
        self.Children['SE'] = Quad(c, e, s, br, rmi, rma)
        print(self.getPoint('NW').X)

# Creates 3 Generations of Quads, which means there are 64 Quads, and 576 points.
# returning 'q' gives the programmer complete control over ALL points, and ALL quads.
def main():

    # Create 4 points
    tl = Point(0,0,0.5)
    tr = Point(5,0,0.5)
    bl = Point(0,5,0.5)
    br = Point(5,5,0.5)

    # Create a quad of those 4 points
    q = Quad(tl, tr, bl, br, 0, 100)

    # Generate it's 4 child quads
    q.generateChildren()

    return q

newQuad = main()
print (newQuad.getChild('NW').X)
# This is 5 ^^^^^^^^^^^^^^^^^^^
# It is 0 when I define it as 'tl' in main()