nettracer3d 0.6.5__py3-none-any.whl → 0.6.7__py3-none-any.whl

nettracer3d/community_extractor.py

@@ -213,178 +213,6 @@ def open_network(excel_file_path):
     return G
 
 
-
-def isolate_full_edges(nodes, edges, directory = None):
-    """requires smart_dilate output to function properly"""
-
-    print("Isolating full edges")
-
-    if type(nodes) == str:
-        nodes = tifffile.imread(nodes)
-
-    if type(edges) == str:
-        edges = tifffile.imread(edges)
-
-    node_bools = binarize(nodes)
-
-    del nodes
-
-    real_edges = node_bools * edges
-
-    del node_bools
-
-    # Flatten the 3D array to a 1D array
-    real_edges = real_edges.flatten()
-
-    # Find unique values
-    real_edges = np.unique(real_edges)
-
-    edge_masks = labels_to_boolean(edges, real_edges)
-
-    del real_edges
-
-    edge_labels_1 = edge_masks * edges
-     
-    del edge_masks
-
-    edge_labels_1 = binarize(edge_labels_1)
-
-    edge_labels_1 = edge_labels_1 * 255
-
-    if directory is None:
-
-        tifffile.imsave(f"full_edges_for_component.tif", edge_labels_1)
-        print("Full edge labels saved to full_edges_for_component.tif")
-    else:
-        tifffile.imsave(f"{directory}/full_edges_for_component.tif", edge_labels_1)
-        print(f"Full edge labels saved to {directory}/full_edges_for_component.tif")
-
-
-def isolate_edges(edges, network, iso_network, netlists = None, directory = None):
-
-    print("Isolating edges")
-
-    if netlists is None:
-
-        master_list = read_excel_to_lists(network)
-    else:
-        master_list = netlists
-
-    if directory is None:
-        comp_list = read_excel_to_lists(iso_network)
-    else:
-        comp_list = read_excel_to_lists(f"{directory}/{iso_network}")
-
-    edge_list = []
-
-    node_1 = master_list[0]
-
-    node_2 = master_list[1]
-
-    edges_list = master_list[2]
-
-    nodes_1 = comp_list[0]
-
-    nodes_2 = comp_list[1]
-
-    compare_list = []
-
-    iso_list = []
-
-    output_list = []
-
-    for i in range(len(nodes_1)):
-        item = [nodes_1[i], nodes_2[i]]
-        iso_list.append(item)
-
-    for i in range(len(node_1)):
-
-        item = [node_1[i], node_2[i]]
-
-        compare_list.append(item)
-
-    for i in range(len(iso_list)):
-
-        for k, item in enumerate(compare_list):
-            if item == iso_list[i] or [item[1], item[0]] == iso_list[i]:
-                add_item = [nodes_1[i], nodes_2[i], edges_list[k]]
-                if add_item in output_list:
-                    break
-                else:
-                    output_list.append(add_item)
-
-                    edge_list.append(edges_list[k])
-
-    # Convert to a DataFrame
-    edges_df = pd.DataFrame(output_list, columns=["Node A", "Node B", "Edge C"])
-
-    if directory is None:
-        # Save to an Excel file
-        edges_df.to_excel(f"{iso_network}", index=False)
-        print(f"Isolated network file saved to {iso_network}")
-    else:
-        edges_df.to_excel(f"{directory}/{iso_network}", index=False)
-        print(f"Isolated network file saved to {directory}/{iso_network}")
-
-
-    mask2 = labels_to_boolean(edges, edge_list)
-
-    mask2 = mask2 * edges
-
-    # Convert boolean values to 0 and 255
-    #mask2 = mask2.astype(np.uint8) * 255
-
-    if directory is None:
-
-        tifffile.imwrite(f"edges_for_{iso_network}.tif", mask2)
-        print(f"Computational edge mask saved to edges_for_{iso_network}.tif")
-    else:
-        tifffile.imwrite(f"{directory}/edges_for_{iso_network}.tif", mask2)
-        print(f"Computational edge mask saved to {directory}/edges_for_{iso_network}.tif")
-
-
-    return output_list, mask2
-
-
-def isolate_connected_component(nodes, excel, key=None, edge_file = None, netlists = None, search_region = None, directory = None):
-
-    structure_3d = np.ones((3, 3, 3), dtype=int)
-
-    if edge_file is not None and type(edge_file) == str:
-        edge_file = tifffile.imread(edge_file)
-
-    if type(nodes) == str:
-        nodes = tifffile.imread(nodes)
-        if len(np.unique(nodes)) == 2:
-            nodes, num_nodes = ndimage.label(nodes, structure=structure_3d)
-
-    if type(excel) == str:
-        G = open_network(excel)
-    else:
-        G = excel
-
-    if key is None:
-        print("Isolating nodes of largest connected component")
-        edges_df, mask, searchers = isolate_largest_connected(nodes, G, search_region = search_region, directory = directory)
-        if edge_file is not None:
-            output_list, mask2 = isolate_edges(edge_file, excel, 'largest_connected_component.xlsx', netlists = netlists, directory = directory)
-            #isolate_full_edges(nodes, edge_file, 'largest_connected_component')
-            return output_list, mask, mask2, searchers
-        else:
-
-            return edges_df, mask, searchers
-
-    else:
-        print("Isolating nodes of connected component containing specified key")
-        edges_df, mask, searchers = isolate_key_connected(nodes, G, key, search_region = search_region, directory = directory)
-        if edge_file is not None:
-            output_list, mask2 = isolate_edges(edge_file, excel, f'connected_component_containing_{key}_node.xlsx', netlists = netlists, directory = directory)
-            #isolate_full_edges(nodes, edge_file, 'connected_component_containing_specific_node')
-            return output_list, mask, mask2, searchers
-        else:
-            return edges_df, mask, searchers
-
-
 def _isolate_connected(G, key = None):
 
     if key is None:
