nettracer3d 0.4.2__tar.gz → 0.4.4__tar.gz

{nettracer3d-0.4.2/src/nettracer3d.egg-info → nettracer3d-0.4.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: nettracer3d
-Version: 0.4.2
+Version: 0.4.4
 Summary: Scripts for intializing and analyzing networks from segmentations of three dimensional images.
 Author-email: Liam McLaughlin <boom2449@gmail.com>
 Project-URL: User_Manual, https://drive.google.com/drive/folders/1fTkz3n4LN9_VxKRKC8lVQSlrz_wq0bVn?usp=drive_link
@@ -23,6 +23,7 @@ Requires-Dist: pandas
 Requires-Dist: napari
 Requires-Dist: python-louvain
 Requires-Dist: tifffile
+Requires-Dist: qtrangeslider
 Requires-Dist: PyQt6
 Provides-Extra: cuda11
 Requires-Dist: cupy-cuda11x; extra == "cuda11"
@@ -31,15 +32,8 @@ Requires-Dist: cupy-cuda12x; extra == "cuda12"
 Provides-Extra: cupy
 Requires-Dist: cupy; extra == "cupy"
 
-NetTracer3D is a python package developed for both 2D and 3D analysis of microscopic images in the .tif file format. It supports generation of 3D networks showing the relationships between objects (or nodes) in three dimensional space, either based on their own proximity or connectivity via connecting objects such as nerves or blood vessels. In addition to these functionalities are several advanced 3D data processing algorithms, such as labeling of branched structures or abstraction of branched structures into networks. Note that nettracer3d uses segmented data, which can be segmented from other softwares such as ImageJ and imported into NetTracer3D, although it does offer its own segmentation via intensity or volumetric thresholding. NetTracer3D currently has a fully functional GUI. To use the GUI, after installing the nettracer3d package via pip, run a python script in your env with the following commands:
+NetTracer3D is a python package developed for both 2D and 3D analysis of microscopic images in the .tif file format. It supports generation of 3D networks showing the relationships between objects (or nodes) in three dimensional space, either based on their own proximity or connectivity via connecting objects such as nerves or blood vessels. In addition to these functionalities are several advanced 3D data processing algorithms, such as labeling of branched structures or abstraction of branched structures into networks. Note that nettracer3d uses segmented data, which can be segmented from other softwares such as ImageJ and imported into NetTracer3D, although it does offer its own segmentation via intensity and volumetric thresholding, or random forest machine learning segmentation. NetTracer3D currently has a fully functional GUI. To use the GUI, after installing the nettracer3d package via pip, enter the command 'nettracer3d' in your command prompt:
 
-#Start
-
-from nettracer3d import nettracer_gui
-
-nettracer_gui.run_gui()
-
-#End
 
 This gui is built from the PyQt6 package and therefore may not function on dockers or virtual envs that are unable to support PyQt6 displays. More advanced documentation (especially for the GUI) is coming down the line, but for now please see: https://drive.google.com/drive/folders/1fTkz3n4LN9_VxKRKC8lVQSlrz_wq0bVn?usp=drive_link
 for a user manual that provides older documentation.

{nettracer3d-0.4.2 → nettracer3d-0.4.4}/README.md

@@ -1,12 +1,5 @@
-NetTracer3D is a python package developed for both 2D and 3D analysis of microscopic images in the .tif file format. It supports generation of 3D networks showing the relationships between objects (or nodes) in three dimensional space, either based on their own proximity or connectivity via connecting objects such as nerves or blood vessels. In addition to these functionalities are several advanced 3D data processing algorithms, such as labeling of branched structures or abstraction of branched structures into networks. Note that nettracer3d uses segmented data, which can be segmented from other softwares such as ImageJ and imported into NetTracer3D, although it does offer its own segmentation via intensity or volumetric thresholding. NetTracer3D currently has a fully functional GUI. To use the GUI, after installing the nettracer3d package via pip, run a python script in your env with the following commands:
+NetTracer3D is a python package developed for both 2D and 3D analysis of microscopic images in the .tif file format. It supports generation of 3D networks showing the relationships between objects (or nodes) in three dimensional space, either based on their own proximity or connectivity via connecting objects such as nerves or blood vessels. In addition to these functionalities are several advanced 3D data processing algorithms, such as labeling of branched structures or abstraction of branched structures into networks. Note that nettracer3d uses segmented data, which can be segmented from other softwares such as ImageJ and imported into NetTracer3D, although it does offer its own segmentation via intensity and volumetric thresholding, or random forest machine learning segmentation. NetTracer3D currently has a fully functional GUI. To use the GUI, after installing the nettracer3d package via pip, enter the command 'nettracer3d' in your command prompt:
 
-#Start
-
-from nettracer3d import nettracer_gui
-
-nettracer_gui.run_gui()
-
-#End
 
 This gui is built from the PyQt6 package and therefore may not function on dockers or virtual envs that are unable to support PyQt6 displays. More advanced documentation (especially for the GUI) is coming down the line, but for now please see: https://drive.google.com/drive/folders/1fTkz3n4LN9_VxKRKC8lVQSlrz_wq0bVn?usp=drive_link
 for a user manual that provides older documentation.

{nettracer3d-0.4.2 → nettracer3d-0.4.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "nettracer3d"
-version = "0.4.2"
+version = "0.4.4"
 authors = [
   { name="Liam McLaughlin", email="boom2449@gmail.com" },
 ]
@@ -18,6 +18,7 @@ dependencies = [
     "napari",
     "python-louvain",
     "tifffile",
+    "qtrangeslider",
     "PyQt6"
 ]
 readme = "README.md"

{nettracer3d-0.4.2 → nettracer3d-0.4.4}/src/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-0.4.2 → nettracer3d-0.4.4}/src/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.