Add points to a Quadtree - Python Pygame

import pygame
from pygame import gfxdraw
import random

# quadTree constants
CAPACITY = 4

# This breaks down the display area into populated rectangles. The population is based on points
class quadTree:
    def __init__(s, rect): # boundry is a rectangle
        s.rect = rect
        s.points = []
        s.divided = False

    def insert(s, point):
        global PD # Primary Display
        global CAPACITY # maximum capacity on each quadrant

        # if the point inserted does fit into this quadrant then don't add it to
        # the points list. Exit insert()!
        if not s.rect.collidepoint(int(point.x), int(point.y)): return False

        # draw the point to the Primary Display
        pygame.draw.circle(PD, (255, 0, 0), (int(point.x), int(point.y)), 3)

        # check if the quadrant has room for more points
        if len(s.points) < CAPACITY:
            s.points.append(point) # if there's room add it to the points list
            # return True to inform parent quadtree the point has been added
            return True
        else:
            # if the quadrant is full then divide the quadrant into
            # four parts north west, north east, south west, south east...
            if not s.divided:
                s.subDivide()

            # ...and insert the point into one of the four new quadrants
            if s.nw.insert(point):
                return True
            elif s.ne.insert(point):
                return True
            elif s.sw.insert(point):
                return True
            elif s.se.insert(point):
                return True

    def subDivide(s):
        global PD # Primary Display

        # create four new quadtrees which belong to the parent quadtree
        size = (s.rect.width / 2, s.rect.height / 2)
        s.nw = quadTree(pygame.Rect(s.rect.topleft, size))
        s.ne = quadTree(pygame.Rect(s.rect.midtop, size))
        s.sw = quadTree(pygame.Rect(s.rect.midleft, size))
        s.se = quadTree(pygame.Rect(s.rect.center, size))
        s.divided = True # the parent quadtree can no longer be divided

        # draw the boundry to help visualise what's going on
        pygame.gfxdraw.hline(PD, int(s.rect.x), int(s.rect.right), int(s.rect.centery), (255, 255, 255))
        pygame.gfxdraw.vline(PD, int(s.rect.centerx), int(s.rect.y), int(s.rect.bottom), (255, 255, 255))

# pygame display settings
DR = pygame.Rect((0, 0, 800, 600)) # Display Rectangle
HDW, HDH = DR.center # H = half

# set up pygame
pygame.init()
PD = pygame.display.set_mode(DR.size) # primary display based of the size of Display Rect (800, 600)

# create a quadtree instance and initialise it with the display rectange (size of the display)
QT = quadTree(DR)

# previous position of the mouse pointer
px, py = -1, -1

# press ESC to exit
while True:
    # process events
    e = pygame.event.get()
    if pygame.key.get_pressed()[pygame.K_ESCAPE]: break

    # get position of the mouse
    mx, my = pygame.mouse.get_pos()

    # if current mouse position is different to the previous mouse position
    # and left mouse button has been pressed then...
    if (mx, my) != (px, py) and pygame.mouse.get_pressed()[0]:
        # set the previous mouse position to the current mouse position
        px, py = (mx, my)

        # create a vector from the mouse location with a random offset on the x and y axis
        rx, ry = (mx + random.randint(-40, 40), my + random.randint(-40, 40))

        # create a point using pygame's vector2
        p = pygame.math.Vector2(rx, ry)

        # insert the point into the quadtree
        QT.insert(p)

    pygame.display.update()