nettracer3d 0.9.3__py3-none-any.whl → 0.9.5__py3-none-any.whl

nettracer3d/nettracer.py

@@ -4,6 +4,7 @@ import tifffile
 from scipy import ndimage
 from skimage import measure
 import cv2
+import ast
 import concurrent.futures
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from scipy.ndimage import zoom
@@ -382,6 +383,27 @@ def invert_dict(d):
         inverted.setdefault(value, []).append(key)
     return inverted
 
+def invert_dict_special(d):
+
+    d = invert_dict(d)
+
+    new_dict = copy.deepcopy(d)
+
+    for key, vals in d.items():
+
+        try:
+            idens = ast.literal_eval(key)
+            for iden in idens:
+                try:
+                    new_dict[iden].extend(vals)
+                except:
+                    new_dict[iden] = vals
+            del new_dict[key]
+        except:
+            pass
+    return new_dict
+
+
 def invert_array(array):
     """Internal method used to flip node array indices. 0 becomes 255 and vice versa."""
     inverted_array = np.where(array == 0, 255, 0).astype(np.uint8)
@@ -1245,31 +1267,6 @@ def dilate_2D(array, search, scaling = 1):
 
     return inv
 
-def erode_2D(array, search, scaling=1):
-    """
-    Erode a 2D array using distance transform method.
-    
-    Parameters:
-    array -- Input 2D binary array
-    search -- Distance within which to erode
-    scaling -- Scaling factor (default: 1)
-    
-    Returns:
-    Eroded 2D array
-    """
-    # For erosion, we work directly with the foreground
-    # No need to invert the array
-    
-    # Compute distance transform on the foreground
-    dt = smart_dilate.compute_distance_transform_distance(array)
-    
-    # Apply scaling
-    dt = dt * scaling
-    
-    # Threshold to keep only points that are at least 'search' distance from the boundary
-    eroded = dt >= search
-    
-    return eroded
 
 def dilate_3D_dt(array, search_distance, xy_scaling=1.0, z_scaling=1.0):
     """
@@ -1331,7 +1328,42 @@ def dilate_3D_dt(array, search_distance, xy_scaling=1.0, z_scaling=1.0):
     
     return inv.astype(np.uint8)
 
-def erode_3D_dt(array, search_distance, xy_scaling=1.0, z_scaling=1.0):
+def erode_2D(array, search, scaling=1, preserve_labels = False):
+    """
+    Erode a 2D array using distance transform method.
+    
+    Parameters:
+    array -- Input 2D binary array
+    search -- Distance within which to erode
+    scaling -- Scaling factor (default: 1)
+    
+    Returns:
+    Eroded 2D array
+    """
+    # For erosion, we work directly with the foreground
+    # No need to invert the array
+
+    if preserve_labels:
+        from skimage.segmentation import find_boundaries
+        borders = find_boundaries(array, mode='thick')
+        mask = array * invert_array(borders)
+        mask = smart_dilate.compute_distance_transform_distance(mask)
+        mask = mask * scaling
+        mask = mask >= search
+        array = mask * array
+    else:
+        # Compute distance transform on the foreground
+        dt = smart_dilate.compute_distance_transform_distance(array)
+        
+        # Apply scaling
+        dt = dt * scaling
+        
+        # Threshold to keep only points that are at least 'search' distance from the boundary
+        array = dt > search
+    
+    return array
+
+def erode_3D_dt(array, search_distance, xy_scaling=1.0, z_scaling=1.0, preserve_labels = False):
     """
     Erode a 3D array using distance transform method. DT erosion produces perfect results 
     with Euclidean geometry, but may be slower for large arrays.
@@ -1349,43 +1381,24 @@ def erode_3D_dt(array, search_distance, xy_scaling=1.0, z_scaling=1.0):
     
     if array.shape[0] == 1:
         # Handle 2D case
-        return erode_2D(array, search_distance, scaling=xy_scaling)
-    
-    # For erosion, we work directly with the foreground (no inversion needed)
+        return erode_2D(array, search_distance, scaling=xy_scaling, preserve_labels = True)
     
