nettracer3d 0.4.2__py3-none-any.whl → 0.4.4__py3-none-any.whl

nettracer3d/morphology.py

@@ -101,6 +101,8 @@ def process_label(args):
     nodes, edges, label, dilate_xy, dilate_z, array_shape = args
     print(f"Processing node {label}")
     indices = np.argwhere(nodes == label)
+    if len(indices) == 0:
+        return None, None, None
     z_vals, y_vals, x_vals = get_reslice_indices((indices, dilate_xy, dilate_z, array_shape))
     if z_vals is None: #If get_reslice_indices ran into a ValueError, nothing is returned.
         return None, None, None

nettracer3d/nettracer.py

@@ -1003,6 +1003,8 @@ def dilate_3D_recursive(tiff_array, dilated_x, dilated_y, dilated_z, step_size=N
     max_dilation = max(dilated_x, dilated_y, dilated_z)
     if max_dilation < (0.2 * min_dim):
         return dilate_3D(tiff_array, dilated_x, dilated_y, dilated_z)
+    elif dilated_x == 1 and dilated_y == 1 and dilated_z == 1: #Also if there is only a single dilation don't do it
+        return dilate_3D(tiff_array, dilated_x, dilated_y, dilated_z)
     
     # Initialize step_size for first call
     if step_size is None:
@@ -1587,6 +1589,51 @@ def label_branches(array, peaks = 0, branch_removal = 0, comp_dil = 0, max_vol =
 
     return array
 
+def fix_branches(array, G, communities, fix_val = None):
+
+    def invert_dict(d):
+        inverted = {}
+        for key, value in d.items():
+            inverted.setdefault(value, []).append(key)
+        return inverted
+
+    def get_degree_threshold(community_degrees):
+        degrees = np.array(community_degrees, dtype=float)
+        hist, bins = np.histogram(degrees, bins='auto')        
+        peaks, _ = find_peaks(hist)
+        if len(peaks) > 1:
+            # Get bin value after first peak as threshold
+            return bins[peaks[0] + 1]
+        return 4  # Default fallback
+
+    avg_degree = G.number_of_edges() * 2 / G.number_of_nodes()
+
+    targs = []
+
+    inverted = invert_dict(communities)
+
+    community_degrees = {}
+
+    for com in inverted:
+        subgraph = G.subgraph(inverted[com])
+        sub_degree = subgraph.number_of_edges() * 2/ subgraph.number_of_nodes()
+        community_degrees[com] = sub_degree
+
+
+    if fix_val is None:
+        threshold = get_degree_threshold(list(community_degrees.values()))
+    else:
+        threshold = fix_val
+
+    for com in community_degrees:
+        if community_degrees[com] > threshold: #This method of comparison could possibly be more nuanced. 
+            targs.append(com)
+
+
+    return targs
+
+
+
 def label_vertices(array, peaks = 0, branch_removal = 0, comp_dil = 0, max_vol = 0, down_factor = 0, directory = None, return_skele = False, order = 0):
     """
     Can be used to label vertices (where multiple branches connect) a binary image. Labelled output will be saved to the active directory if none is specified. Note this works better on already thin filaments and may over-divide larger trunkish objects.
@@ -1789,6 +1836,7 @@ def watershed(image, directory = None, proportion = 0.1, GPU = True, smallest_ra
                     gotoexcept = 1/0
 
             except (cp.cuda.memory.OutOfMemoryError, ZeroDivisionError) as e:
+                
                 if predownsample is None:
                     down_factor = smart_dilate.catch_memory(e) #Obtain downsample amount based on memory missing
                 else:
@@ -1819,8 +1867,12 @@ def watershed(image, directory = None, proportion = 0.1, GPU = True, smallest_ra
 
     labels, _ = label_objects(distance)
 
+    if len(labels.shape) ==2:
+        labels = np.expand_dims(labels, axis = 0)
+
     del distance
 
+
     if labels.shape[1] < original_shape[1]: #If downsample was used, upsample output
         labels = upsample_with_padding(labels, downsample_needed, original_shape)
         labels = labels * old_mask
@@ -1829,8 +1881,7 @@ def watershed(image, directory = None, proportion = 0.1, GPU = True, smallest_ra
         labels = smart_dilate.smart_label(image, labels, GPU = GPU, predownsample = predownsample2)
 
     if directory is None:
-        tifffile.imwrite("Watershed_output.tif", labels)
-        print("Watershed saved to 'Watershed_output.tif'")
+        pass
     else:
         tifffile.imwrite(f"{directory}/Watershed_output.tif", labels)
         print(f"Watershed saved to {directory}/'Watershed_output.tif'")
@@ -3417,6 +3468,92 @@ class Network_3D:
             self._nodes = self._nodes.astype(np.uint16)
 
 
+    def com_to_node(self, targets = None):
+
+        def invert_dict(d):
+            inverted = {}
+            for key, value in d.items():
+                inverted.setdefault(value, []).append(key)
+            return inverted
+
+        def update_array(array_3d, value_dict, targets = None):
+            ref_array = copy.deepcopy(array_3d)
+            if targets is None:
+                for key, value_list in value_dict.items():
+                    for value in value_list:
+                        array_3d[ref_array == value] = key
+            else:
+                max_val = np.max(array_3d) + 1
+                for key, value_list in value_dict.items():
+                    for value in value_list:
+                        array_3d[ref_array == value] = max_val
+                    max_val += 1
+
+            return array_3d
+
+        if 0 in self.communities.values():
+            self.communities = {k: v + 1 for k, v in self.communities.items()} 
+            if targets is not None:
+                for item in targets:
+                    item = item + 1
+
+        inverted = invert_dict(self.communities)
+
+
+        if targets is not None:
+            new_inverted = copy.deepcopy(inverted)
+            for com in inverted:
+                if com not in targets:
+                    del new_inverted[com]
+            inverted = new_inverted
+
+
+        if self._node_identities is not None:
+            new_identities = {}
+            for com in inverted:
+                new_identities[com] = ""
+
+        list1 = self._network_lists[0] #Get network lists to change
+        list2 = self._network_lists[1]
+        list3 = self._network_lists[2]
+
+        for i in range(len(list1)):
+            list1[i] = self.communities[list1[i]] #Set node at network list spot to its community instead
+            list2[i] = self.communities[list2[i]]
+            if list1[i] == list2[i]: #If the  edge corresponding there joins different communities, it will not be set to 0
+                list3[i] = 0
+
+
+        self.network_lists = [list1, list2, list3]
+
+        if self._nodes is not None:
+            self._nodes = update_array(self._nodes, inverted, targets = targets) #Set the array to match the new network
+
+        try:
+
+            if self._node_identities is not None:
+
+                for key, value_list in inverted.items():
+                    temp_dict = {}
+                    for value in value_list:
+                        if self._node_identities[value] in temp_dict:
+                            temp_dict[self._node_identities[value]] += 1
+                        else:
+                            temp_dict[self._node_identities[value]] = 1
+                    for id_type, num in temp_dict.items():
+                        new_identities[key] += f'ID {id_type}:{num}, '
+
+                self.node_identities = new_identities
+        except:
+            pass
+
+
+
+
+
+
+
+
     def trunk_to_node(self):
         """
         Converts the edge 'trunk' into a node. In this case, the trunk is the edge that creates the most node-node connections. There may be times when many nodes are connected by a single, expansive edge that obfuscates the rest of the edges. Converting the trunk to a node can better reveal these edges.