nettracer3d 0.7.9__py3-none-any.whl → 0.8.1__py3-none-any.whl

nettracer3d/nettracer.py

@@ -548,6 +548,7 @@ def remove_branches(skeleton, length):
     return image_copy
 
 
+
 def estimate_object_radii(labeled_array, gpu=False, n_jobs=None, xy_scale = 1, z_scale = 1):
     """
     Estimate the radii of labeled objects in a 3D numpy array.
@@ -1485,21 +1486,21 @@ def remove_zeros(input_list):
 
 
 def combine_edges(edge_labels_1, edge_labels_2):
-    """Internal method to combine the edges and 'inner edges' into a single array while preserving their IDs. Prioritizes 'edge_labels_1' when overlapped"""
-
-    edge_labels_1 = edge_labels_1.astype(np.uint32)
-    edge_labels_2 = edge_labels_2.astype(np.uint32)
-
-    max_val = np.max(edge_labels_1) 
-    edge_bools_1 = edge_labels_1 == 0 #Get boolean mask where edges do not exist.
-    edge_bools_2 = edge_labels_2 > 0 #Get boolean mask where inner edges exist.
-    edge_labels_2 = edge_labels_2 + max_val #Add the maximum edge ID to all inner edges so the two can be merged without overriding eachother
-    edge_labels_2 = edge_labels_2 * edge_bools_2 #Eliminate any indices that should be 0 from inner edges.
-    edge_labels_2 = edge_labels_2 * edge_bools_1 #Eliminate any indices where outer edges overlap inner edges (Outer edges are giving overlap priority)
-    edge_labels = edge_labels_1 + edge_labels_2 #Combine the outer edges with the inner edges modified via the above steps
-
-    return edge_labels
-
+    """
+    let NumPy handle promotion automatically
+    """
+    # Early exit if no combination needed
+    mask = (edge_labels_1 == 0) & (edge_labels_2 > 0)
+    if not np.any(mask):
+        return edge_labels_1.copy()
+    
+    max_val = np.max(edge_labels_1)
+    
+    # Let NumPy handle dtype promotion automatically
+    # This will promote to the smallest type that can handle the operation
+    offset_labels = edge_labels_2 + max_val
+    
+    return np.where(mask, offset_labels, edge_labels_1)
 
 def combine_nodes(root_nodes, other_nodes, other_ID, identity_dict, root_ID = None):
 
@@ -1507,15 +1508,10 @@ def combine_nodes(root_nodes, other_nodes, other_ID, identity_dict, root_ID = No
 
     print("Combining node arrays")
 
-    root_nodes = root_nodes.astype(np.uint32)
-    other_nodes = other_nodes.astype(np.uint32)
-
-    max_val = np.max(root_nodes) 
-    root_bools = root_nodes == 0 #Get boolean mask where root nodes do not exist.
-    other_bools = other_nodes > 0 #Get boolean mask where other nodes exist.
-    other_nodes = other_nodes + max_val #Add the maximum root node labels to other nodes so the two can be merged without overriding eachother
-    other_nodes = other_nodes * other_bools #Eliminate any indices that should be 0 from other_nodes.
-    other_nodes = other_nodes * root_bools #Eliminate any indices where other nodes overlap root nodes (root node are giving overlap priority)
+    mask = (root_nodes == 0) & (other_nodes > 0)
+    if np.any(mask):
+        max_val = np.max(root_nodes)
+        other_nodes[:] = np.where(mask, other_nodes + max_val, 0)
 
     if root_ID is not None:
         rootIDs = list(np.unique(root_nodes)) #Sets up adding these vals to the identitiy dictionary. Gets skipped if this has already been done.
@@ -1530,6 +1526,11 @@ def combine_nodes(root_nodes, other_nodes, other_ID, identity_dict, root_ID = No
 
     if root_ID is not None: #Adds the root vals to the dictionary if it hasn't already
 
+        if other_ID.endswith('.tiff'):
+            other_ID = other_ID[:-5]
+        elif other_ID.endswith('.tif'):
+            other_ID = other_ID[:-4]
+
         for item in rootIDs:
             identity_dict[item] = root_ID
 
@@ -1538,6 +1539,11 @@ def combine_nodes(root_nodes, other_nodes, other_ID, identity_dict, root_ID = No
             other_ID = os.path.basename(other_ID)
         except:
             pass
+        if other_ID.endswith('.tiff'):
+            other_ID = other_ID[:-5]
+        elif other_ID.endswith('.tif'):
+            other_ID = other_ID[:-4]
+
         identity_dict[item] = other_ID
 
     nodes = root_nodes + other_nodes #Combine the outer edges with the inner edges modified via the above steps
@@ -1609,6 +1615,17 @@ def downsample(data, factor, directory=None, order=0):
     
     return data
 
+
+def otsu_binarize(image_array):
+
+    """Automated binarize method for seperating the foreground"""
+
+    from skimage.filters import threshold_otsu
+
+    threshold = threshold_otsu(image_array)
+    binary_mask = image_array > threshold
+    return binary_mask
+
 def binarize(arrayimage, directory = None):
     """
     Can be used to binarize an image. Binary output will be saved to the active directory if none is specified.