-    """
-    # Determine which dimension needs resampling
-    if (z_scaling > xy_scaling):
-        # Z dimension needs to be stretched
-        zoom_factor = [z_scaling/xy_scaling, 1, 1]  # Scale factor for [z, y, x]
-        rev_factor = [xy_scaling/z_scaling, 1, 1] 
-        cardinal = xy_scaling
-    elif (xy_scaling > z_scaling):
-        # XY dimensions need to be stretched
-        zoom_factor = [1, xy_scaling/z_scaling, xy_scaling/z_scaling]  # Scale factor for [z, y, x]
-        rev_factor = [1, z_scaling/xy_scaling, z_scaling/xy_scaling]  # Scale factor for [z, y, x]
-        cardinal = z_scaling
-    else:
-        # Already uniform scaling, no need to resample
-        zoom_factor = None
-        rev_factor = None
-        cardinal = xy_scaling
-    
-    # Resample the mask if needed
-    if zoom_factor:
-        array = ndimage.zoom(array, zoom_factor, order=0)  # Use order=0 for binary masks
-    """
-    
-    print("Computing a distance transform for a perfect erosion...")
 
-    array = smart_dilate.compute_distance_transform_distance(array, sampling = [z_scaling, xy_scaling, xy_scaling])
-    
-    # Apply scaling factor
-    #array = array * cardinal
-    
-    # Threshold the distance transform to get eroded result
-    # For erosion, we keep only the points that are at least search_distance from the boundary
-    array = array >= search_distance
+    if preserve_labels:
+
+
+        from skimage.segmentation import find_boundaries
+
+        borders = find_boundaries(array, mode='thick')
+        mask = array * invert_array(borders)
+        mask = smart_dilate.compute_distance_transform_distance(mask, sampling = [z_scaling, xy_scaling, xy_scaling])
+        mask = mask >= search_distance
+        array = mask * array
+    else:
+        array = smart_dilate.compute_distance_transform_distance(array, sampling = [z_scaling, xy_scaling, xy_scaling])
+        # Threshold the distance transform to get eroded result
+        # For erosion, we keep only the points that are at least search_distance from the boundary
+        array = array > search_distance
     
     # Resample back to original dimensions if needed
     #if rev_factor:
@@ -1552,7 +1565,7 @@ def dilate_3D_old(tiff_array, dilated_x=3, dilated_y=3, dilated_z=3):
 
 
 def erode_3D(tiff_array, eroded_x, eroded_y, eroded_z):
-    """Internal method to erode an array in 3D. Erosion this way is much faster than using a distance transform although the latter is theoretically more accurate.
+    """Internal method to erode an array in 3D. Erosion this way is faster than using a distance transform although the latter is theoretically more accurate.
     Arguments are an array, and the desired pixel erosion amounts in X, Y, Z."""
 
     if tiff_array.shape[0] == 1:
@@ -2102,22 +2115,34 @@ def dilate(arrayimage, amount, xy_scale = 1, z_scale = 1, directory = None, fast
 
     return arrayimage
 
-def erode(arrayimage, amount, xy_scale = 1, z_scale = 1, mode = 0):
-    if len(np.unique(arrayimage)) > 2: #binarize
+def erode(arrayimage, amount, xy_scale = 1, z_scale = 1, mode = 0, preserve_labels = False):
+    if not preserve_labels and len(np.unique(arrayimage)) > 2: #binarize
         arrayimage = binarize(arrayimage)
     erode_xy, erode_z = dilation_length_to_pixels(xy_scale, z_scale, amount, amount)
 
     if mode == 0:
         arrayimage = (erode_3D(arrayimage, erode_xy, erode_xy, erode_z)) * 255
     else:
-        arrayimage = erode_3D_dt(arrayimage, amount, xy_scaling=xy_scale, z_scaling=z_scale)
+        arrayimage = erode_3D_dt(arrayimage, amount, xy_scaling=xy_scale, z_scaling=z_scale, preserve_labels = preserve_labels)
 
     if np.max(arrayimage) == 1:
         arrayimage = arrayimage * 255
 
     return arrayimage
 
+def iden_set(idens):
 
+    idens = set(idens)
+    real_iden_set = []
+    for iden in idens:
+        try:
+            options = ast.literal_eval(iden)
+            for opt in options:
+                real_iden_set.append(opt)
+        except:
+            real_iden_set.append(iden)
+
+    return set(real_iden_set)
 
 
 
@@ -3813,7 +3838,7 @@ class Network_3D:
 
             self._search_region = self._nodes
 
-    def calculate_edges(self, binary_edges, diledge = None, inners = True, hash_inner_edges = True, search = None, remove_edgetrunk = 0, GPU = True, fast_dil = False, skeletonized = False):
+    def calculate_edges(self, binary_edges, diledge = None, inners = True, search = None, remove_edgetrunk = 0, GPU = True, fast_dil = False, skeletonized = False):
         """
         Method to calculate the edges that are used to directly connect nodes. May be done with or without the search region, however using search_region is recommended. 
         The search_region property must be set to use the search region, otherwise the nodes property must be set. Sets the edges property
