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()