@@ -3428,7 +3445,7 @@ class Network_3D:
         """
         self._nodes, num_nodes = label_objects(nodes, structure_3d)
 
-    def merge_nodes(self, addn_nodes_name, label_nodes = True):
+    def merge_nodes(self, addn_nodes_name, label_nodes = True, root_id = "Root_Nodes"):
         """
         Merges the self._nodes attribute with alternate labelled node images. The alternate nodes can be inputted as a string for a filepath to a tif,
         or as a directory address containing only tif images, which will merge the _nodes attribute with all tifs in the folder. The _node_identities attribute
@@ -3439,8 +3456,13 @@ class Network_3D:
         :param label_nodes: (Optional - Val = True; Boolean). Will label all discrete objects in each node file being merged if True. If False, will not label.
         """
 
-        nodes_name = 'Root_Nodes'
+        nodes_name = root_id
 
+        try:
+            nodes_name = os.path.splitext(os.path.basename(nodes_name))[0]
+        except:
+            pass
+            
         identity_dict = {} #A dictionary to deliniate the node identities
 
         try: #Try presumes the input is a tif
@@ -3462,7 +3484,10 @@ class Network_3D:
             for i, addn_nodes in enumerate(addn_nodes_list):
                 try:
                     addn_nodes_ID = addn_nodes
-                    addn_nodes = tifffile.imread(f'{addn_nodes_name}/{addn_nodes}')
+                    try:
+                        addn_nodes = tifffile.imread(f'{addn_nodes_name}/{addn_nodes}')
+                    except:
+                        continue
 
                     if label_nodes is True:
                         addn_nodes, num_nodes2 = label_objects(addn_nodes)  # Label the node objects. Note this presumes no overlap between node masks.
@@ -4266,7 +4291,7 @@ class Network_3D:
 
 
 
-    def get_degrees(self, down_factor = 1, directory = None, called = False, no_img = 0):
+    def get_degrees(self, down_factor = 1, directory = None, called = False, no_img = 0, heatmap = False):
         """
         Method to obtain information on the degrees of nodes in the network, also generating overlays that relate this information to the 3D structure.
         Overlays include a grayscale image where nodes are assigned a grayscale value corresponding to their degree, and a numerical index where numbers are drawn at nodes corresponding to their degree.