@@ -3822,7 +3847,6 @@ class Network_3D:
         so some amount of dilation is recommended if there are any, but  not so much to create overconnectivity. This is a value that needs to be tuned by the user.
         :param inners: (Optional - Val = True; boolean). Will use inner edges if True, will not if False. Inner edges are parts of the edge mask that exist within search regions. If search regions overlap, 
         any edges that exist within the overlap will only assert connectivity if 'inners' is True.
-        :param hash_inner_edges: (Optional - Val = True; boolean). If False, all search regions that contain an edge object connecting multiple nodes will be assigned as connected.
         If True, an extra processing step is used to sort the correct connectivity amongst these search_regions. Can only be computed when search_regions property is set.
         :param search: (Optional - Val = None; int). Amount for nodes to search for connections, assuming the search_regions are not being used. Assigning a value to this param will utilize the secondary algorithm and not the search_regions.
         :param remove_edgetrunk: (Optional - Val = 0; int). Amount of times to remove the 'Trunk' from the edges. A trunk in this case is the largest (by vol) edge object remaining after nodes have broken up the edges.
@@ -3875,11 +3899,7 @@ class Network_3D:
         labelled_edges, num_edge = label_objects(outer_edges)
 
         if inners:
-
-            if search is None and hash_inner_edges is True:
-                inner_edges = hash_inners(self._search_region, binary_edges, GPU = GPU)
-            else:
-                inner_edges = establish_inner_edges(search_region, binary_edges)
+            inner_edges = hash_inners(self._search_region, binary_edges, GPU = GPU)
 
             del binary_edges
 
@@ -4011,7 +4031,7 @@ class Network_3D:
             self._network_lists = network_analysis.read_excel_to_lists(df)
             self._network, net_weights = network_analysis.weighted_network(df)
 