@@ -401,103 +229,6 @@ def _isolate_connected(G, key = None):
         return G0
 
 
-
-def isolate_largest_connected(masks, G, directory = None, search_region = None):
-    # Read the Excel file into a pandas DataFrame
-
-    # Get a list of connected components
-    connected_components = list(nx.connected_components(G))
-    Gcc = sorted(nx.connected_components(G), key=len, reverse=True)
-    G0 = G.subgraph(Gcc[0])
-
-    # Extract the edges of the largest connected component
-    edges_largest_component = list(G0.edges)
-
-    # Convert to a DataFrame
-    edges_df = pd.DataFrame(edges_largest_component, columns=["Node A", "Node B"])
-
-    if directory is None:
-        # Save to an Excel file
-        edges_df.to_excel("largest_connected_component.xlsx", index=False)
-        print("Largest component nodes saved to largest_connected_component.xlsx")
-    else:
-        edges_df.to_excel(f"{directory}/largest_connected_component.xlsx", index=False)
-        print(f"Largest component nodes saved to {directory}/largest_connected_component.xlsx")
-
-    nodes_in_largest_component = list(G0)
-
-    mask2 = labels_to_boolean(masks, nodes_in_largest_component)
-
-    mask2 = mask2 * masks
-
-    if search_region is not None:
-        searchers = labels_to_boolean(search_region, nodes_in_largest_component)
-        searchers = searchers * search_region
-    else:
-        searchers = None
-
-    if directory is None:
-        tifffile.imwrite("largest_connected_component.tif", mask2)
-        print(f"Largest connected component image saved to largest_connected_component.tif")
-
-    else:
-        tifffile.imwrite(f"{directory}/largest_connected_component.tif", mask2)
-        print(f"Largest connected component image saved to {directory}/largest_connected_component.tif")
-
-    return edges_largest_component, mask2, searchers
-
-
-
-def isolate_key_connected(masks, G, key, search_region = None, directory = None):
-
-
-    # Get the connected component containing the specific node label
-    connected_component = nx.node_connected_component(G, key)
-
-    G0 = G.subgraph(connected_component)
-
-    # Extract the edges of the largest connected component
-    edges_component = list(G0.edges)
-
-    # Convert to a DataFrame
-    edges_df = pd.DataFrame(edges_component, columns=["Node A", "Node B"])
-
-
-    if directory is None:
-        # Save to an Excel file
-        edges_df.to_excel(f"connected_component_containing_{key}_node.xlsx", index=False)
-        print(f"Nodes containing {key} saved to connected_component_containing_{key}_node.xlsx")
-    else:
-        edges_df.to_excel(f"{directory}/connected_component_containing_{key}_node.xlsx", index=False)
-        print(f"Nodes containing {key} saved to {directory}/connected_component_containing_{key}_node.xlsx")
-
-    # Convert the set of nodes to a list
-    nodes_in_component = list(connected_component)
-
-    mask2 = labels_to_boolean(masks, nodes_in_component)
-
-    mask2 = mask2 * masks
-
-    # Convert boolean values to 0 and 255
-    #mask2 = mask2.astype(np.uint8) * 255
-
-    if search_region is not None:
-        searchers = labels_to_boolean(search_region, nodes_in_component)
-        searchers = searchers * search_region
-    else:
-        searchers = None
-
-    if directory is None:
-        tifffile.imwrite(f"connected_component_containing_{key}_node.tif", mask2)
-        print(f"Connected component containing node {key} saved to connected_component_containing_{key}_node.tif")
-
-    else:
-        tifffile.imwrite(f"{directory}/connected_component_containing_{key}_node.tif", mask2)
-        print(f"Connected component containing node {key} saved to {directory}/connected_component_containing_{key}_node.tif")
-
-    return nodes_in_component, mask2, searchers
-
-
 def extract_mothers(nodes, excel_file_path, centroid_dic = None, directory = None, louvain = True, ret_nodes = False, called = False):
 
     if type(nodes) == str:

