def extend(self, item_list):
""" Add the given items to the world.
@param item_list: [ ... polygon ... ]
"""
assert isinstance(item_list, (type(()), type([])))
# Identify the bounds of the new list
l = min(item.left for item in item_list)
t = max(item.top for item in item_list)
r = max(item.right for item in item_list)
b = min(item.bottom for item in item_list)
bounding_box = BBox(l, t, r, b)
if self.item_list:
self.item_list.extend(item_list)
else:
self.item_list = item_list
# Compare with index
if self.index is None:
self.index = QuadTree(self.item_list)
else:
# Check that new items are inside the existing index
i_l, i_t, i_r, i_b = self.index.box_as_tuple
if l >= i_l and t <= i_t and r <= i_r and b >= i_b:
self.index.extend(item_list)
else:
# Rebuild to allow for extra space
self.index = QuadTree(self.item_list)
def __init__(self):
self.ants = []
self.food = Circle(19, 18, 0.2)
self.home = Circle(10, 10, 0.2)
self.home_trail = QuadTree(AREA, capacity=QUADTREE_CAPACITY)
self.food_trail = QuadTree(AREA, capacity=QUADTREE_CAPACITY)
self.iteration = -1
def __check_collisions(self):
"""Update proximity sensors and detect collisions between objects"""
collisions = []
checked_robots = []
if self.__qtree is None:
self.__qtree = QuadTree(self.__obstacles)
if len(self.__robots) > 1:
rqtree = QuadTree(self.__robots)
else:
rqtree = None
# check each robot
for robot in self.__robots:
# update proximity sensors
for sensor in robot.get_external_sensors():
sensor.get_world_envelope(True)
rect = Rect(sensor.get_bounding_rect())
sensor.update_distance()
# distance to obstacles
for obstacle in self.__qtree.find_items(rect):
sensor.update_distance(obstacle)
# distance to other robots
if rqtree is None: continue
for other in rqtree.find_items(rect):
if other is not robot:
sensor.update_distance(other)
rect = Rect(robot.get_bounding_rect())
# against nearest obstacles
for obstacle in self.__qtree.find_items(rect):
if robot.has_collision(obstacle):
collisions.append((robot, obstacle))
# against other robots
if rqtree is not None:
for other in rqtree.find_items(rect):
if other is robot: continue
if other in checked_robots: continue
if robot.has_collision(other):
collisions.append((robot, other))
checked_robots.append(robot)
if len(collisions) > 0:
# Test code - print out collisions
for (robot, obstacle) in collisions:
self.log("Collision with {}".format(obstacle),
obj=robot,
color=robot.get_color())
# end of test code
return True
return False
def main():
capacite = input(
"Veuillez entrer la capacitée maximale que QuadTree peut contenir ")
pygame.init()
pygame.mixer.init()
pygame.display.set_caption('QuadTree Project')
ecran = pygame.display.set_mode((WINDOWWIDTH, WINDOWHEIGHT))
refresh(ecran)
e = ensemble_points(0, 512, 512) # création de 8 points aléatoires
# dans un univers de taille
# 512x512
region = Rectangle((0, 0), (512, 512))
quadTree = QuadTree(region, e, int(capacite))
while True: # boucle principale
try:
handleEvents(quadTree)
drawApp(ecran, quadTree)
pygame.display.update()
except Quitte:
break
pygame.quit()
sys.exit(0)
def _clear_all(self):
self.find_points = []
self.find_frm = None
self.find_to = None
self.kd_find_result = None
self.kd_find_steps = []
self.find_step_no = 0
self.find_stage = NO_FIND
self.q_find_steps = []
self.q_find_result = []
self._q_found_points = []
self._q_graph = nx.DiGraph()
self._kd_graph = nx.DiGraph()
self._qt = QuadTree((0, 0), (X_SIZE, Y_SIZE),
lambda x: self.add_q_node(x),
lambda x, y: self.connect_q_node(x, y))
self._kdt = KDTree(
(0, 0), (X_SIZE, Y_SIZE),
lambda x: self.add_kd_node(x),
lambda x, y: self.connect_kd_node(x, y),
lambda x, y, z=(False, True): self.highlight_kd_nodes(x, y, z))
self._refresh_graphs()
def __init__(self, rect):
self.objects = []
self.objects.append(Player())
for i in range(100):
self.objects.append(Hunter())
self.qtree = QuadTree(rect, maxDepth=8)
self.qtree.insert(self.objects)
def remove(self, item):
""" Remove a single item from the world
@param item: PolyGon or similar
"""
self.item_list.remove(item)
# Oops. Rebuilding quadtrees is not that easy...
self.index = QuadTree(self.item_list)
def test_constructor_complex():
from quadtree import QuadTree
q = QuadTree(complex(100, 100))
assert abs(q.dimension.real - 100) < 0.0001
assert abs(q.dimension.imag - 100) < 0.0001
assert q.branches == [None, None, None, None]
assert q.children == {}
def test_constructor_distinct():
from quadtree import QuadTree
q = QuadTree(width=100, height=100)
assert abs(q.dimension.real - 100) < 0.0001
assert abs(q.dimension.imag - 100) < 0.0001
assert q.branches == [None, None, None, None]
assert q.children == {}
def __init__(self):
super(GUI, self).__init__('Simple example 1')
self.find_stage = False
self.find_points = []
self.find_frm = None
self.find_to = None
self.kd_find_steps = []
self.kd_find_result = None
self.find_step_no = 0
self.q_find_steps = []
self.q_find_result = []
self._q_found_points = []
self._q_structure = ControlMatplotlib('Quad tree structure')
self._q_plain = ControlMatplotlib('Quad tree plain')
self._kd_structure = ControlMatplotlib('KD tree structure')
self._kd_plain = ControlMatplotlib('KD tree plain')
self._find_button = ControlButton('Find')
self._step_button = ControlButton('Step')
self._clear_button = ControlButton('Clear')
self._find_button.value = self._on_find
self._step_button.value = self._on_step
self._clear_button.value = self._clear_all
self._formset = [
'_find_button', '||', '_step_button', '||', "_clear_button", '=', {
'Quad tree': ['_q_structure', '||', '_q_plain'],
'KD tree': ['_kd_structure', '||', '_kd_plain']
}
]
self._q_graph = nx.DiGraph()
self._kd_graph = nx.DiGraph()
self._q_graph_fig = self._q_structure.fig
self._q_plain_fig = self._q_plain.fig
self._kd_graph_fig = self._kd_structure.fig
self._kd_plain_fig = self._kd_plain.fig
self._kd_plain_fig.canvas.mpl_connect(
'button_press_event', lambda x: self._add_point_action(x))
self._q_plain_fig.canvas.mpl_connect(
'button_press_event', lambda x: self._add_point_action(x))
self._qt = QuadTree((0, 0), (X_SIZE, Y_SIZE),
lambda x: self.add_q_node(x),
lambda x, y: self.connect_q_node(x, y))
self._kdt = KDTree(
(0, 0), (X_SIZE, Y_SIZE),
lambda x: self.add_kd_node(x),
lambda x, y: self.connect_kd_node(x, y),
lambda x, y, z=(False, True): self.highlight_kd_nodes(x, y, z))
self._refresh_graphs()
def __init__(self, item_list=None):
""" Set up the solid world
@param item_list: [ ... polygon ... ]
"""
self.item_list = None
if item_list:
self.item_list = item_list
self.index = None
if item_list:
self.index = QuadTree(self.item_list)
def build_tree(text):
query = query_broadcast.value
root = None
geometric_centroid_ra = geometric_centroid_dec = None
centroid = None
cent_min_dist = float("inf")
voxel = None
for lines in text:
for line in lines[1].split("\n"):
split = line.split(",")
if len(split) == 4:
min_ra, max_ra, min_dec, max_dec = split
voxel = Voxel(float(min_ra), float(max_ra), float(min_dec),
float(max_dec))
geometric_centroid_ra, geometric_centroid_dec = voxel.getVoxelCentroid(
)
root = Node(voxel)
elif line:
border = False if split[13].lower() == "false" else True
'''star = Element(int(split[0]), float(split[1]), float(split[2]), float(split[3]), float(split[4]),
float(split[5]), float(split[6]), float(split[7]), float(split[8]),
float(split[9]), float(split[10]), float(split[11]), float(split[12]), 0, border)'''
star = Element(int(split[0]), float(split[1]), float(split[2]),
float(split[3]), 0, border)
root.addElement(star)
if star.border is False:
dist = EucDist(star.getRa(), geometric_centroid_ra,
star.getDec(), geometric_centroid_dec)
if dist < cent_min_dist:
centroid = star
cent_min_dist = dist
root.setSize(len(root.getElements()))
root.addCentroid(centroid)
level = compute_level(voxel.getSideSize(), voxel.getHeightSize(),
query.getMaxDistance())
tree = QuadTree(root, level)
print("\n**** Data Descriptions *****")
print("Sky Voxel: %s,%s,%s,%s" %
(voxel.x_left, voxel.x_right, voxel.y_left, voxel.y_right))
print("Sky Diagonal: %s" % voxel.getDiagonal())
print("Tree Level: %s" % level)
print("Tree Elements: %s" % root.size)
print("Tree Leaf nodes: %s" % len(tree.nodes))
print("**** End Data Descriptions *****\n")
return [tree]
def rebuild_quad_tree(self):
self.quad_tree = QuadTree( geometry.BoundingBox( 0, self.SCREEN_SIZE[0], 0, self.SCREEN_SIZE[1] ), max_elems=4 )
for wall in self.walls:
for wall_segment in pairwise( wall ):
self.quad_tree.add( geometry.LineSegment( wall_segment[0], wall_segment[1] ) )
self.quad_tree_rects = []
def get_quadrants_rects( quadrant ):
if quadrant.subquadrants is not None:
for subquadrant in quadrant.subquadrants:
get_quadrants_rects( subquadrant )
else:
self.quad_tree_rects.append( pygame.Rect( quadrant.bounding_box.x_lower, quadrant.bounding_box.y_lower,
quadrant.bounding_box.x_upper - quadrant.bounding_box.x_lower + 1,
quadrant.bounding_box.y_upper - quadrant.bounding_box.y_lower + 1 ) )
get_quadrants_rects( self.quad_tree.main_quadrant )
def __init__(self):
self.root = QuadTree()
self.radius = 0.125
self.searching = None
self.found = []
self.app = QtWidgets.QApplication(sys.argv)
super().__init__()
self.app.setStyle("Fusion")
palette = QtGui.QPalette()
palette.setColor(QtGui.QPalette.Window, self.background)
self.app.setPalette(palette)
self.setWindowTitle('QuadTree')
self.resize(600, 600)
self.show()
# main event loop
sys.exit(self.app.exec_())
def build_tree(filename, query):
start_time = time.time()
root = None
geometric_centroid_ra = geometric_centroid_dec = None
centroid = None
cent_min_dist = float("inf")
voxel = None
with open(filename) as f:
for line in f:
split = line.replace("\n", "").split(",")
if len(split) == 4:
min_ra, max_ra, min_dec, max_dec = split
voxel = Voxel(float(min_ra), float(max_ra), float(min_dec), float(max_dec))
geometric_centroid_ra, geometric_centroid_dec = voxel.getVoxelCentroid()
root = Node(voxel)
elif line:
border = False # if split[13].lower() == "false" else True
star = Element(int(split[0]), float(split[1]), float(split[2]), float(split[3]), float(split[4]),
float(split[5]), float(split[6]), float(split[7]), float(split[8]),
float(split[9]), float(split[10]), float(split[11]), float(split[12]), 0, border)
root.addElement(star)
if star.border is False:
dist = EucDist(star.getRa(), geometric_centroid_ra, star.getDec(), geometric_centroid_dec)
if dist < cent_min_dist:
centroid = star
cent_min_dist = dist
root.setSize(len(root.getElements()))
root.addCentroid(centroid)
level = compute_level(voxel.getSideSize(), voxel.getHeightSize(), query.getMaxDistance())
tree = QuadTree(root, level)
end_time = time.time() - start_time
print("BT - %s - %0.25f" % (filename, end_time))
return tree
def load(filename, zoom):
with open(filename) as file:
data = json.load(file)
FILENAME = data['filename']
startIter = data['iter']
tree = QuadTree( (data['treeMin'][0]*zoom, data['treeMin'][1]*zoom), (data['treeMax'][0]*zoom, data['treeMax'][1]*zoom))
Node.tree = tree
Road.tree = tree
for node in data['nodes']:
Node((node['coord'][0]*zoom, node['coord'][1]*zoom), id=node['id'])
Node.nodeId = max(Node.nodeSet.keys())+1
for road in data['roads']:
newRoad = Road.getClass(road['type'])(Node.nodeSet[road['start']], Node.nodeSet[road['end']], level=road['level'])
if type(newRoad) is SpecialRoad:
newRoad.create(**road['data'])
newRoad.add(road['id'])
newRoad.reset()
Road.roadId = max(Road.roadSet.keys())+1
return FILENAME, startIter
def setup(self):
self.quadtree = QuadTree(8, self.width, self.height)
self.buffer = 15
self.numRectangles = 100
self.numPoints = 100
self.rectangles = []
self.points = []
self.rectColor = "#354F00"
self.pointColor = "#567714"
self.backColor = "#97A084"
self.collRectColor = "#441154"
self.maxRectSize = 100
self.minRectSize = 20
self.pointSize = 5
self.collRectWidth = 150
self.collRectHeight = 150
self.collRect = RectData(0,0,self.collRectWidth,self.collRectHeight,"#F00")
for i in range(self.numRectangles):
vals = self.genRandomVals("rectangle")
rect = RectData(vals.x, vals.y, vals.w, vals.h, self.rectColor)
self.rectangles.append(rect)
self.quadtree.add(rect)
for i in range(self.numPoints):
vals = self.genRandomVals("point")
point = RectData(vals.x, vals.y, vals.w, vals.h, self.pointColor)
self.points.append(point)
self.quadtree.add(point)
self.draw_rect(0, 0, self.width, self.height, "#000")
self.draw_rect(self.collRect.x,self.collRect.y,self.collRect.w,self.collRect.h,self.collRect.data)
def build_tree(text):
#query = query_broadcast.value
root = None
geometric_centroid_ra = geometric_centroid_dec = None
centroid = None
cent_min_dist = float("inf")
voxel = None
for i in range(1, len(text)): # skip first line
#for line in lines[1].split("\n"):
split = text[i].split(",")
if len(split) == 4:
min_ra, max_ra, min_dec, max_dec = split
voxel = Voxel(float(min_ra), float(max_ra), float(min_dec),
float(max_dec))
geometric_centroid_ra, geometric_centroid_dec = voxel.getVoxelCentroid(
)
root = Node(voxel)
elif text[i]:
star = Element(int(split[0]), float(split[1]), float(split[2]),
float(split[3]), 0, split[4])
root.addElement(star)
dist = EucDist(star.getRa(), geometric_centroid_ra, star.getDec(),
geometric_centroid_dec)
if dist < cent_min_dist:
centroid = star
cent_min_dist = dist
root.setSize(len(root.getElements()))
root.addCentroid(centroid)
level = compute_level(voxel.getSideSize(), voxel.getHeightSize(),
0.00416667)
tree = QuadTree(root, level)
return tree
def test_constructor_wrong():
from quadtree import QuadTree
with pytest.raises(ValueError):
QuadTree()
with pytest.raises(ValueError):
QuadTree(width=100)
with pytest.raises(ValueError):
QuadTree(height=100)
with pytest.raises(ValueError):
QuadTree(complex(100, 100), width=100)
with pytest.raises(ValueError):
QuadTree(complex(100, 100), height=100)
with pytest.raises(ValueError):
QuadTree(complex(100, 100), width=100, height=100)
import numpy as np
import matplotlib.pyplot as plt
from quadtree import Point, Rect, QuadTree
from matplotlib import gridspec
DPI = 72
np.random.seed(13)
width, height = 600, 400
N = 5000
coords = np.random.randn(N, 2) * height / 3 + (width / 2, height / 2)
points = [Point(*coord) for coord in coords]
domain = Rect(width / 2, height / 2, width, height)
qtree = QuadTree(domain, 3)
for point in points:
qtree.insert(point)
print('Number of points in the domain =', len(qtree))
fig = plt.figure(figsize=(700 / DPI, 500 / DPI), dpi=DPI)
ax = plt.subplot()
ax.set_xlim(0, width)
ax.set_ylim(0, height)
qtree.draw(ax)
ax.scatter([p.x for p in points], [p.y for p in points], s=4)
ax.set_xticks([])
ax.set_yticks([])
# Test playground for functions
if __name__ == "__main__":
import p5_vis
import random
import datetime
from p5 import *
from aabb import AABB
from point2d import Point2D
from quadtree import QuadTree
# 1000 x 1000 QuadTree
q = QuadTree(AABB(0, 0, 1000, 1000))
random.seed(datetime.datetime.now().utcoffset())
vis_qt = p5_vis.VisQuadTree(q)
# Insert 100000 points into QuadTree with gaussian distribution
for x in range(0, 100000):
p = Point2D(random.gauss(500, 100), random.gauss(500, 100))
q.insert(p)
# p5py setup function
def setup():
vis_qt.setup()
# p5py run function
run(sketch_draw=vis_qt.draw())
pts = q.get_all()
xtotal = 0
def main():
QuadTree.maxSize = 1
qt = QuadTree( (-160,-160), (160,160))
Node.tree = qt
assert qt.root.isLeaf
assert qt.root.pointCount == 0
print('Test 1 passed')
pts = [[Node(i+10*random.random(),j+10*random.random()) for j in range(-170,180,20)] for i in range(-170,180,20)]
for row in pts:
for p in row:
p.add()
qt.addPoint(pts[1][1])
assert qt.root.isLeaf
assert qt.root.pointCount == 1
print('Test 2 passed')
qt.addPoint(pts[6][2])
assert not qt.root.isLeaf
assert qt.root.pointCount == 2
print('Test 3 passed')
qt.addPoint(pts[0][0])
assert qt.root.minX < -16
assert qt.root.pointCount == 3
print('Test 4 passed')
draw(qt, 'tree1.png')
print('Tree1 complete')
qt = QuadTree( (-155, -155), (155,155))
Node.tree = qt
points = [Node(x,y) for x,y in [(30,50),(30,70),(50,90),(70,90),(90,70),(90,50),(70,30),(50,30)]]
p1 = Node(50,50)
p1.add()
p2 = Node(50,70)
p2.add()
[p.add() for p in points]
pairs = [(a,b) for a in points for b in points if (a.coord-b.coord).sum() > 0]
roads = [TransportRoad(a,b) for a,b in pairs]
[r.add() for r in roads]
for i in range(len(roads)):
qt = QuadTree( (-155,-155), (155,155))
Node.tree = qt
QuadTree.roadNodes = {}
qt.addPoint(p1)
qt.addPoint(p2)
[qt.addPoint(p) for p in points]
qt.addRoad(roads[i])
draw(qt, 'treeroad%d.png' % i)
print('Treeroad%d complete' % i)
QuadTree.roadNodes = {}
qt = QuadTree( (-160,-160), (160,160))
Node.tree = qt
added = []
for i in range(100):
#(row,col) in random.sample(list(itertools.product(range(1,len(pts)-1), range(1,len(pts)-1))), 100):
x = (random.random()-.5) * 320
y = (random.random()-.5) * 320
p = Node(x,y)
p.add()
assert qt.root.parent is None
qt.addPoint(p)
added.append(p)
draw(qt, 'tree2-%d.png' % i)
toCheck = [qt]
while len(toCheck) > 0:
t = toCheck.pop()
for c in t.children:
toCheck.append(c)
assert t.isLeaf or t.pointCount > 0, str(t)
print('Tree2 complete')
for i in range(20):
QuadTree.roadNodes = {}
qt = QuadTree( (-160,-160), (160,160))
Node.tree = qt
added = []
for _ in range(100):
x = (random.random()-.5) * 320
y = (random.random()-.5) * 320
p = Node(x,y)
p.add()
assert qt.root.parent is None
qt.addPoint(p)
added.append(p)
a,b = random.sample(added,2)
road = TransportRoad(a,b)
road.add()
qt.addRoad(road)
draw(qt, 'treeroadr%d.png' % i)
print('Treeroadr%d complete' % i)
def __init__(self, nrof_creatures, world):
super().__init__()
self.nrof_creatures = nrof_creatures
self.world = world
self.creatures = QuadTree(600, 600)
def retrieve(DATASET, SRID, unbounded_id):
pp = PlanarPartition(unbounded_id)
sql = (
"select st_setsrid(st_extent(geometry)::geometry(polygon),"
+ str(SRID)
+ ") from "
+ DATASET
+ "_edge;"
)
with connection(True) as db:
mbr_geometry, = db.record(sql)
dataset_envelope = mbr_geometry.envelope
# unbounded face, otherwise this face cannot be found
pp.faces[unbounded_id] = Face(unbounded_id, dataset_envelope, None, set([]), {})
pp.face_hierarchy[unbounded_id] = None
faces = pp.faces
face_hierarchy = pp.face_hierarchy
edge_hierarchy = pp.edge_hierarchy
t0 = time.time()
sql = (
"select face_id::int, feature_class::int, mbr_geometry, pip_geometry from "
+ DATASET
+ "_face"
) # where imp_low = 0"
# sql = "select id::int, height::int, null as mbr_geometry, null as pip_geometry from "+DATASET+"_face" # where imp_low = 0"
with connection(True) as db:
for item in db.irecordset(sql):
face_id, feature_class_id, mbr_geometry, pip_geometry, = item
faces[face_id] = Face(
face_id,
mbr_geometry.envelope, # FIXME store as box2d and map to Envelope at connection level ???
# mbr_geometry,
pip_geometry,
set([]),
{"feature_class_id": feature_class_id, "step_low": 0},
)
face_hierarchy[face_id] = None
print(f"{time.time()-t0:.3f}s face retrieval: {len(faces)} faces")
t0 = time.time()
edges = pp.edges
# distinct, as the drenthe dataset has edges twice (with multiple feature class)
sql = (
"select distinct edge_id::int, start_node_id::int, end_node_id::int, left_face_id::int, right_face_id::int, geometry from "
+ DATASET
+ "_edge order by edge_id"
) # where imp_low = 0"
# sql = "select id::int, startnode::int, endnode::int, leftface::int, rightface::int, geometry from "+DATASET+"_edge" # where imp_low = 0"
# from tmp_mut_kdtree import create as create_kdtree
# kdtree = create_kdtree(dimensions=2)
# from tmp_grid import Grid
# from math import ceil
# kdtree = Grid(sizes = (ceil(dataset_envelope.width/50.), ceil(dataset_envelope.height/50.)))
### get unique vertices by hashing the geometry
pts = {}
with connection(True) as db:
for item in db.irecordset(sql):
edge_id, start_node_id, end_node_id, left_face_id, right_face_id, geometry, = (
item
)
# pp.edge_rtree.add(edge_id, geometry.envelope)
edges[edge_id] = Edge(
edge_id,
start_node_id,
angle(geometry[0], geometry[1]),
end_node_id,
angle(geometry[-1], geometry[-2]),
left_face_id,
right_face_id,
geometry,
{"step_low": 0}
# {'smooth': make_smooth_line(geometry)})
)
# check for dup points
for j in range(1, len(geometry)):
i = j - 1
assert geometry[i] != geometry[j], geometry
# DO_SIMPLIFY
for pt in geometry:
if (pt.x, pt.y) not in pts:
pts[(pt.x, pt.y)] = [edge_id]
else:
pts[(pt.x, pt.y)].append(edge_id)
# add the edge_ids to the edges sets of the faces
# on the left and right of the edge
faces[left_face_id].edges.add(edge_id)
faces[right_face_id].edges.add(~edge_id)
edge_hierarchy[edge_id] = None
print(f"{time.time()-t0:.3f}s edge retrieval: {len(edges)} edges")
t0 = time.time()
# DO_SIMPLIFY
tree = QuadTree(
[
(dataset_envelope.xmin, dataset_envelope.ymin),
(dataset_envelope.xmax, dataset_envelope.ymax),
],
64,
)
for pt in pts.keys():
tree.add(pt)
pp.quadtree = tree
print(f"{time.time()-t0:.3f}s quadtree construction")
t0 = time.time()
ct = 0
for pt in pp.quadtree:
ct += 1
print(f"spatially indexed {ct} points (quadtree)")
# from .tmp_kdtree import create as create_kdtree
## from .tmp_mut_kdtree import create as create_kdtree
# pp.kdtree = create_kdtree(point_list=pts.keys(), dimensions=2)
# pp.kdtree = None
# def output_points(pts, fh):
# for pt in pts:
# fh.write("POINT({0[0]} {0[1]})\n".format(pt))
# with open('/tmp/kdtree_pts.wkt', 'w') as fh:
# fh.write('wkt\n')
# pts = pp.kdtree.range_search( (float('-inf'), float('-inf')), (float('+inf'), float('+inf')) )
## output_points((node.data for node in pp.kdtree.inorder()), fh)
## output_points(pts, fh)
## raw_input('paused')
# check if we did not mix up things
for edge_id in edges:
edge = edges[edge_id]
assert edge_id in faces[edge.left_face_id].edges
assert ~edge_id in faces[edge.right_face_id].edges
# stars
# stars = pp.stars
# for edge_id in edges:
# stars[edges[edge_id].start_node_id].append(edge_id) # outgoing: +
# stars[edges[edge_id].end_node_id].append(~edge_id) # incoming: -
# nodes
nodes = pp.nodes
for edge_id in edges:
edge = edges[edge_id]
# start node
if edge.start_node_id not in nodes:
nodes[edge.start_node_id] = Node(edge.start_node_id, edge.geometry[0], [])
nodes[edge.start_node_id].star.append(edge_id)
# end node
if edge.end_node_id not in nodes:
nodes[edge.end_node_id] = Node(edge.end_node_id, edge.geometry[-1], [])
nodes[edges[edge_id].end_node_id].star.append(~edge_id)
# sort edges counter clockwise (?) around a node
sort_on_angle = partial(get_correct_angle, edges=edges)
# for node_id in stars.keys():
# stars[node_id].sort(key=sort_on_angle)
for node_id in nodes.keys():
nodes[node_id].star.sort(key=sort_on_angle)
print(f"{time.time()-t0:.3f}s node stars")
t0 = time.time()
# based on the wheels we find, we can obtain the size of the faces
for face in faces.values():
wheels = get_wheel_edges(face.edges, pp)
rings = [get_geometry_for_wheel(wheel, pp) for wheel in wheels]
rings = [(abs(ring.signed_area()), ring) for ring in rings]
rings.sort(reverse=True, key=lambda x: x[0])
area, largest_ring = rings[0]
perimeter = largest_ring.length
iso_perimetric_quotient = (4.0 * math.pi * area) / (perimeter * perimeter)
# FIXME: should we subtract hole regions from the faces?
face.info["area"] = area
face.info["perimeter"] = perimeter
face.info["ipq"] = iso_perimetric_quotient
face.info["priority"] = face.info["area"] * face.info["ipq"]
print(f"{time.time()-t0:.3f}s area calculation")
# when we ask the rtree the whole domain, we should get all edges
# assert len(pp.edge_rtree.intersection(dataset_envelope)) == len(edges)
# return the planar partition
return pp
from quadtree import Rectangle, QuadTree, Point, Circle
from time import time
import matplotlib.pyplot as plt
from threading import Thread
width = 360
height = 180
no_of_points = 10000
boundary = Rectangle(-180, -90, width, height)
qd = QuadTree(boundary)
all_points = []
start = time()
for i in range(0, no_of_points):
lng = random.randint(-180, width + 1)
lat = random.randint(-90, height + 1)
point = Point(lng, lat)
t = time()
qd.insert(point)
# print('point ',i,' inserted in ',time()-t,' seconds')
all_points.append(point)
# print(no_of_points,' points inserted in ',time()-start,' seconds')
found_mt = []
from quadtree import QuadTree, Bounds, Point
import json
import matplotlib.pyplot as plt
if __name__ == '__main__':
my_tree = QuadTree(Bounds(0, 0, 400, 400), max_objects=4, max_level=5)
# get point data from json file
with open('../tests/example_data.json', 'r') as f:
json_data = json.loads(f.read())
point_set = json_data['data']
# insert points
for point in point_set:
my_tree.insert(Point(point['x'], point['y'], point['value']))
# visualize quadtree
objects = my_tree.retrieve(Bounds(200, 200, 50, 50))
objects_intersects = my_tree.retrieve_intersections(Bounds(200, 200, 50, 50))
nearest_neighbors = my_tree.nearest_neighbors(Point(225, 225), radius=25)
print('collide ------------ ', len(objects))
print('intersects --------- ', len(objects_intersects))
print('nearest neighbors -- ', len(nearest_neighbors))
my_tree.visualize()
for d in node.data:
pygame.draw.rect(surface, d.data, pygame.Rect(d.x, d.y, d.w, d.h))
display = pygame.display.set_mode((640, 640))
clock = pygame.time.Clock()
mdown = False
mx1 = 0
my1 = 0
mx2 = 0
my2 = 0
selected = []
quadtree = QuadTree(8, 640, 640)
keep_going = True
while keep_going:
for event in pygame.event.get():
if event.type == pygame.QUIT:
keep_going = False
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_a:
x = random.randint(0, 600)
y = random.randint(0, 600)
w = random.randint(3, 40)
h = random.randint(3, 40)
color = (random.randint(64, 250), random.randint(64, 250), random.randint(64, 250))
quadtree.add(RectData(x, y, w, h, color))
def buildStructure(cls, screen_x, screen_y, resolution=8):
cls.qt = QuadTree(resolution, screen_x, screen_y)
def setUp(self) -> None:
self.quadtree = QuadTree(Bounds(0, 0, 400, 400),
max_objects=4,
max_level=5)
from quadtree import QuadTree
import models
timestep = 0.1
gravitational_constant = 0.000005
particles = models.n_bodies(1000)
tree = QuadTree(particles, timestep, 10, gravitational_constant, 0.5)
while True:
tree.step()