-    def calculate_all(self, nodes, edges, xy_scale = 1, z_scale = 1, down_factor = None, search = None, diledge = None, inners = True, hash_inners = True, remove_trunk = 0, ignore_search_region = False, other_nodes = None, label_nodes = True, directory = None, GPU = True, fast_dil = True, skeletonize = False, GPU_downsample = None):
+    def calculate_all(self, nodes, edges, xy_scale = 1, z_scale = 1, down_factor = None, search = None, diledge = None, inners = True, remove_trunk = 0, ignore_search_region = False, other_nodes = None, label_nodes = True, directory = None, GPU = True, fast_dil = True, skeletonize = False, GPU_downsample = None):
         """
         Method to calculate and save to mem all properties of a Network_3D object. In general, after initializing a Network_3D object, this method should be called on the node and edge masks that will be used to calculate the network.
         :param nodes: (Mandatory; String or ndarray). Filepath to segmented nodes mask or a numpy array containing the same.
@@ -4024,7 +4044,6 @@ class Network_3D:
         so some amount of dilation is recommended if there are any, but not so much to create overconnectivity. This is a value that needs to be tuned by the user.
         :param inners: (Optional - Val = True; boolean). Will use inner edges if True, will not if False. Inner edges are parts of the edge mask that exist within search regions. If search regions overlap, 
         any edges that exist within the overlap will only assert connectivity if 'inners' is True.
-        :param hash_inners: (Optional - Val = True; boolean). If False, all search regions that contain an edge object connecting multiple nodes will be assigned as connected.
         If True, an extra processing step is used to sort the correct connectivity amongst these search_regions. Can only be computed when search_regions property is set.
         :param remove_trunk: (Optional - Val = 0; int). Amount of times to remove the 'Trunk' from the edges. A trunk in this case is the largest (by vol) edge object remaining after nodes have broken up the edges.
         Any 'Trunks' removed will be absent for connection calculations.
@@ -4086,7 +4105,7 @@ class Network_3D:
                 except:
                     pass
 
-            self.calculate_edges(edges, diledge = diledge, inners = inners, hash_inner_edges = hash_inners, search = search, remove_edgetrunk = remove_trunk, GPU = GPU, fast_dil = fast_dil, skeletonized = skeletonize) #Will have to be moved out if the second method becomes more directly implemented
+            self.calculate_edges(edges, diledge = diledge, inners = inners, search = search, remove_edgetrunk = remove_trunk, GPU = GPU, fast_dil = fast_dil, skeletonized = skeletonize) #Will have to be moved out if the second method becomes more directly implemented
         else:
             self._edges, _ = label_objects(edges)
 
@@ -5070,13 +5089,16 @@ class Network_3D:
 
 
             for node in G.nodes():
-                nodeid = node_identities[node]
-                neighbors = list(G.neighbors(node))
-                for subnode in neighbors:
-                    subnodeid = node_identities[subnode]
-                    if subnodeid == root:
-                        neighborhood_dict[nodeid] += 1
-                        break
+                try:
+                    nodeid = node_identities[node]
+                    neighbors = list(G.neighbors(node))
+                    for subnode in neighbors:
+                        subnodeid = node_identities[subnode]
+                        if subnodeid == root:
+                            neighborhood_dict[nodeid] += 1
+                            break
+                except:
+                    pass
 
             title1 = f'Neighborhood Distribution of Nodes in Network from Nodes: {root}'
             title2 = f'Neighborhood Distribution of Nodes in Network from Nodes {root} as a proportion of total nodes of that ID'
@@ -5185,34 +5207,22 @@ class Network_3D:
                     bounds = (min_coords, max_coords)
                     dim_list = max_coords - min_coords
 
-
-                if dim == 3:
-
-                    """
-                    if self.xy_scale > self.z_scale: # xy will be 'expanded' more so its components will be arbitrarily further from the border than z ones
-                        factor_xy = (self.z_scale/self.xy_scale) * factor # So 'factor' in the xy dim has to get smaller
-                        factor_z = factor
-                    elif self.z_scale > self.xy_scale: # Same idea
-                        factor_z = (self.xy_scale/self.z_scale) * factor
-                        factor_xy = factor
-                    else:
-                        factor_z = factor
-                        factor_xy = factor
-                    """
-
-                    for centroid in roots:
-
-                        if ((centroid[2] - min_coords[0]) > dim_list[0] * factor) and ((max_coords[0] - centroid[2]) > dim_list[0]  * factor) and ((centroid[1] - min_coords[1]) > dim_list[1] * factor) and ((max_coords[1] - centroid[1]) > dim_list[1] * factor) and ((centroid[0] - min_coords[2]) > dim_list[2] * factor) and ((max_coords[2] - centroid[0]) > dim_list[2] * factor):
+                for centroid in roots:
+                    # Assuming centroid is [z, y, x] based on your indexing
+                    z, y, x = centroid[0], centroid[1], centroid[2]
+                    
+                    # Check x-dimension
+                    x_ok = (x - min_coords[0]) > dim_list[0] * factor and (max_coords[0] - x) > dim_list[0] * factor
+                    # Check y-dimension  
+                    y_ok = (y - min_coords[1]) > dim_list[1] * factor and (max_coords[1] - y) > dim_list[1] * factor
+                    
+                    if dim == 3:  # 3D case
+                        # Check z-dimension
+                        z_ok = (z - min_coords[2]) > dim_list[2] * factor and (max_coords[2] - z) > dim_list[2] * factor
+                        if x_ok and y_ok and z_ok:
                             new_list.append(centroid)
-
-
-                        #if ((centroid[2] - min_coords[0]) > dim_list[0] * factor) and ((max_coords[0] - centroid[2]) > dim_list[0]  * factor) and ((centroid[1] - min_coords[1]) > dim_list[1] * factor) and ((max_coords[1] - centroid[1]) > dim_list[1] * factor) and ((centroid[0] - min_coords[2]) > dim_list[2] * factor) and ((max_coords[2] - centroid[0]) > dim_list[2] * factor):
-                            #new_list.append(centroid)
-                            #print(f"dim_list: {dim_list}, centroid: {centroid}, min_coords: {min_coords}, max_coords: {max_coords}")
-                else:
-                    for centroid in roots:
-
-                        if ((centroid[2] - min_coords[0]) > dim_list[0] * factor) and ((max_coords[0] - centroid[2]) > dim_list[0]  * factor) and ((centroid[1] - min_coords[1]) > dim_list[1] * factor) and ((max_coords[1] - centroid[1]) > dim_list[1] * factor):
+                    else:  # 2D case
+                        if x_ok and y_ok:
                             new_list.append(centroid)
 
             else:
@@ -5265,8 +5275,6 @@ class Network_3D:
             print(f"Utilizing {len(roots)} root points. Note that low n values are unstable.")
             is_subset = True
 
-
-
         roots = proximity.convert_centroids_to_array(roots, xy_scale = self.xy_scale, z_scale = self.z_scale)
 
         n_subset = len(targs)
@@ -5451,7 +5459,7 @@ class Network_3D:
 
         community_dict = invert_dict(self.communities)
         summation = 0
-        id_set = set(self.node_identities.values())
+        id_set = iden_set(self.node_identities.values())
         output = {sort: 0 for sort in id_set}
         template = copy.deepcopy(output)
 
@@ -5463,7 +5471,12 @@ class Network_3D:
             
             # Count identities in this community
             for node in nodes:
-                counter[self.node_identities[node]] += 1
+                try:
+                    idens = ast.literal_eval(self.node_identities[node])
+                    for iden in idens:
+                        counter[iden] += 1
+                except:
+                    counter[self.node_identities[node]] += 1
             
             # Convert to proportions within this community and weight by size
             for sort in counter:
@@ -5492,11 +5505,60 @@ class Network_3D:
         neighborhoods.visualize_cluster_composition_umap(self.node_centroids, None, id_dictionary = self.node_identities, graph_label = "Node ID", title = 'UMAP Visualization of Node Centroids') 
 
 
+
+    def identity_umap(self):
+
+        try:
+
+            id_set = iden_set(self.node_identities.values())
+
+            template = np.zeros(len(id_set))
+
+            id_dict = {}
+            for i, iden in enumerate(id_set):
+                id_dict[iden] = i
+
+            umap_dict = {}
+
+            for node in self.node_identities.keys():
+                umap_dict[node] = copy.deepcopy(template)
+                try:
+                    idens = ast.literal_eval(self.node_identities[node])
+                    for iden in idens:
+                        index = id_dict[iden]
+                        ref = umap_dict[node]
+                        ref[index] = 1
+                        umap_dict[node] = ref
+                except:
+                    index = id_dict[self.node_identities[node]]
+                    ref = umap_dict[node]
+                    ref[index] = 1
+                    umap_dict[node] = ref
+
+            neighbor_classes = {}
+            import random
+
+            for node, iden in self.node_identities.items():
+                try:
+                    idens = ast.literal_eval(iden)
+                    neighbor_classes[node] = random.choice(idens)
+                except:
+                    neighbor_classes[node] = iden
+
+
+            from . import neighborhoods
+
+            neighborhoods.visualize_cluster_composition_umap(umap_dict, None, id_dictionary = neighbor_classes, graph_label = "Node ID", title = 'UMAP Visualization of Node Identities', draw_lines = True) 
+
+        except Exception as e:
+            print(f"Error: {e}")
+
+
     def community_id_info_per_com(self, umap = False, label = 0, limit = 0, proportional = False, neighbors = None):
 
         community_dict = invert_dict(self.communities)
         summation = 0
-        id_set = set(self.node_identities.values())
+        id_set = iden_set(self.node_identities.values())
         id_dict = {}
         for i, iden in enumerate(id_set):
             id_dict[iden] = i
@@ -5515,7 +5577,15 @@ class Network_3D:
 
                 # Count identities in this community
                 for node in nodes:
-                    counter[id_dict[self.node_identities[node]]] += 1 # Keep them as arrays
+                    try:
+                        idens = ast.literal_eval(self.node_identities[node])
+                        for iden in idens:
+                            counter[id_dict[iden]] += 1
+                    except:
+                        try:
+                            counter[id_dict[self.node_identities[node]]] += 1 # Keep them as arrays
+                        except:
+                            pass
 
                 for i in range(len(counter)): # Translate them into proportions out of 1
 
@@ -5527,12 +5597,11 @@ class Network_3D:
                     umap_dict[community] = counter
 
         else:
-            idens = invert_dict(self.node_identities)
+            idens = invert_dict_special(self.node_identities)
             iden_count = {}
             template = {}
             node_count = len(list(self.communities.keys()))
 
-
             for iden in id_set:
                 template[iden] = 0
 
@@ -5548,7 +5617,15 @@ class Network_3D:
                 counter = np.zeros(len(id_set))
 
                 for node in nodes:
-                    iden_tracker[self.node_identities[node]] += 1 
+                    try:
+                        idents = ast.literal_eval(self.node_identities[node])
+                        for iden in idents:
+                            iden_tracker[iden] += 1
+                    except:
+                        try:
+                            iden_tracker[self.node_identities[node]] += 1
+                        except:
+                            pass
 
                 i = 0
 
@@ -5819,7 +5896,7 @@ class Network_3D:
             return heat_dict, overlay
 
 
-    def merge_node_ids(self, path, data):
+    def merge_node_ids(self, path, data, include = True):
 
         if self.node_identities is None: # Prepare modular dict
 
@@ -5828,9 +5905,17 @@ class Network_3D:
             nodes = list(np.unique(data))
             if 0 in nodes:
                 del nodes[0]
-
             for node in nodes:
-                self.node_identities[node] = ''
+
+                self.node_identities[node] = [] # Assign to lists at first
+        else:
+            for node, iden in self.node_identities.items():
+                try:
+                    self.node_identities[node] = ast.literal_eval(iden)
+                except:
+                    self.node_identities[node] = [iden]
+
+
 
         img_list = directory_info(path)
 
@@ -5840,9 +5925,12 @@ class Network_3D:
             if len(np.unique(mask)) != 2:
 
                 mask = otsu_binarize(mask)
+            else:
+                mask = mask != 0
 
             nodes = data * mask
-            nodes = list(np.unique(nodes))
+            nodes = np.unique(nodes)
+            nodes = nodes.tolist()
             if 0 in nodes:
                 del nodes[0]
 
@@ -5853,21 +5941,43 @@ class Network_3D:
             else:
                 base_name = img
 
+            assigned = {}
+
+
             for node in self.node_identities.keys():
 
                 try:
 
-                    if node in nodes:
+                    if int(node) in nodes:
 
-                        self.node_identities[node] += f" {base_name}+"
+                        self.node_identities[node].append(f'{base_name}+')
 
-                    else:
+                    elif include:
 
-                        self.node_identities[node] += f" {base_name}-"
+                        self.node_identities[node].append(f'{base_name}-')
 
                 except:
                     pass
 
+            modify_dict = copy.deepcopy(self.node_identities)
+
+        for node, iden in self.node_identities.items():
+
+            try:
+
+                if len(iden) == 1:
+
+                    modify_dict[node] = str(iden[0]) # Singleton lists become bare strings
+                elif len(iden) == 0:
+                    del modify_dict[node]
+                else:
+                    modify_dict[node] = str(iden) # We hold multi element lists as strings for compatibility
+
+            except:
+                pass
+
+        self.node_identities = modify_dict
+
 
     def nearest_neighbors_avg(self, root, targ, xy_scale = 1, z_scale = 1, num = 1, heatmap = False, threed = True, numpy = False, quant = False, centroids = True):