nettracer3d/morphology.py

@@ -65,13 +65,12 @@ def reslice_3d_array(args):
     return resliced_array
 
 
-
-def _get_node_edge_dict(label_array, edge_array, label, dilate_xy, dilate_z, cores = 0):
+def _get_node_edge_dict(label_array, edge_array, label, dilate_xy, dilate_z, cores = 0, search = 0, fastdil = False, xy_scale = 1, z_scale = 1):
     """Internal method used for the secondary algorithm to find pixel involvement of nodes around an edge."""
     
     # Create a boolean mask where elements with the specified label are True
     label_array = label_array == label
-    dil_array = nettracer.dilate_3D_recursive(label_array, dilate_xy, dilate_xy, dilate_z) #Dilate the label to see where the dilated label overlaps
+    dil_array = nettracer.dilate(label_array, search, xy_scale = xy_scale, z_scale = z_scale, fast_dil = fastdil) #Dilate the label to see where the dilated label overlaps
 
     if cores == 0: #For getting the volume of objects. Cores presumes you want the 'core' included in the interaction.
         edge_array = edge_array * dil_array  # Filter the edges by the label in question
@@ -116,7 +115,7 @@ def process_label(args):
 
 
 
-def create_node_dictionary(nodes, edges, num_nodes, dilate_xy, dilate_z, cores=0):
+def create_node_dictionary(nodes, edges, num_nodes, dilate_xy, dilate_z, cores=0, search = 0, fastdil = False, xy_scale = 1, z_scale = 1):
     """Modified to pre-compute all bounding boxes using find_objects"""
     node_dict = {}
     array_shape = nodes.shape
@@ -136,20 +135,20 @@ def create_node_dictionary(nodes, edges, num_nodes, dilate_xy, dilate_z, cores=0
         # Process results in parallel
         for label, sub_nodes, sub_edges in results:
             executor.submit(create_dict_entry, node_dict, label, sub_nodes, sub_edges, 
-                          dilate_xy, dilate_z, cores)
+                          dilate_xy, dilate_z, cores, search, fastdil, xy_scale, z_scale)
 
     return node_dict
 
-def create_dict_entry(node_dict, label, sub_nodes, sub_edges, dilate_xy, dilate_z, cores = 0):
+def create_dict_entry(node_dict, label, sub_nodes, sub_edges, dilate_xy, dilate_z, cores = 0, search = 0, fastdil = False, xy_scale = 1, z_scale = 1):
     """Internal method used for the secondary algorithm to pass around args in parallel."""
 
     if label is None:
         pass
     else:
