def is_continuation(gold_node, bin_test_list, add_to_list=True, DEBUG=False): if not gold_node.has_children(): return False ancestor_node_matches = [] gold_path_length = SwcNode() # find the first matched ancestor of the gold_node ancestor_match = None ancestor_gold = gold_node.parent gold_path_length.path_length = gold_node.data.path_length gold_path_length.xy_path_length = gold_node.data.xy_path_length gold_path_length.z_path_length = gold_node.data.z_path_length is_match = False ancestor_match = False is_left = False if DEBUG: print( "gold_path_length: path_length {}, xy_path_length {}, z_path_length {}" .format(gold_path_length.path_length, gold_path_length.xy_path_length, gold_path_length.z_path_length)) while ancestor_gold is not None and not ancestor_match: if ancestor_gold in g_matches.keys(): ancestor_match = g_matches[ancestor_gold] if is_sub_continuation(gold_node, ancestor_gold, ancestor_match, is_left, gold_path_length, bin_test_list, add_to_list): return True ancestor_match = True ancestor_node_matches = get_nearby_node_list(ancestor_gold, bin_test_list, check_previous_use=True, g_matches=g_matches) for a_n_node in ancestor_node_matches: if is_sub_continuation(gold_node, ancestor_gold, ancestor_match, is_left, gold_path_length, bin_test_list, add_to_list): return True gold_path_length.path_length += ancestor_gold.data.path_length gold_path_length.xy_path_length += ancestor_gold.data.xy_path_length gold_path_length.z_path_length += ancestor_gold.data.z_path_length is_left = ancestor_gold.is_left() ancestor_gold = ancestor_gold.parent # failed return False
def test_rtree(self): swctree = SwcTree() swctree.load( "D:\gitProject\mine\PyNeval\\test\data_example\\test\\30_18_10_test.swc" ) rtree = get_edge_rtree(swctree) id_edge_dict = get_idedge_dict(swctree) point = SwcNode(center=[22.5822, 172.856, 300.413]) (line_tuple, dis) = get_nearby_edges(rtree, point, id_edge_dict, point.radius())[0] print( point.distance( Line(coords=[[15.3249, 130.821, 327.012], [19.8495, 132.384, 323.395]]))) print("dis = {}, line:{}, {}".format(dis, line_tuple[0]._pos, line_tuple[1]._pos))
def swc_get_foot(swc_node, swc_line_tuple): e_node = swc_node.get_center() e_line = Line(e_node_1=swc_line_tuple[0].get_center(), e_node_2=swc_line_tuple[1].get_center()) e_foot = e_node.get_closest_point(e_line) swc_foot = SwcNode(center=e_foot, radius=1.0, ntype=0) return swc_foot
def reconstruct_tree(swc_tree, is_activate, down_pa): new_swc_tree = SwcTree() node_list = [node for node in PreOrderIter(swc_tree.root())] id_node_map = {-1: new_swc_tree.root()} for node in node_list: if node.is_virtual(): continue if is_activate[node.get_id()]: tmp_node = SwcNode() tmp_node._id = node.get_id() tmp_node._type = node._type tmp_node._pos = copy.copy(node._pos) tmp_node._radius = node._radius pa = id_node_map[down_pa[node].get_id()] tmp_node.parent = pa id_node_map[node.get_id()] = tmp_node return new_swc_tree
def adjust_vertical_tree(node, line_tuple_a, line_tuple_b, vertical_tree, vertical_id): # adjust vertical tree swc_foot_a = swc_get_foot(node, line_tuple_a) swc_foot_b = swc_get_foot(node.parent, line_tuple_b) tmp_node = SwcNode(center=node._pos, radius=node.radius() / 2, ntype=node._type) tmp_node_p = SwcNode(center=node.parent._pos, radius=node.parent.radius() / 2, ntype=node.parent._type) tmp_node.set_id(vertical_id) vertical_id += 1 vertical_tree.append(tmp_node.to_swc_str(-1)) tmp_node_p.set_id(vertical_id) vertical_id += 1 vertical_tree.append(tmp_node_p.to_swc_str(-1)) swc_foot_a.set_id(vertical_id) vertical_id += 1 vertical_tree.append(swc_foot_a.to_swc_str(tmp_node.get_id())) swc_foot_b.set_id(vertical_id) vertical_id += 1 vertical_tree.append(swc_foot_b.to_swc_str(tmp_node_p.get_id())) return vertical_id
def get_des_in_for_continuation(first_node, ancestor_node, ancestor_match, ancestor_trajectory, path_length_map, bin_test_list, DEBUG=False): spe_ancestor_trajectory = ancestor_trajectory test_matches = [] stack = queue.LifoQueue() stack.put(first_node) while not stack.empty(): gold_node = stack.get() des_tra = gold_node.data.parent_trajectory # print("gold_node id = {}".format(gold_node.data.get_id())) if gold_node in g_matches: test_matches.append(g_matches[gold_node]) else: test_matches = get_nearby_node_list(gold_node, bin_test_list, check_previous_use=False) prev_path_length = path_length_map[gold_node.parent] gold_path_length = SwcNode() gold_path_length.path_length = gold_node.data.path_length + prev_path_length.path_length gold_path_length.xy_path_length = gold_node.data.xy_path_length + prev_path_length.xy_path_length gold_path_length.z_path_length = gold_node.data.z_path_length + prev_path_length.z_path_length path_length_map[gold_node] = gold_path_length for child_match in test_matches: test_path_length = SwcNode() test_path_length.add_data(child_match.data) tmp_node = child_match.parent # print("child match id = {}".format( # child_match.data.get_id())) done = (tmp_node == ancestor_match) while not done: if tmp_node in path_length_map.keys(): prev_path_length = path_length_map[tmp_node] test_path_length.add_length(prev_path_length) done = True else: test_path_length.add_length(tmp_node.data) tmp_node = tmp_node.parent if tmp_node is None: done = True if tmp_node == ancestor_match: done = True if tmp_node is None: if DEBUG: print("[info]: descendant not match") else: path_length_map[child_match] = test_path_length if ancestor_trajectory.get_x( ) == -1.0 or ancestor_trajectory.get_z() == -1.0: spe_ancestor_trajectory = get_trajectory_for_path( ancestor_node, gold_node) if ancestor_trajectory.get_x != -1.0: spe_ancestor_trajectory.set_x( ancestor_trajectory.get_x()) spe_ancestor_trajectory.set_y( ancestor_trajectory.get_y()) if ancestor_trajectory.get_z != -1.0: spe_ancestor_trajectory.set_z( ancestor_trajectory.get_z()) test_xy_path_length = test_path_length.xy_path_length \ + get_end_node_XY_dis_diff(ancestor_node.data, spe_ancestor_trajectory, ancestor_match.data) \ + get_end_node_XY_dis_diff(gold_node.data, des_tra, child_match.data) test_z_path_length = test_path_length.z_path_length \ + get_end_node_Z_dis_diff(ancestor_node.data, spe_ancestor_trajectory, ancestor_match.data) \ + get_end_node_Z_dis_diff(gold_node.data, des_tra, child_match.data) if path_length_matches(gold_path_length, test_xy_path_length, test_z_path_length) < 1: return child_match if gold_node.has_children() and gold_node not in g_matches: stack.put(gold_node.left_son) stack.put(gold_node.right_son) return None
def get_best_match(match_list, gold_node, bin_test_list, DEBUG=False): if DEBUG: print("Determining best match") confirm_list = [] gold_data = gold_node.data des_branch_left = {} trajactory_map = {} if gold_node.has_children(): nearby_list = [] path_length_map = {} path_length_map[gold_node] = SwcNode() target_dis_list = [] for test_node in match_list: target_distances = SwcNode() target_distances.xy_path_length = gold_node.data.distance( test_node.data, _2D) target_distances.z_path_length = gold_node.data.distance( test_node.data, _2D) target_dis_list.append(target_distances) current_list = [] current_list.append(gold_node.left_son) trajactory_map[gold_node.left_son] = gold_node.data.left_trajectory des_branch_left[gold_node.left_son] = True current_list.append(gold_node.right_son) trajactory_map[gold_node.right_son] = gold_node.data.right_trajectory des_branch_left[gold_node.right_son] = False target_tra = EuclideanPoint while len(current_list) > 0 and len(confirm_list) == 0: next_list = [] for des_node in current_list: target_tra = trajactory_map[des_node] if target_tra.get_x() == -1.0 or target_tra.get_z() == -1.0: tmp_tra = get_trajectory_for_path(gold_node, des_node) if target_tra.get_x() == -1.0: target_tra.set_x(tmp_tra.get_x()) target_tra.set_y(tmp_tra.get_y()) if target_tra.get_z() == -1.0: target_tra.set_z(tmp_tra.get_z()) des_tra = des_node.data.parent_trajectory if des_node.has_children(): next_list.append(des_node.left_son) next_list.append(des_node.right_son) trajactory_map[des_node.left_son] = target_tra trajactory_map[des_node.right_son] = target_tra gold_path_length = SwcNode() gold_path_length.add_length(des_node.data) parent_path_length = path_length_map[des_node.parent] gold_path_length.add_length(parent_path_length) path_length_map[des_node] = gold_path_length nearby_list = get_nearby_node_list(des_node, bin_test_list, check_previous_use=True, g_matches=g_matches) for test_node in nearby_list: test_des_node = test_node test_path_length = SwcNode() des_dis = SwcNode() des_dis.xy_path_length = des_node.data.distance( test_node.data, _2D) des_dis.z_path_length = math.fabs(des_node.data.get_z() - test_node.data.get_z()) while test_node.parent is not None: test_path_length.add_length(test_node.data) test_node = test_node.parent tmp_list = [] for match in match_list: if test_node == match: test_XY_path_length = test_path_length.xy_path_length + \ get_end_node_XY_dis_diff(gold_data, target_tra, test_node.data) + \ get_end_node_XY_dis_diff(des_node.data, des_tra, test_des_node.data) test_Z_path_length = test_path_length.z_path_length + \ get_end_node_Z_dis_diff(gold_data, target_tra, test_node.data) + \ get_end_node_Z_dis_diff(des_node.data, des_tra, test_des_node.data) if path_length_matches(gold_path_length, test_XY_path_length, test_Z_path_length) < 1: confirm_list.append(match) tmp_list.append(match) for node in tmp_list: match_list.remove(node) while len(tmp_list): tmp_list.pop() current_list = nearby_list if len(confirm_list) == 1: return confirm_list[0] if len(confirm_list) == 0: confirm_list = match_list dis = 0 closest_dis = -1 closest_match = None for test_node in confirm_list: dis = test_node.data.distance(gold_node.data) if closest_dis == -1 or dis < closest_dis: closest_dis = dis closest_match = test_node return closest_match
def get_match_path_length_difference(gold_node, test_node, bin_gold_list, bin_test_list): if test_node.parent is None: return 0 gold_target = gold_node gold_swc_path_length = SwcNode() gold_swc_path_length.add_length(gold_node.data) test_swc_path_length = SwcNode() test_swc_path_length.add_length(test_node.data) test_path_XY_mod = get_end_node_XY_dis_diff( gold_node.data, gold_node.data.parent_trajectory, test_node.data) test_path_Z_mod = get_end_node_Z_dis_diff(gold_node.data, gold_node.data.parent_trajectory, test_node.data) test_swc_path_length.xy_path_length += test_path_XY_mod test_swc_path_length.z_path_length += test_path_Z_mod is_branch_left = gold_node.is_left() gold_node = gold_node.parent test_node = test_node.parent ancestor_trajectory = EuclideanPoint() checked_node = set() no_match = True no_done = True while no_match and no_done: if is_in_threshold(gold_node, test_node): gold_data = gold_node.data if is_branch_left: ancestor_trajectory = gold_data.left_trajectory else: ancestor_trajectory = gold_data.right_trajectory if ancestor_trajectory.get_x() == TRAJECTORY_NONE or \ ancestor_trajectory.get_z() == TRAJECTORY_NONE: tmp_trajectory = get_trajectory_for_path( gold_node, gold_target) if ancestor_trajectory.get_x() == TRAJECTORY_NONE: ancestor_trajectory.set_x(tmp_trajectory.get_x()) ancestor_trajectory.set_y(tmp_trajectory.get_y()) if ancestor_trajectory.get_z() == TRAJECTORY_NONE: ancestor_trajectory.set_z(tmp_trajectory.get_z()) test_XY_path_length = test_swc_path_length.xy_path_length + \ get_end_node_XY_dis_diff(gold_data, ancestor_trajectory, test_node.data) test_Z_path_length = test_swc_path_length.z_path_length + \ get_end_node_Z_dis_diff(gold_data, ancestor_trajectory, test_node.data) percent_error = path_length_matches(gold_swc_path_length, \ test_XY_path_length, \ test_Z_path_length) if percent_error < 1: return percent_error else: return 1 else: if gold_swc_path_length.path_length < test_swc_path_length.path_length: if gold_node.parent is None: no_done = False else: nearby_nodes = get_nearby_node_list( gold_node, bin_test_list, False) for node in nearby_nodes: if node in checked_node: no_done = False break checked_node.add(gold_node) gold_swc_path_length.add_length(gold_node.data) is_branch_left = gold_node.is_left() gold_node = gold_node.parent else: if test_node.parent is None: no_done = False else: nearby_nodes = get_nearby_node_list( test_node, bin_gold_list, False) for node in nearby_nodes: if node in checked_node: no_done = False break checked_node.add(test_node) test_swc_path_length.add_length(test_node.data) test_node = test_node.parent return 1
def LCA(node1, node2, kca): node1_list = [] node1 = node1.parent while node1 != kca: node1_list.append(node1) node1 = node1.parent node1 = node2.parent while node2 != kca and node2 is not None: if node2 in node1_list: return node2 node2 = node2.parent return None def is_within_dis_match_threshold(node1, node2): if isinstance(node1, BinaryNode): node1 = node1.data if isinstance(node2, BinaryNode): node2 = node2.data return node1.distance(node2, _2D) <= g_xy_threshold * 3 \ and math.fabs(node1.get_z() - node2.get_z()) < g_z_threshold * 3 + 0.1 if __name__ == "__main__": gold = SwcNode(center=[2, 3, 4]) test = SwcNode(center=[1, -1, 5]) is_in_threshold(gold, test)