def fetch_compartments_meshes(compartments, segment_id, split_index=0, original_mesh=None, verbose=False, plot_mesh = False, mesh_alpha = 1): """ Purpose: to get the requested compartment meshes saved off Ex: import apical_utils as apu pv.fetch_compartments_meshes(apu.default_compartment_order, segment_id, split_index, original_mesh = original_mesh, plot_mesh=True) """ compartments = nu.convert_to_array_like(compartments) if original_mesh is None: original_mesh = du.fetch_segment_id_mesh(segment_id) comp_meshes = [pv.fetch_compartment_mesh(c,segment_id,split_index, original_mesh=original_mesh) for c in compartments] if plot_mesh: comp_meshes_colors = apu.colors_from_compartments(compartments) nviz.plot_objects(original_mesh, meshes = comp_meshes, meshes_colors=comp_meshes_colors, mesh_alpha=mesh_alpha) return comp_meshes
def fetch_proofread_mesh(segment_id,split_index = 0, original_mesh = None, return_error_mesh = False, plot_mesh = False ): if original_mesh is None: original_mesh = du.fetch_segment_id_mesh(segment_id) proof_mesh = pv.fetch_compartment_mesh("neuron", segment_id, split_index, original_mesh=original_mesh, ) if return_error_mesh: error_mesh = tu.subtract_mesh(original_mesh,proof_mesh) if plot_mesh: nviz.plot_objects(proof_mesh, meshes=[error_mesh], meshes_colors=["red"]) return proof_mesh,error_mesh if plot_mesh: nviz.plot_objects(proof_mesh, #meshes=[error_mesh], #meshes_colors=["red"] ) return proof_mesh
def nucleus_mesh_from_segment_id( segment_id, split_index = 0, nuclei_size=2500, verbose = False, plot_nuclei_with_mesh=False): nucleus_center = pv.nucleus_center_from_segment_id(segment_id,split_index) if verbose: print(f"nucleus_center= {nucleus_center}") if nucleus_center is None: return None nucleus_mesh = tu.sphere_mesh(nucleus_center,radius=nuclei_size) if plot_nuclei_with_mesh: proof_mesh = du.fetch_proofread_neuron(segment_id,split_index) nviz.plot_objects(main_mesh=proof_mesh, meshes=[nucleus_mesh], meshes_colors="red", mesh_alpha = 1, scatters=[nucleus_center.reshape(-1,3)], scatter_size=1) return nucleus_mesh
def fetch_segment_id_mesh(segment_id, plot_mesh=False): """ Gets the undecimated mesh """ seg_mesh = ((decimated_mesh_table & dict(segment_id=segment_id)).fetch1("mesh")) if plot_mesh: import neuron_visualizations as nviz nviz.plot_objects(seg_mesh) return seg_mesh
def mesh_from_seg_id(segment_id, cloudvolume_obj=cloudvolume_raw, plot=False): """ Purpose: To return a mesh object from downloading through the cloudvolume interface """ mesh = cloudvolume_obj.mesh.get(segment_id) mesh_verts = list(mesh.values())[0].vertices mesh_faces = list(mesh.values())[0].faces mesh_tri = trimesh.Trimesh(vertices=mesh_verts, faces=mesh_faces) if plot: nviz.plot_objects(meshes=[mesh_tri]) return mesh_tri
def plot_df_xyz(df,branch_size = 1,soma_size = 4, soma_color = "blue",branch_color = "red", col_suffix = "", flip_y = True, **kwargs,): soma_center = soma_center_from_df(df) all_points = df[[f"x{col_suffix}",f"y{col_suffix}",f"z{col_suffix}"]].to_numpy().reshape(-1,3) s_center = soma_center_from_df(df,col_suffix=col_suffix) nviz.plot_objects(scatters=[all_points,s_center.reshape(-1,3)], scatters_colors=[branch_color,soma_color], scatter_size=[branch_size,soma_size], flip_y = flip_y, axis_box_off = False, **kwargs)
def make(self, key): print(key) segment_id = key['segment_id'] split_index = key['split_index'] version = key.get("decimation_version", 0) mesh = pv.fetch_proofread_mesh(segment_id, split_index=split_index) #mesh = (minnie.Mesh & key).fetch1('mesh') if verbose: print( f"Mesh size BEFORE DECIMATION: n_vertices = {len(mesh.vertices)}, n_faces = {len(mesh.faces)}" ) if verbose: st = time.time() dec_mesh = tu.decimate(mesh, decimation_ratio_global) if verbose: print(f"Total time for decimation: {time.time() - st}") print( f"Mesh size AFTER DECIMATION: n_vertices = {len(dec_mesh.vertices)}, n_faces = {len(dec_mesh.faces)}" ) if plot_decimation: print(f"Decimated Mesh") nviz.plot_objects(dec_mesh) vertices = dec_mesh.vertices faces = dec_mesh.faces filepath = self.make_file( segment_id=segment_id, split_index=split_index, decimation_ratio=decimation_ratio_global, vertices=vertices, faces=faces, version=version, ) if verbose: print(f"filepath = {filepath}") self.insert1(dict( key, n_vertices=len(vertices), n_faces=len(faces), mesh=filepath, decimation_ratio_after_proof=decimation_ratio_global), allow_direct_insert=True)
def fetch_compartment_mesh(compartment, segment_id, split_index=0, original_mesh=None, verbose=False, plot_mesh = False): """ Purpose: To get the mesh belonging to a certain compartment Ex: original_mesh = du.fetch_segment_id_mesh(segment_id) comp_mesh = pv.fetch_compartment_mesh("apical_shaft", segment_id, split_index, original_mesh=original_mesh, verbose = True, plot_mesh = True, ) """ if compartment == "apical_total": compartment_faces = np.concatenate([pv.fetch_compartment_faces(compartment = c, segment_id=segment_id, split_index=split_index, ) for c in apu.apical_total]).astype("int") else: compartment_faces = pv.fetch_compartment_faces(compartment = compartment, segment_id=segment_id, split_index=split_index, ) if verbose: print(f"# of faces = {len(compartment_faces)}") if original_mesh is None: original_mesh = du.fetch_segment_id_mesh(segment_id) compartment_mesh = original_mesh.submesh([compartment_faces],append=True) if not tu.is_mesh(compartment_mesh): compartment_mesh = tu.empty_mesh() if plot_mesh: print(f"Plotting {compartment}") nviz.plot_objects(original_mesh, meshes=[compartment_mesh], meshes_colors="red") return compartment_mesh
def skeleton_from_seg_id( segment_id, cloudvolume_obj=cloudvolume_raw, plot=False, ): """ Purpose: To return a skeleton object from downloading through the cloudvolume interface """ skel = cloudvolume_obj.skeleton.get(segment_id) skeleton = sk.convert_nodes_edges_to_skeleton(skel.vertices, skel.edges) #skeleton_proof = sk.convert_nodes_edges_to_skeleton(skeleton.vertices,skel_proof.edges) if plot: nviz.plot_objects(skeletons=[skeleton]) return skeleton
def fetch_soma_mesh(segment_id, split_index = None, plot_soma = False, return_sdf=False, verbose = False, ): """ Purpose: To retrieve the soma of the proofread mesh 1) Get the soma center x,y,z of segment """ segment_id,split_index = pv.segment_id_and_split_index(segment_id, split_index) soma_x,soma_y,soma_z = pv.features_from_proofread_table( segment_id = segment_id, split_index = split_index, feature_names = ["soma_x","soma_y","soma_z"], return_dict = False, ) if verbose: print(f"For segment_id = {segment_id}, split_index = {split_index} ") print(f"soma_x = {soma_x}, soma_y= {soma_y}, soma_z= {soma_z}") soma_mesh,soma_run_time,soma_sdf = du.get_soma_mesh_list_singular( segment_id = segment_id, soma_center = [soma_x,soma_y,soma_z], verbose = verbose ) if plot_soma: print(f"Plotting soma: {soma_mesh}") nviz.plot_objects(soma_mesh) if return_sdf: return soma_mesh,soma_sdf else: return soma_mesh
def fetch_error_mesh(segment_id,split_index = 0, original_mesh = None, plot_mesh = False): """ Ex: pv.fetch_error_mesh(segment_id, split_index, original_mesh=original_mesh, plot_mesh = True) """ proof_mesh,error_mesh = pv.fetch_proofread_mesh(segment_id, split_index = split_index, original_mesh = original_mesh, return_error_mesh = True) if plot_mesh: nviz.plot_objects(proof_mesh, meshes=[error_mesh], meshes_colors=["red"]) return error_mesh
def fetch_compartment_skeleton(compartment, segment_id, split_index = 0, verbose = False, plot_skeleton = False, original_mesh = None, ): """ Purpose: To retrieve the datajoint stored skeleton for that compartment Ex: comp_skeleton = pv.fetch_compartment_skeleton("apical_shaft", segment_id, split_index, plot_skeleton = True) """ segment_id,split_index = pv.segment_id_and_split_index(segment_id,split_index) if compartment == "apical_total": comp_skeleton = sk.stack_skeletons([(du.proofreading_stats_table() & dict(segment_id=segment_id, split_index=split_index)).fetch1(f"{c}_skeleton") for c in apu.apical_total]) else: comp_skeleton = (du.proofreading_stats_table() & dict(segment_id=segment_id, split_index=split_index)).fetch1(f"{compartment}_skeleton") if len(comp_skeleton) == 0: comp_skeleton = np.array([]).reshape(-1,2,3) if verbose: print(f"{compartment} skeleton = {sk.calculate_skeleton_distance(comp_skeleton)}") if plot_skeleton: if original_mesh is None: original_mesh = du.fetch_segment_id_mesh(segment_id) nviz.plot_objects(original_mesh, skeletons = [comp_skeleton]) return comp_skeleton
def plot_axon_dendrite_skeletons(segment_id, split_index=0, table=None, axon_skeleton_color="black", plot_mesh=True, axon_color="black", dendrite_color="aqua", mesh_color="green", verbose=True): """ Purpose: Fetch the old mesh and all of the axon skeletons and graph Pseudocode: 1) Fetch the old mesh 2) fetch all of the axon skeletons 3) graph together """ if plot_mesh: neuron_mesh = fetch_segment_id_mesh(segment_id) else: neuron_mesh = None axon_skeleton, dendrite_skeleton = hdju.axon_dendrite_skeleton( segment_id=segment_id, split_index=split_index, table=table) if verbose: print( f"axon_skeleton length = {sk.calculate_skeleton_distance(axon_skeleton)}" ) print( f"dendrite_skeleton length = {sk.calculate_skeleton_distance(dendrite_skeleton)}" ) nviz.plot_objects(main_mesh=neuron_mesh, main_mesh_color=mesh_color, skeletons=[axon_skeleton, dendrite_skeleton], skeletons_colors=[axon_color, dendrite_color])
def fetch_compartments_skeletons( compartments, segment_id, split_index=0, verbose=False, #plotting arguments plot_skeleton = False, original_mesh=None,): """ Ex: import apical_utils as apu pv.fetch_compartments_skeletons(apu.default_compartment_order, segment_id, split_index, original_mesh = original_mesh, plot_skeleton=True) """ compartments = nu.convert_to_array_like(compartments) comp_skeletons = [pv.fetch_compartment_skeleton(c,segment_id,split_index, verbose=verbose) for c in compartments] if plot_skeleton: if original_mesh is None: original_mesh = du.fetch_segment_id_mesh(segment_id) nviz.plot_objects(original_mesh, skeletons=comp_skeletons, skeletons_colors = apu.colors_from_compartments(compartments)) return comp_skeletons
def make(self,key): """ Purpose: To decimate a mesh by a perscribed decimation ratio and algorithm Pseudocode: 1) Get the current mesh,somas,glia and nuclie faces 2) Get the parameters and run the neuron preprocessing """ global_time = time.time() segment_id = key["segment_id"] decomposition_hash = key["decomposition_method"] ver =key["ver"] if verbose: print(f"\n\n--Working on {segment_id}: (decomposition_hash = {decomposition_hash})") # if len(self & dict( # ver=ver, # segment_id = segment_id, # decimation=decomposition_hash)) > 0: # if verbose: # print(f"Already processed {segment_id} (decomposition_hash = {decomposition_hash})") # return #1) st = time.time() mesh = hdju.fetch_segment_id_mesh(segment_id) somas = hdju.get_soma_mesh_list_filtered(segment_id) print(f"somas = {somas}") glia_faces,nuclei_faces = hdju.get_segment_glia_nuclei_faces(segment_id) if plotting: soma_mesh_center = hdju.soma_info_center(segment_id,return_nm=True) # rotating the mesh nviz.plot_objects(hu.align_mesh_from_soma_coordinate(mesh, soma_center=soma_mesh_center )) if verbose: print(f"Collecting Mesh Info: {time.time() - st}") #2) preprocess_args = DecompositionMethod.restrict_one_part_with_hash( decomposition_method_hash).fetch1() fill_hole_size = preprocess_args["fill_hole_size"] current_preprocess_neuron_kwargs = { k:v for k,v in preprocess_args.items() if k in preprocess_neuron_kwargs.keys()} current_spines_kwargs = { k:v for k,v in preprocess_args.items() if k in spines_kwargs.keys()} print(f"current_preprocess_neuron_kwargs = \n{current_preprocess_neuron_kwargs}") print(f"current_spines_kwargs = \n{current_spines_kwargs}") params_to_change = [k for k in current_preprocess_neuron_kwargs if k.split("_")[-1] in ["cgal","map"]] if verbose: print(f"params_to_change = {params_to_change}") current_preprocess_neuron_kwargs["width_threshold_MAP"] = current_preprocess_neuron_kwargs["width_threshold_map"] current_preprocess_neuron_kwargs["size_threshold_MAP"] = current_preprocess_neuron_kwargs["size_threshold_map"] current_preprocess_neuron_kwargs["max_stitch_distance_CGAL"] = current_preprocess_neuron_kwargs["max_stitch_distance_cgal"] del current_preprocess_neuron_kwargs["width_threshold_map"] del current_preprocess_neuron_kwargs["size_threshold_map"] del current_preprocess_neuron_kwargs["max_stitch_distance_cgal"] description = "0_25" st = time.time() neuron_obj = neuron.Neuron( mesh = mesh, somas = somas, segment_id=segment_id, description=description, suppress_preprocessing_print=False, suppress_output=False, calculate_spines=True, widths_to_calculate=["no_spine_median_mesh_center"], glia_faces=glia_faces, nuclei_faces = nuclei_faces, decomposition_type = "meshafterparty", preprocess_neuron_kwargs=current_preprocess_neuron_kwargs, spines_kwargs=spines_kwargs, fill_hole_size=fill_hole_size ) neuron_obj_comb = nru.combined_somas_neuron_obj(neuron_obj, inplace = False, verbose = verbose, plot_soma_limb_network = plotting) if verbose: print(f"\n\n\n---- Total preprocessing time = {time.time() - st}") if plotting: nviz.visualize_neuron(neuron_obj_comb, limb_branch_dict="all", mesh_whole_neuron=True) #3) st = time.time() stats_dict = neuron_obj_comb.neuron_stats(stats_to_ignore = [ "n_boutons", "axon_length", "axon_area", "max_soma_volume", "max_soma_n_faces",], include_skeletal_stats = True, include_centroids= True, voxel_adjustment_vector=voxel_adjustment_vector, ) if verbose: print(f"-- Generating Stats: {time.time() - st}") #4) Save the neuron object in a certain location file_name = f"{neuron_obj_comb.segment_id}_{decomposition_hash}" file_name_decomp = f"{file_name}_{dataset}_decomposition" output_folder=str(target_dir_decomp) st = time.time() ret_file_path = neuron_obj_comb.save_compressed_neuron( output_folder=output_folder, file_name= file_name_decomp, return_file_path=True, export_mesh=False, suppress_output=True, ) ret_file_path_str = str(ret_file_path.absolute()) + ".pbz2" if verbose: print(f"-- Neuron Object Save time: {time.time() - st}") #5) Outputting skeleton object, computing stats and saving st = time.time() sk_stats = nst.skeleton_stats_from_neuron_obj( neuron_obj_comb, include_centroids=True, voxel_adjustment_vector=voxel_adjustment_vector, verbose = True) skeleton = neuron_obj_comb.skeleton file_name_decomp_sk = f"{file_name}_{dataset}_decomposition_sk" ret_sk_filepath = su.compressed_pickle( skeleton, filename = file_name_decomp_sk, folder=str(target_dir_sk), return_filepath=True) if verbose: print(f"ret_sk_filepath = {ret_sk_filepath}") if verbose: print(f"-- Skeleton Generation and Save time: {time.time() - st}") # 6) make the insertions run_time = run_time=np.round(time.time() - global_time,4) # -- decomp table -- decomp_dict = dict(key.copy(), process_version = process_version, index = 0, multiplicity=1, decomposition=ret_file_path_str, run_time = run_time) decomp_dict.update(stats_dict) self.insert1(decomp_dict, allow_direct_insert = True, ignore_extra_fields = True, skip_duplicates=True) self.Object.insert1( decomp_dict, allow_direct_insert = True, ignore_extra_fields = True, skip_duplicates=True) #-- sk table sk_dict = dict(key.copy() , process_version = process_version, index = 0, multiplicity=1, skeleton=ret_sk_filepath, run_time = run_time) sk_dict.update(sk_stats) SkeletonDecomposition.insert1(sk_dict, allow_direct_insert = True, ignore_extra_fields = True, skip_duplicates=True) SkeletonDecomposition.Object.insert1( sk_dict, allow_direct_insert = True, ignore_extra_fields = True, skip_duplicates=True)
def presyn_postsyn_skeletal_path_from_synapse_id( G, synapse_id, synapse_coordinate=None, segment_ids=None, return_nm=return_nm_default, #arguments for plotting the paths plot_skeletal_paths=False, synapse_color="red", synapse_scatter_size=0.2, #, path_presyn_color="yellow", path_postsyn_color="blue", path_scatter_size=0.05, #0.2, plot_meshes=True, mesh_presyn_color="orange", mesh_postsyn_color="aqua", verbose=False, remove_soma_synanpse_nodes=True, ): """ Purpose: To develop a skeletal path coordinates between two segments ids that go through a soma Application: Can then be sent to a plotting function Pseudocode: 1) Get the segment ids paired with that synapse id (get synapse coordinate if not precomputed) 2) Get the proofread skeletons associated with the segment_ids 3) Get the soma center coordinates to determine paths 4) Get the closest skeleton node to the coordinate 5) Find the skeletal path in coordinates 6) Plot the skeletal paths Ex: G["864691136830770542_0"]["864691136881594990_0"] synapse_id = 299949435 segment_ids = ["864691136830770542_0","864691136881594990_0"] mgu.presyn_postsyn_skeletal_path_from_synapse_id( G, synapse_id = synapse_id, synapse_coordinate = None, segment_ids = segment_ids, return_nm = True, verbose = True, plot_skeletal_paths=True, path_scatter_size = 0.04, ) """ #2) Get the proofread skeletons associated with the segment_ids pre_seg, post_seg = mgu.pre_post_node_names_from_synapse_id( G, node_names=segment_ids, synapse_id=synapse_id, return_one=True, ) if synapse_coordinate is None: synapse_coordinate = mgu.synapse_coordinate_from_seg_split_syn_id( G, pre_seg, post_seg, synapse_id, return_nm=True) if verbose: print( f"syn_id = {synapse_id}: pre_seg = {pre_seg}, post_seg = {post_seg}" ) print(f"synapse_coordinate = {synapse_coordinate}") segment_ids = [pre_seg, post_seg] seg_type = ["presyn", "postsyn"] #2) Get the proofread skeletons associated with the segment_ids seg_sks = [ pv.fetch_proofread_skeleton(*pv.segment_id_and_split_index(k)) for k in segment_ids ] #3) Get the soma center coordinates to determine paths soma_coordinates = [ mgu.soma_center_from_segment_id(G, s, return_nm=True) for s in segment_ids ] soma_coordinates_closest = [ sk.closest_skeleton_coordinate(curr_sk, soma_c) for curr_sk, soma_c in zip(seg_sks, soma_coordinates) ] if verbose: print(f"\n Soma Information:") print(f"soma_coordinates = {soma_coordinates}") print(f"soma_coordinates_closest = {soma_coordinates_closest}") #4) Get the closest skeleton node to the coordinate closest_sk_coords = [ sk.closest_skeleton_coordinate(curr_sk, synapse_coordinate) for curr_sk in seg_sks ] #5) Find the skeletal path in coordinates skeletal_coord_paths = [ np.array( sk.convert_skeleton_to_nodes( sk.skeleton_path_between_skeleton_coordinates( starting_coordinate=soma_coordinates_closest[idx], destination_coordinate=closest_sk_coords[idx], skeleton=seg_sks[idx], plot_skeleton_path=False, return_singular_node_path_if_no_path=True)).reshape(-1, 3)) for idx in range(len(seg_sks)) ] if verbose: print(f"Path lengths = {[len(k) for k in skeletal_coord_paths]}") if remove_soma_synanpse_nodes: skeletal_coord_paths_revised = [] for soma_c, syn_c, curr_path in zip(soma_coordinates_closest, closest_sk_coords, skeletal_coord_paths): if len(curr_path) > 1: skeletal_coord_paths_revised.append( nu.setdiff2d(curr_path, np.array([soma_c, syn_c]))) else: skeletal_coord_paths_revised.append( np.mean(np.vstack([soma_c, syn_c]), axis=0).reshape(-1, 3)) skeletal_coord_paths = skeletal_coord_paths_revised if plot_skeletal_paths: print(f"Plotting synapse paths") scatters = [synapse_coordinate.reshape(-1, 3)] scatter_size = [synapse_scatter_size] scatters_colors = [synapse_color] path_colors = [path_presyn_color, path_postsyn_color] for p_sc, p_col in zip(skeletal_coord_paths, path_colors): scatters.append(p_sc) scatter_size.append(path_scatter_size) scatters_colors.append(p_col) meshes = [] meshes_colors = [ mesh_presyn_color, mesh_postsyn_color, ] if plot_meshes: meshes = [pv.fetch_proofread_mesh(k) for k in segment_ids] nviz.plot_objects(meshes=meshes, meshes_colors=meshes_colors, skeletons=seg_sks, skeletons_colors=meshes_colors, scatters=scatters, scatter_size=scatter_size, scatters_colors=scatters_colors) if not return_nm: skeletal_coord_paths = [ k / alu.voxel_to_nm_scaling for k in skeletal_coord_paths ] return skeletal_coord_paths
def plot_mesh_with_somas( segment_id, split_index=None, plot_glia=False, plot_nuclei=False, soma_color=["red", "purple", "pink"], #soma_color = 'red', nuclei_color="black", glia_color="aqua", main_mesh_color=[0., 1., 0., 0.2], plot_soma_center=True, soma_center_size=2, with_skeleton=False, skeleton_color="black", align_from_soma_center=True, verbose=True, ): """ To plot the extracted somas and the glia and nuclei if found Ex: curr_idx = 12_700 segment_id = single_seg_ids[curr_idx] segment_id = 316084337 print(f"segment_id = {segment_id}") print((h01mat.SomaInfo() & dict(segment_id=segment_id)).fetch("celltype","layer")) hdju.plot_mesh_with_somas( segment_id, plot_glia=True, plot_nuclei=True) """ import neuron_visualizations as nviz if verbose: print(f"segment_id = {segment_id}") print((h01mat.SomaInfo() & dict(segment_id=segment_id)).fetch( "celltype", "layer")) seg_mesh = hdju.fetch_segment_id_mesh(segment_id) try: glia_mesh = hdju.glia_mesh(segment_id, mesh=seg_mesh) except: if verbose: print(f"No glia_mesh entry detected") glia_mesh = None try: nuclei_mesh = hdju.nuclei_mesh(segment_id, mesh=seg_mesh) except: if verbose: print(f"No nuclie entry detected") nuclei_mesh = None meshes = list(hdju.get_extracted_somas(segment_id)) meshes_colors = mu.generate_non_randon_named_color_list( len(meshes), user_colors=soma_color) if plot_glia and glia_mesh is not None: if len(glia_mesh.faces) > 0: meshes.append(glia_mesh) meshes_colors.append(glia_color) if verbose: print(f"Empty Glia Mesh") if plot_nuclei and nuclei_mesh is not None: if len(nuclei_mesh.faces) > 0: meshes.append(nuclei_mesh) meshes_colors.append(nuclei_color) if verbose: print(f"Empty Nuclie Mesh") if plot_soma_center: scatters = hdju.soma_info_center(segment_id) scatters = [np.array(scatters).reshape(-1, 3)] else: scatters = None, if with_skeleton: try: skeletons = [ np.array(skeleton_from_decomposition(segment_id, split_index)) ] except: skeletons = [np.array(skeleton_from_decomposition(segment_id))] else: skeletons = [] if align_from_soma_center: import human_utils as hu soma_mesh_center = hdju.soma_info_center(segment_id, return_nm=True) meshes = [ hu.align_mesh(k, soma_center=soma_mesh_center, verbose=False) for k in meshes ] seg_mesh = hu.align_mesh(seg_mesh, soma_center=soma_mesh_center, verbose=False) skeletons = [ hu.align_skeleton( k, soma_center=soma_mesh_center, verbose=False, ) for k in skeletons ] scatters = [ hu.align_array(k, soma_center=soma_mesh_center, verbose=False) for k in scatters ] nviz.plot_objects( seg_mesh, main_mesh_color=main_mesh_color, meshes=meshes, meshes_colors=meshes_colors, scatters=scatters, scatter_size=soma_center_size, skeletons=skeletons, skeletons_colors=skeleton_color, )
def plot_proofread_neuron( segment_id, split_index = 0, cell_type = None, original_mesh = None, plot_proofread_skeleton = False, proofread_mesh_color = "green", proofread_mesh_alpha = None, proofread_skeleton_color = "black", plot_nucleus = True, nucleus_size = 1, nucleus_color = "proofread_mesh_color",#"black", plot_synapses = True, synapses_size = 0.05, synapse_plot_type = "spine_bouton",#"compartment"# "valid_error" #"valid_presyn_postsyn" synapse_compartments = None, synapse_spine_bouton_labels = None, plot_error_synapses = False, valid_synapses_color = "orange", error_synapses_color = "aliceblue", synapse_queries = None, synapse_queries_colors = None, plot_error_mesh = False, error_mesh_color = "black", error_mesh_alpha = 1, compartments = None, #compartments = ["apical_total"] #compartments= ["axon","dendrite"] plot_compartment_meshes = True, compartment_mesh_alpha = 0.3, plot_compartment_skeletons = True, verbose = False, print_spine_colors = True, print_compartment_colors = True, #arguments for plotting more scatters scatters = None, scatter_sizes = 0.2, scatters_colors = "yellow", show_at_end = True, append_figure = False, ): """ Purpose: Will plot the saved proofread information of a neuron Ex: #trying on inhibitory segment_id,split_index = (864691134917559306,0) original_mesh = du.fetch_segment_id_mesh(segment_id) pv.plot_proofread_neuron( segment_id, split_index, original_mesh=original_mesh, plot_error_mesh=False, verbose = True) """ if not append_figure: import ipyvolume as ipv ipv.clear() su.ignore_warnings() if type(segment_id) == str: segment_id,split_index = pv.segment_id_and_split_index_from_node_name(segment_id) if verbose: print(f"Plotting {segment_id}_{split_index} (nucleus_id={pv.nucleus_id_from_segment_id(segment_id,split_index)})") if cell_type is None: cell_type = pv.cell_type_from_segment_id(segment_id,split_index) if verbose: print(f"cell_type = {cell_type}") if synapse_compartments is None: synapse_compartments = apu.compartments_to_plot(cell_type) if synapse_spine_bouton_labels is None: synapse_spine_bouton_labels = spu.spine_bouton_labels_to_plot() if compartments is None: compartments = apu.compartments_to_plot(cell_type) meshes = [] meshes_colors = [] skeletons = [] skeletons_colors = [] meshes_alpha = [] if scatters is not None: scatters_colors = nu.convert_to_array_like(scatters_colors) if len(scatters_colors) == 1: scatters_colors = scatters_colors*len(scatters) scatter_sizes = nu.convert_to_array_like(scatter_sizes) if len(scatter_sizes) == 1: scatter_sizes = scatter_sizes*len(scatters) else: scatters = [] scatters_colors = [] scatter_sizes = [] if original_mesh is None: original_mesh = du.fetch_segment_id_mesh(segment_id) compartment_color_dict = dict(valid_mesh=proofread_mesh_color) proof_mesh,error_mesh = pv.fetch_proofread_mesh(segment_id, split_index = split_index, original_mesh=original_mesh, return_error_mesh=True) if plot_proofread_skeleton: proof_skeleton = pv.fetch_proofread_skeleton(segment_id, split_index, plot_skeleton=False, #original_mesh=original_mesh ) else: proof_skeleton = None if plot_error_mesh: meshes.append(error_mesh) meshes_colors.append(error_mesh_color) meshes_alpha.append(error_mesh_alpha) compartment_color_dict["error_mesh"] = error_mesh_color if plot_nucleus: nuc_center = pv.nucleus_center_from_segment_id(segment_id, split_index) if nucleus_color == "proofread_mesh_color": nucleus_color = proofread_mesh_color if nuc_center is None: print(f"No nucleus to plot") else: scatters += [nuc_center.reshape(-1,3)] scatters_colors += [nucleus_color] scatter_sizes += [nucleus_size] #get the synapse groups if plot_synapses: synapses_objs = pv.syanpse_objs_from_segment_id(segment_id,split_index) (syn_scatters, syn_colors, syn_sizes) = syu.synapse_plot_items_by_type_or_query( synapses_objs, synapses_size = synapses_size, synapse_plot_type = synapse_plot_type,#"compartment"# "valid_error" synapse_compartments = synapse_compartments, synapse_spine_bouton_labels = synapse_spine_bouton_labels, plot_error_synapses = plot_error_synapses, valid_synapses_color = valid_synapses_color, error_synapses_color = error_synapses_color, synapse_queries = synapse_queries, synapse_queries_colors = synapse_queries_colors, verbose = verbose, print_spine_colors = print_spine_colors) scatters += syn_scatters scatters_colors += syn_colors scatter_sizes += syn_sizes if compartments is not None and len(compartments) > 0: comp_colors = apu.colors_from_compartments(compartments) if plot_compartment_meshes: comp_meshes = pv.fetch_compartments_meshes(compartments, segment_id, split_index, original_mesh = original_mesh, ) meshes += comp_meshes meshes_colors += comp_colors meshes_alpha += [compartment_mesh_alpha]*len(comp_meshes) if plot_compartment_skeletons: comp_sk = pv.fetch_compartments_skeletons(compartments, segment_id, split_index, ) skeletons += comp_sk skeletons_colors += comp_colors compartment_color_dict.update({k:v for k,v in zip(compartments,comp_colors)}) if print_compartment_colors: print(f"\nCompartment Colors:") for k,v in compartment_color_dict.items(): print(f" {k}:{v}") # print(f"proof_mesh== {proof_mesh}") # print(f"proof_skeleton = {proof_skeleton}") # if len(proof_skeleton) == 0: # proof_skeleton = None # print(f"skeletons = {skeletons}") # print(f"meshes = {meshes}") # print(f"scatters = {scatters}") nviz.plot_objects(main_mesh = proof_mesh, main_mesh_alpha=proofread_mesh_alpha, main_mesh_color=proofread_mesh_color, main_skeleton=proof_skeleton, main_skeleton_color=proofread_skeleton_color, skeletons=skeletons, skeletons_colors=skeletons_colors, meshes=meshes, meshes_colors=meshes_colors, mesh_alpha=meshes_alpha, scatters=scatters, scatter_size=scatter_sizes, scatters_colors=scatters_colors, show_at_end = show_at_end, append_figure = append_figure, )