-        node_dict[label] = _get_node_edge_dict(sub_nodes, sub_edges, label, dilate_xy, dilate_z, cores = cores)
+        node_dict[label] = _get_node_edge_dict(sub_nodes, sub_edges, label, dilate_xy, dilate_z, cores = cores, search = search, fastdil = fastdil, xy_scale = xy_scale, z_scale = z_scale)
 
 
-def quantify_edge_node(nodes, edges, search = 0, xy_scale = 1, z_scale = 1, cores = 0, resize = None, save = True, skele = False):
+def quantify_edge_node(nodes, edges, search = 0, xy_scale = 1, z_scale = 1, cores = 0, resize = None, save = True, skele = False, fastdil = False):
 
     def save_dubval_dict(dict, index_name, val1name, val2name, filename):
 
@@ -189,7 +188,7 @@ def quantify_edge_node(nodes, edges, search = 0, xy_scale = 1, z_scale = 1, core
         dilate_xy, dilate_z = 0, 0
 
 
-    edge_quants = create_node_dictionary(nodes, edges, num_nodes, dilate_xy, dilate_z, cores = cores) #Find which edges connect which nodes and put them in a dictionary.
+    edge_quants = create_node_dictionary(nodes, edges, num_nodes, dilate_xy, dilate_z, cores = cores, search = search, fastdil = fastdil, xy_scale = xy_scale, z_scale = z_scale) #Find which edges connect which nodes and put them in a dictionary.
 
     if save:
     
@@ -235,16 +234,14 @@ def calculate_voxel_volumes(array, xy_scale=1, z_scale=1):
 
 
 
-def search_neighbor_ids(nodes, targets, id_dict, neighborhood_dict, totals, search, xy_scale, z_scale, root):
+def search_neighbor_ids(nodes, targets, id_dict, neighborhood_dict, totals, search, xy_scale, z_scale, root, fastdil = False):
 
     if 0 in targets:
         targets.remove(0)
     targets = np.isin(nodes, targets)
     targets = nettracer.binarize(targets)
-    
-    dilate_xy, dilate_z = nettracer.dilation_length_to_pixels(xy_scale, z_scale, search, search)
-    
-    dilated = nettracer.dilate_3D_recursive(targets, dilate_xy, dilate_xy, dilate_z)
+        
+    dilated = nettracer.dilate(targets, search, xy_scale = xy_scale, z_scale = z_scale, fast_dil = fastdil)
     dilated = dilated - targets #technically we dont need the cores
     search_vol = np.count_nonzero(dilated) * xy_scale * xy_scale * z_scale #need this for density
     targets = dilated != 0
@@ -255,13 +252,11 @@ def search_neighbor_ids(nodes, targets, id_dict, neighborhood_dict, totals, sear
     
     unique, counts = np.unique(targets, return_counts=True)
     count_dict = dict(zip(unique, counts))
-    print(count_dict)
     
     del count_dict[0]
     
     unique, counts = np.unique(nodes, return_counts=True)
     total_dict = dict(zip(unique, counts))
-    print(total_dict)
 
     del total_dict[0]
     
@@ -319,7 +314,7 @@ def get_search_space_dilate(target, centroids, id_dict, search, scaling = 1):
 
 # Methods pertaining to getting radii:
 
-def process_object_cpu(label, objects, labeled_array):
+def process_object_cpu(label, objects, labeled_array, xy_scale = 1, z_scale = 1):
     """
     Process a single labeled object to estimate its radius (CPU version).
     This function is designed to be called in parallel.
@@ -357,25 +352,36 @@ def process_object_cpu(label, objects, labeled_array):
     
     # Create binary mask for this object within the subarray
     mask = (subarray == label)
+
+
+    # Determine which dimension needs resampling
+    if (z_scale > xy_scale) and mask.shape[0] != 1:
+        # Z dimension needs to be stretched
+        zoom_factor = [z_scale/xy_scale, 1, 1]  # Scale factor for [z, y, x]
+        cardinal = xy_scale
+    elif (xy_scale > z_scale) and mask.shape[0] != 1:
+        # XY dimensions need to be stretched
+        zoom_factor = [1, xy_scale/z_scale, xy_scale/z_scale]  # Scale factor for [z, y, x]
+        cardinal = z_scale
+    else:
+        # Already uniform scaling, no need to resample
+        zoom_factor = None
+        cardinal = xy_scale
+
+    # Resample the mask if needed
+    if zoom_factor:
+        mask = ndimage.zoom(mask, zoom_factor, order=0)  # Use order=0 for binary masks
+
     
     # Compute distance transform on the smaller mask
     dist_transform = compute_distance_transform_distance(mask)
     
     # Filter out small values near the edge to focus on more central regions
-    radius = np.max(dist_transform)
+    radius = np.max(dist_transform) * cardinal
     
-    # Calculate basic shape metrics
-    volume = np.sum(mask)
-    
-    # Calculate bounding box dimensions
-    x_len = obj_slice[0].stop - obj_slice[0].start
-    y_len = obj_slice[1].stop - obj_slice[1].start
-    z_len = obj_slice[2].stop - obj_slice[2].start
-    dimensions = np.array([x_len, y_len, z_len])
-    
-    return label, radius, volume, dimensions
+    return label, radius
 
-def estimate_object_radii_cpu(labeled_array, n_jobs=None):
+def estimate_object_radii_cpu(labeled_array, n_jobs=None, xy_scale = 1, z_scale = 1):
     """
     Estimate the radii of labeled objects in a 3D numpy array using distance transform.
     CPU parallel implementation.
@@ -399,7 +405,7 @@ def estimate_object_radii_cpu(labeled_array, n_jobs=None):
     unique_labels = unique_labels[unique_labels != 0]  # Remove background
     
     # Create a partial function for parallel processing
-    process_func = partial(process_object_cpu, objects=objects, labeled_array=labeled_array)
+    process_func = partial(process_object_cpu, objects=objects, labeled_array=labeled_array, xy_scale = xy_scale, z_scale = z_scale)
     
     # Process objects in parallel
     results = []
@@ -414,12 +420,12 @@ def estimate_object_radii_cpu(labeled_array, n_jobs=None):
     # Organize results
     radii = {}
     
-    for label, radius, volume, dimensions in results:
+    for label, radius in results:
         radii[label] = radius
     
     return radii
 
-def estimate_object_radii_gpu(labeled_array):
+def estimate_object_radii_gpu(labeled_array, xy_scale = 1, z_scale = 1):
     """
     Estimate the radii of labeled objects in a 3D numpy array using distance transform.
     GPU implementation using CuPy.
@@ -467,13 +473,32 @@ def estimate_object_radii_gpu(labeled_array):
             
             # Create binary mask for this object (directly on GPU)
             mask_gpu = (labeled_array_gpu[tuple(padded_slices)] == label)
+
+            # Determine which dimension needs resampling
+            if (z_scale > xy_scale) and mask_gpu.shape[0] != 1:
+                # Z dimension needs to be stretched
+                zoom_factor = [z_scale/xy_scale, 1, 1]  # Scale factor for [z, y, x]
+                cardinal = xy_scale
+            elif (xy_scale > z_scale) and mask_gpu.shape[0] != 1:
+                # XY dimensions need to be stretched
+                zoom_factor = [1, xy_scale/z_scale, xy_scale/z_scale]  # Scale factor for [z, y, x]
+                cardinal = z_scale
+            else:
+                # Already uniform scaling, no need to resample
+                zoom_factor = None
+                cardinal = xy_scale
+
+            # Resample the mask if needed
+            if zoom_factor:
+                mask_gpu = cpx.zoom(mask_gpu, zoom_factor, order=0)  # Use order=0 for binary masks
             
             # Compute distance transform on GPU
             dist_transform_gpu = compute_distance_transform_distance_GPU(mask_gpu)
-            
-            radius = float(cp.max(dist_transform_gpu).get())
-            
-            # Store the radius
+        
+            radius = float(cp.max(dist_transform_gpu).get()) * cardinal
+
+
+            # Store the radius and the scaled radius
             radii[label] = radius
         
         # Clean up GPU memory