def update(self, current_time): self.organism_quad_tree = QuadTree(Rectangle(0, 0, 1, 1)) for blob in self.organism_list: blob.update(current_time) if blob.is_dead(): self.kill_organism(blob, is_in_tree=False) else: for offspring in blob.produce_offspring(current_time): self.add_blob(offspring) self.organism_quad_tree.insert(blob)
def init_clusters(self, nodes): node_dicts = [] x_list = [nd[0] for nd in nodes] y_list = [nd[1] for nd in nodes] x_list.sort() y_list.sort() sw = (x_list[0], y_list[0]) ne = (x_list[-1], y_list[-1]) self.qt = QuadTree(8, sw, ne, get_point, False) for i in range(0, len(nodes)): node_dict = {} node_dict['id'] = i node_dict['xy'] = nodes[i] self.qt.add(node_dict)
class Organisms: def __init__(self): self.organism_list = [] self.organism_quad_tree = QuadTree(Rectangle(0, 0, 1, 1)) def update(self, current_time): self.organism_quad_tree = QuadTree(Rectangle(0, 0, 1, 1)) for blob in self.organism_list: blob.update(current_time) if blob.is_dead(): self.kill_organism(blob, is_in_tree=False) else: for offspring in blob.produce_offspring(current_time): self.add_blob(offspring) self.organism_quad_tree.insert(blob) def add_blob(self, blob): self.organism_list += [blob] self.organism_quad_tree.insert(blob) def add_random_blobs(self, number_of_new_blobs=1, current_time=0): for i in range(number_of_new_blobs): new_blob = Blob(time_of_birth=current_time) self.add_blob(new_blob) def kill_organism(self, organism, is_in_tree=True): self.organism_list.remove(organism) if is_in_tree: self.organism_quad_tree.remove(organism) def find_close_organisms(self, domain: Rectangle): close_organisms = [] self.organism_quad_tree.retrieve_close_objects(domain, close_organisms) return close_organisms def update_extrema_of_organisms(self): for organism in self.organism_list: organism.restrict_to_extrema()
def __init__(self): self.organism_list = [] self.organism_quad_tree = QuadTree(Rectangle(0, 0, 1, 1))
class KMeansHelper(object): """Helper class to manage seeding, finding and updating clustered node assignment for KMeans""" def __init__(self): qt = None pass def seed(self, k, nodes): """ splits nodes based on x and y means of each of k partitions of nodes sorted by x and y """ x_list = [nd[0] for nd in nodes] y_list = [nd[1] for nd in nodes] x_list.sort() y_list.sort() parts = range(0, len(nodes), (len(nodes)-1)/k) x_means = [sum(x_list[i:j])/len(x_list[i:j]) for i, j in zip(parts, parts[1:len(parts)])] y_means = [sum(y_list[i:j])/len(y_list[i:j]) for i, j in zip(parts, parts[1:len(parts)])] k_nodes = zip(x_means, y_means) return k_nodes def init_clusters(self, nodes): node_dicts = [] x_list = [nd[0] for nd in nodes] y_list = [nd[1] for nd in nodes] x_list.sort() y_list.sort() sw = (x_list[0], y_list[0]) ne = (x_list[-1], y_list[-1]) self.qt = QuadTree(8, sw, ne, get_point, False) for i in range(0, len(nodes)): node_dict = {} node_dict['id'] = i node_dict['xy'] = nodes[i] self.qt.add(node_dict) def find_nearest(self, node): k_node = self.qt.find_nearest(node) return k_node['id'] def update_clusters(self, cluster_assignments): """ Returns a new set of cluster nodes based on average of assigned points """ cluster_list = [] for k_id in range(0, len(cluster_assignments)): points = cluster_assignments[k_id] if len(points) > 0: x_list = [pt[0] for pt in points] y_list = [pt[1] for pt in points] x_list.sort() y_list.sort() x_mean = sum(x_list)/len(x_list) y_mean = sum(y_list)/len(y_list) cluster_list.append([x_mean, y_mean]) return cluster_list
def setUp(self): self.tree = QuadTree(0, 0, 200, 200)
class QuadTreeTests(unittest.TestCase): def setUp(self): self.tree = QuadTree(0, 0, 200, 200) def test_insert_should_increase_count(self): items = [BoundableObject(50, 50, 60, 60)] * 3 for item in items: self.tree.add_object(item) self.assertEqual(len(self.tree), len(items)) def test_report_empty_quadrant_should_return_empty(self): items = [ BoundableObject(10, 0, 20, 10), BoundableObject(110, 0, 120, 10), BoundableObject(10, 110, 20, 120), BoundableObject(50, 0, 60, 10) ] for item in items: self.tree.add_object(item) # after 4 inserts our root splits into 4 and the third quadrant is empty first_quadrant = self.tree.get_subquandrant(1) elements = self.tree.report( first_quadrant ) # get everthing that intersects with our third quadrant self.assertEqual(len(elements), 0) def test_report_from_non_empty_quadrants_should_return_elements(self): expected_quadrant_items = [ [BoundableObject(110, 101, 120, 110)], # first quadrant [BoundableObject(10, 110, 20, 120)], # second quadrant [BoundableObject(10, 0, 20, 10), BoundableObject(50, 0, 60, 10)], # third quadrant [] # fourth quadrant ] # add the objects to the tree for obj in [ obj for quadrant in expected_quadrant_items for obj in quadrant ]: self.tree.add_object(obj) first_quadrant = self.tree.get_subquandrant(1) f_q_elements = self.tree.report(first_quadrant) self.assertEqual(f_q_elements, expected_quadrant_items[0]) second_quadrant = self.tree.get_subquandrant(2) s_q_elements = self.tree.report(second_quadrant) self.assertEqual(s_q_elements, expected_quadrant_items[1]) third_quadrant = self.tree.get_subquandrant(3) t_q_elements = self.tree.report(third_quadrant) self.assertEqual(t_q_elements, expected_quadrant_items[2]) fourth_quadrant = self.tree.get_subquandrant(4) fourth_q_elements = self.tree.report(fourth_quadrant) self.assertEqual(fourth_q_elements, expected_quadrant_items[3]) def test_foreach_dfs_should_fuck_you(self): items = [BoundableObject(2, 2, 3, 3)] * 100 for item in items: self.tree.add_object(item) def assert_function(_, __, depth): self.assertEqual(self.tree.max_depth, depth) self.tree.foreach_dfs(assert_function) def test_report_many_random_elements_should_return_all_colliders(self): object_count = 10000 shepherd = BoundableObject(10, 20, 20, 30) items = [] self.tree.add_object(shepherd) for _ in range(object_count): x = random.randint(0, self.tree.x2 - 11) x2 = x + 10 y = random.randint(0, self.tree.y2 - 11) y2 = y + 10 obj = BoundableObject(x, y, x2, y2) items.append(obj) self.tree.add_object(obj) expected_collisions = self.search_for_collisions_in_a_list( shepherd, items) result_collisions = self.search_for_collisions_in_a_tree(shepherd) self.assertEqual(len(expected_collisions), len(result_collisions)) print(expected_collisions) self.assertCountEqual(expected_collisions, result_collisions) def search_for_collisions_in_a_tree(self, shepherd): result = [] collision_candidates = self.tree.report(shepherd) for col_candidate in collision_candidates: if col_candidate.intersects( shepherd) and col_candidate != shepherd: result.append(col_candidate) return result def search_for_collisions_in_a_list(self, shepherd, objs): result = [] for obj in objs: if shepherd.intersects(obj) and shepherd != obj: result.append(obj) return result
def init_quad_tree(self, cam_img_dim, min_cell_size): qt = QuadTree(cam_img_dim[0], cam_img_dim[1], min_cell_size) qt.create_tree(self.cb_split_node) return qt