@@ -4276,6 +4301,27 @@ class Network_3D:
         :returns: A dictionary of degree values for each node.
         """
 
+        if heatmap:
+            import statistics
+            degrees_dict = {node: val for (node, val) in self.network.degree()}
+            pred = statistics.mean(list(degrees_dict.values()))
+
+            node_intensity = {}
+            import math
+            node_centroids = {}
+
+            for node in list(self.network.nodes()):
+                node_intensity[node] = math.log(self.network.degree(node)/pred)
+                node_centroids[node] = self.node_centroids[node]
+
+            from . import neighborhoods
+
+            overlay = neighborhoods.create_node_heatmap(node_intensity, node_centroids, shape = self.nodes.shape, is_3d=True, labeled_array = self.nodes)
+
+            return degrees_dict, overlay
+
+
+
         if down_factor > 1:
             centroids = self._node_centroids.copy()
             for item in self._node_centroids:
@@ -4632,24 +4678,27 @@ class Network_3D:
                     dim = 3
                     break
 
-
         if ignore_dims:
 
             factor = 0.25
 
+            big_array = proximity.convert_centroids_to_array(list(self.node_centroids.values()))
 
             if bounds is None:
-                if dim == 2:
-                    min_coords = np.array([0,0])
-                else:
-                    min_coords = np.array([0,0,0])
-                max_coords = np.max(points_array, axis=0)
+                min_coords = np.array([0,0,0])
+                max_coords = [np.max(big_array[:, 0]), np.max(big_array[:, 1]), np.max(big_array[:, 2])]
+                del big_array
                 max_coords = np.flip(max_coords)
                 bounds = (min_coords, max_coords)
             else:
                 min_coords, max_coords = bounds
 
-            dim_list = max_coords - min_coords
+            try:
+                dim_list = max_coords - min_coords
+            except:
+                min_coords = np.array([0,0,0])
+                bounds = (min_coords, max_coords)
+                dim_list = max_coords - min_coords
 
             new_list = []
 
@@ -4659,6 +4708,10 @@ class Network_3D:
 
                     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)
+
+
+                    #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:
@@ -4688,7 +4741,7 @@ class Network_3D:
 
         h_vals = proximity.compute_ripleys_h(k_vals, r_vals, dim)
 
-        proximity.plot_ripley_functions(r_vals, k_vals, h_vals, dim)
+        proximity.plot_ripley_functions(r_vals, k_vals, h_vals, dim, root, targ)
 
         return r_vals, k_vals, h_vals
 
@@ -5039,7 +5092,7 @@ class Network_3D:
 
         self.communities = invert_dict(com_dict)
 
-    def community_heatmap(self, num_nodes = None, is3d = True):
+    def community_heatmap(self, num_nodes = None, is3d = True, numpy = False):
 
         import math
 
@@ -5077,10 +5130,148 @@ class Network_3D:
         for com, nodes in coms.items():
             heat_dict[com] = math.log(len(nodes)/rand_dens)
 
+        try:
+            shape = self.nodes.shape
+        except:
+            big_array = proximity.convert_centroids_to_array(list(self.node_centroids.values()))
+            shape = [np.max(big_array[0, :]) + 1, np.max(big_array[1, :]) + 1, np.max(big_array[2, :]) + 1]
+
         from . import neighborhoods
-        neighborhoods.create_community_heatmap(heat_dict, self.communities, self.node_centroids, is_3d=is3d)
+        if not numpy:
+            neighborhoods.create_community_heatmap(heat_dict, self.communities, self.node_centroids, shape = shape, is_3d=is3d)
+
+            return heat_dict
+        else:
+            overlay = neighborhoods.create_community_heatmap(heat_dict, self.communities, self.node_centroids, shape = shape, is_3d=is3d, labeled_array = self.nodes)
+            return heat_dict, overlay
+
+
+    def merge_node_ids(self, path, data):
+
+        if self.node_identities is None: # Prepare modular dict
+
+            self.node_identities = {}
+
+            nodes = list(np.unique(data))
+            if 0 in nodes:
+                del nodes[0]
+
+            for node in nodes:
+                self.node_identities[node] = ''
+
+        img_list = directory_info(path)
+
+        for i, img in enumerate(img_list):
+            mask = tifffile.imread(f'{path}/{img}')
+
+            if len(np.unique(mask)) != 2:
+
+                mask = otsu_binarize(mask)
+
+            nodes = data * mask
+            nodes = list(np.unique(nodes))
+            if 0 in nodes:
+                del nodes[0]
+
+            if img.endswith('.tiff'):
+                base_name = img[:-5]
+            elif img.endswith('.tif'):
+                base_name = img[:-4]
+            else:
+                base_name = img
+
+            for node in self.node_identities.keys():
+
+                try:
+
+                    if node in nodes:
+
+                        self.node_identities[node] += f" {base_name}+"
+
+                    else:
+
+                        self.node_identities[node] += f" {base_name}-"
+
+                except:
+                    pass
+
+
+    def nearest_neighbors_avg(self, root, targ, xy_scale = 1, z_scale = 1, num = 1, heatmap = False, threed = True, numpy = False):
+
+        root_set = []
+
+        compare_set = []
+
+        if root is None:
+
+            root_set = list(self.node_centroids.keys())
+            compare_set = root_set
+            title = "Nearest Neighbors Between Nodes Heatmap"
+
+        else:
+
+            title = f"Nearest Neighbors of ID {targ} from ID {root} Heatmap"
+
+            for node, iden in self.node_identities.items():
+
+                if iden == root:
+
+                    root_set.append(node)
+
+                elif (iden == targ) or (targ == 'All Others (Excluding Self)'):
+
+                    compare_set.append(node)
+
+        if root == targ:
+
+            compare_set = root_set
+            if len(compare_set) - 1 < num:
+
+                print("Error: Not enough neighbor nodes for requested number of neighbors")
+                return
+
+        if len(compare_set) < num:
+
+            print("Error: Not enough neighbor nodes for requested number of neighbors")
+            return
+
+        avg, output = proximity.average_nearest_neighbor_distances(self.node_centroids, root_set, compare_set, xy_scale=self.xy_scale, z_scale=self.z_scale, num = num)
+
+        if heatmap:
+
+
+            from . import neighborhoods
+            try:
+                shape = self.nodes.shape
+            except:
+                big_array = proximity.convert_centroids_to_array(list(self.node_centroids.values()))
+                shape = [np.max(big_array[0, :]) + 1, np.max(big_array[1, :]) + 1, np.max(big_array[2, :]) + 1]
+
+            pred = avg
+
+            node_intensity = {}
+            import math
+            node_centroids = {}
+
+            for node in root_set:
+                node_intensity[node] = math.log(pred/output[node])
+                node_centroids[node] = self.node_centroids[node]
+
+            if numpy:
+
+                overlay = neighborhoods.create_node_heatmap(node_intensity, node_centroids, shape = shape, is_3d=threed, labeled_array = self.nodes, colorbar_label="Clustering Intensity", title = title)
+
+                return avg, output, overlay
+
+            else:
+                neighborhoods.create_node_heatmap(node_intensity, node_centroids, shape = shape, is_3d=threed, labeled_array = None, colorbar_label="Clustering Intensity", title = title)
+
+        return avg, output
+
+
+
+
 
-        return heat_dict