nettracer3d 1.0.7__tar.gz → 1.0.9__tar.gz

{nettracer3d-1.0.7/src/nettracer3d.egg-info → nettracer3d-1.0.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nettracer3d
-Version: 1.0.7
+Version: 1.0.9
 Summary: Scripts for intializing and analyzing networks from segmentations of three dimensional images.
 Author-email: Liam McLaughlin <liamm@wustl.edu>
 Project-URL: Documentation, https://nettracer3d.readthedocs.io/en/latest/
@@ -110,7 +110,9 @@ McLaughlin, L., Zhang, B., Sharma, S. et al. Three dimensional multiscalar neuro
 
 NetTracer3D was developed by Liam McLaughlin while working under Dr. Sanjay Jain at Washington University School of Medicine.
 
--- Version 1.0.7 Updates --
+-- Version 1.0.9 Updates --
 
-	* Bug fix
-	* Added handling if the user tries to load in a multichannel 3dimensional image (note this will not detect if you have a multi-channel image of 2d planes, it will think those are 3d. For now those can be split up with other software, or you can use the crop function to just isolate the channel you want as if it were a z-plane).
+	* Some bug fixes
+	* Added ability to load a full sized highlight overlay from the file menu (in case you need it for a picture - on big images the highlight overlay is computed by slice so if you reload the channel its trying to highlight, it will alter the highlight overlay, but loading in the entire highlight overlay directly will stop this behavior until a new highlight is generated).
+	* For the 'calculate edge < > node interaction' method - now can compute the length of nearby edges as an alternative option to just the volumes.
+	* Added ability to select all nodes/edges participating in the network.

{nettracer3d-1.0.7 → nettracer3d-1.0.9}/README.md

@@ -65,7 +65,9 @@ McLaughlin, L., Zhang, B., Sharma, S. et al. Three dimensional multiscalar neuro
 
 NetTracer3D was developed by Liam McLaughlin while working under Dr. Sanjay Jain at Washington University School of Medicine.
 
--- Version 1.0.7 Updates --
+-- Version 1.0.9 Updates --
 
-	* Bug fix
-	* Added handling if the user tries to load in a multichannel 3dimensional image (note this will not detect if you have a multi-channel image of 2d planes, it will think those are 3d. For now those can be split up with other software, or you can use the crop function to just isolate the channel you want as if it were a z-plane).
+	* Some bug fixes
+	* Added ability to load a full sized highlight overlay from the file menu (in case you need it for a picture - on big images the highlight overlay is computed by slice so if you reload the channel its trying to highlight, it will alter the highlight overlay, but loading in the entire highlight overlay directly will stop this behavior until a new highlight is generated).
+	* For the 'calculate edge < > node interaction' method - now can compute the length of nearby edges as an alternative option to just the volumes.
+	* Added ability to select all nodes/edges participating in the network.

{nettracer3d-1.0.7 → nettracer3d-1.0.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "nettracer3d"
-version = "1.0.7"
+version = "1.0.9"
 authors = [
   { name="Liam McLaughlin", email="liamm@wustl.edu" },
 ]

{nettracer3d-1.0.7 → nettracer3d-1.0.9}/src/nettracer3d/morphology.py

@@ -65,7 +65,7 @@ def reslice_3d_array(args):
     return resliced_array
 
 
-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):
+def _get_node_edge_dict(label_array, edge_array, label, dilate_xy, dilate_z, cores = 0, search = 0, fastdil = False, length = 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
@@ -74,24 +74,25 @@ def _get_node_edge_dict(label_array, edge_array, label, dilate_xy, dilate_z, cor
 
     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
-        label_array = np.count_nonzero(dil_array)
-        edge_array = np.count_nonzero(edge_array) # For getting the interacting skeleton
-
     elif cores == 1: #Cores being 1 presumes you do not want to 'core' included in the interaction
         label_array = dil_array - label_array
         edge_array = edge_array * label_array
-        label_array = np.count_nonzero(label_array)
-        edge_array = np.count_nonzero(edge_array) # For getting the interacting skeleton
-
     elif cores == 2: #Presumes you want skeleton within the core but to only 'count' the stuff around the core for volumes... because of imaging artifacts, perhaps
         edge_array = edge_array * dil_array
         label_array = dil_array - label_array
-        label_array = np.count_nonzero(label_array)
-        edge_array = np.count_nonzero(edge_array) # For getting the interacting skeleton
 
+    label_count = np.count_nonzero(label_array) * xy_scale * xy_scale * z_scale
 
-    
-    args = [edge_array, label_array]
+    if not length:
+        edge_count = np.count_nonzero(edge_array) * xy_scale * xy_scale * z_scale # For getting the interacting skeleton
+    else:
+        edge_count = calculate_skeleton_lengths(
+            edge_array, 
+            xy_scale=xy_scale, 
+            z_scale=z_scale
+        )
+
+    args = [edge_count, label_count]
 
     return args
 
@@ -115,7 +116,7 @@ def process_label(args):
 
 
 
-def create_node_dictionary(nodes, edges, num_nodes, dilate_xy, dilate_z, cores=0, search = 0, fastdil = False, xy_scale = 1, z_scale = 1):
+def create_node_dictionary(nodes, edges, num_nodes, dilate_xy, dilate_z, cores=0, search = 0, fastdil = False, length = False, xy_scale = 1, z_scale = 1):
     """Modified to pre-compute all bounding boxes using find_objects"""
     node_dict = {}
     array_shape = nodes.shape
@@ -135,20 +136,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, search, fastdil, xy_scale, z_scale)
+                          dilate_xy, dilate_z, cores, search, fastdil, length, xy_scale, z_scale)
 
     return node_dict
 
-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):
+def create_dict_entry(node_dict, label, sub_nodes, sub_edges, dilate_xy, dilate_z, cores = 0, search = 0, fastdil = False, length = 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, search = search, fastdil = fastdil, xy_scale = xy_scale, z_scale = z_scale)
+        node_dict[label] = _get_node_edge_dict(sub_nodes, sub_edges, label, dilate_xy, dilate_z, cores = cores, search = search, fastdil = fastdil, length = length, 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, fastdil = False):
+def quantify_edge_node(nodes, edges, search = 0, xy_scale = 1, z_scale = 1, cores = 0, resize = None, save = True, skele = False, length = False, auto = True, fastdil = False):
 
     def save_dubval_dict(dict, index_name, val1name, val2name, filename):
 
@@ -168,6 +169,9 @@ def quantify_edge_node(nodes, edges, search = 0, xy_scale = 1, z_scale = 1, core
         edges = tifffile.imread(edges)
 
     if skele:
+        if auto:
+            edges = nettracer.skeletonize(edges)
+            edges = nettracer.fill_holes_3d(edges)
         edges = nettracer.skeletonize(edges)
     else:
         edges = nettracer.binarize(edges)
@@ -188,7 +192,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, search = search, fastdil = fastdil, xy_scale = xy_scale, z_scale = z_scale) #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, length = length, xy_scale = xy_scale, z_scale = z_scale) #Find which edges connect which nodes and put them in a dictionary.
 
     if save:
     
@@ -199,6 +203,93 @@ def quantify_edge_node(nodes, edges, search = 0, xy_scale = 1, z_scale = 1, core
         return edge_quants
 
 
+# Helper methods for counting the lens of skeletons:
+
+def calculate_skeleton_lengths(skeleton_binary, xy_scale=1.0, z_scale=1.0):
+    """
+    Calculate total length of all skeletons in a 3D binary image.
+    
+    skeleton_binary: 3D boolean array where True = skeleton voxel
+    xy_scale, z_scale: physical units per voxel
+    """
+    # Find all skeleton voxels
+    skeleton_coords = np.argwhere(skeleton_binary)
+    
+    if len(skeleton_coords) == 0:
+        return 0.0
+    
+    # Create a mapping from coordinates to indices for fast lookup
+    coord_to_idx = {tuple(coord): idx for idx, coord in enumerate(skeleton_coords)}
+    
+    # Build adjacency graph
+    adjacency_list = build_adjacency_graph(skeleton_coords, coord_to_idx, skeleton_binary.shape)
+    
+    # Calculate lengths using scaled distances
+    total_length = calculate_graph_length(skeleton_coords, adjacency_list, xy_scale, z_scale)
+    
+    return total_length
+
+def build_adjacency_graph(skeleton_coords, coord_to_idx, shape):
+    """Build adjacency list for skeleton voxels using 26-connectivity."""
+    adjacency_list = [[] for _ in range(len(skeleton_coords))]
+    
+    # 26-connectivity offsets (all combinations of -1,0,1 except 0,0,0)
+    offsets = []
+    for dz in [-1, 0, 1]:
+        for dy in [-1, 0, 1]:
+            for dx in [-1, 0, 1]:
+                if not (dx == 0 and dy == 0 and dz == 0):
+                    offsets.append((dz, dy, dx))
+    
+    for idx, coord in enumerate(skeleton_coords):
+        z, y, x = coord
+        
+        # Check all 26 neighbors
+        for dz, dy, dx in offsets:
+            nz, ny, nx = z + dz, y + dy, x + dx
+            
+            # Check bounds
+            if (0 <= nz < shape[0] and 
+                0 <= ny < shape[1] and 
+                0 <= nx < shape[2]):
+                
+                neighbor_coord = (nz, ny, nx)
+                if neighbor_coord in coord_to_idx:
+                    neighbor_idx = coord_to_idx[neighbor_coord]
+                    adjacency_list[idx].append(neighbor_idx)
+    
+    return adjacency_list
+
+def calculate_graph_length(skeleton_coords, adjacency_list, xy_scale, z_scale):
+    """Calculate total length by summing distances between adjacent voxels."""
+    total_length = 0.0
+    processed_edges = set()
+    
+    for idx, neighbors in enumerate(adjacency_list):
+        coord = skeleton_coords[idx]
+        
+        for neighbor_idx in neighbors:
+            # Avoid double-counting edges
+            edge = tuple(sorted([idx, neighbor_idx]))
+            if edge in processed_edges:
+                continue
+            processed_edges.add(edge)
+            
+            neighbor_coord = skeleton_coords[neighbor_idx]
+            
+            # Calculate scaled distance
+            dz = (coord[0] - neighbor_coord[0]) * z_scale
+            dy = (coord[1] - neighbor_coord[1]) * xy_scale
+            dx = (coord[2] - neighbor_coord[2]) * xy_scale
+            
+            distance = np.sqrt(dx*dx + dy*dy + dz*dz)
+            total_length += distance
+    
+    return total_length
+
+# End helper methods
+
+
 
 def calculate_voxel_volumes(array, xy_scale=1, z_scale=1):
     """

{nettracer3d-1.0.7 → nettracer3d-1.0.9}/src/nettracer3d/nettracer.py

@@ -804,7 +804,7 @@ def threshold(arr, proportion, custom_rad = None):
 
         threshold_index = int(len(sorted_values) * proportion)
         threshold_value = sorted_values[threshold_index]
-        print(f"Thresholding as if smallest_radius as assigned {threshold_value}")
+        print(f"Thresholding as if smallest_radius was assigned {threshold_value}")
 
 
     mask = arr > threshold_value
@@ -3143,6 +3143,14 @@ class Network_3D:
         Can be called on a Network_3D object to save the nodes property to hard mem as a tif. It will save to the active directory if none is specified.
         :param directory: (Optional - Val = None; String). The path to an indended directory to save the nodes to.
         """
+        imagej_metadata = {
+            'spacing': self.z_scale,
+            'slices': self._nodes.shape[0],
+            'channels': 1,
+            'axes': 'ZYX'
+        }
+        resolution_value = 1.0 / self.xy_scale if self.xy_scale != 0 else 1
+
         if filename is None:
             filename = "labelled_nodes.tif"
         elif not filename.endswith(('.tif', '.tiff')):
@@ -3151,13 +3159,19 @@ class Network_3D:
         if self._nodes is not None:
             if directory is None:
                 try:
-                    tifffile.imwrite(f"{filename}", self._nodes)
+                    if len(self._nodes.shape) == 3:
+                        tifffile.imwrite(f"{filename}", self._nodes, imagej=True, metadata=imagej_metadata, resolution=(resolution_value, resolution_value))
+                    else:
+                        tifffile.imwrite(f"{filename}", self._nodes)
                     print(f"Nodes saved to {filename}")
                 except Exception as e:
                     print("Could not save nodes")
             if directory is not None:
                 try:
-                    tifffile.imwrite(f"{directory}/{filename}", self._nodes)
+                    if len(self._nodes.shape) == 3:
+                        tifffile.imwrite(f"{directory}/{filename}", self._nodes, imagej=True, metadata=imagej_metadata, resolution=(resolution_value, resolution_value))
+                    else:
+                        tifffile.imwrite(f"{directory}/{filename}")
                     print(f"Nodes saved to {directory}/{filename}")
                 except Exception as e:
                     print(f"Could not save nodes to {directory}")
@@ -3170,6 +3184,15 @@ class Network_3D:
         :param directory: (Optional - Val = None; String). The path to an indended directory to save the edges to.
         """
 
+        imagej_metadata = {
+            'spacing': self.z_scale,
+            'slices': self._edges.shape[0],
+            'channels': 1,
+            'axes': 'ZYX'
+        }
+
+        resolution_value = 1.0 / self.xy_scale if self.xy_scale != 0 else 1
+
         if filename is None:
             filename = "labelled_edges.tif"
         elif not filename.endswith(('.tif', '.tiff')):
@@ -3177,11 +3200,11 @@ class Network_3D:
 
         if self._edges is not None:
             if directory is None:
-                tifffile.imwrite(f"{filename}", self._edges)
+                tifffile.imwrite(f"{filename}", self._edges, imagej=True, metadata=imagej_metadata, resolution=(resolution_value, resolution_value))
                 print(f"Edges saved to {filename}")
 
             if directory is not None:
-                tifffile.imwrite(f"{directory}/{filename}", self._edges)
+                tifffile.imwrite(f"{directory}/{filename}", self._edges, imagej=True, metadata=imagej_metadata, resolution=(resolution_value, resolution_value))
                 print(f"Edges saved to {directory}/{filename}")
 
         if self._edges is None:
@@ -3337,6 +3360,13 @@ class Network_3D:
 
     def save_network_overlay(self, directory = None, filename = None):
 
+        imagej_metadata = {
+            'spacing': self.z_scale,
+            'slices': self._network_overlay.shape[0],
+            'channels': 1,
+            'axes': 'ZYX'
+        }
+        resolution_value = 1.0 / self.xy_scale if self.xy_scale != 0 else 1
 
         if filename is None:
             filename = "overlay_1.tif"
@@ -3345,15 +3375,29 @@ class Network_3D:
 
         if self._network_overlay is not None:
             if directory is None:
-                tifffile.imwrite(f"{filename}", self._network_overlay)
+                if len(self._network_overlay.shape) == 3:
+                    tifffile.imwrite(f"{filename}", self._network_overlay, imagej=True, metadata=imagej_metadata, resolution=(resolution_value, resolution_value))
+                else:
+                    tifffile.imwrite(f"{filename}", self._network_overlay)
                 print(f"Network overlay saved to {filename}")
 
             if directory is not None:
-                tifffile.imwrite(f"{directory}/{filename}", self._network_overlay)
+                if len(self._network_overlay.shape) == 3:
+                    tifffile.imwrite(f"{directory}/{filename}", self._network_overlay, imagej=True, metadata=imagej_metadata, resolution=(resolution_value, resolution_value))
+                else:
+                    tifffile.imwrite(f"{directory}/{filename}", self._network_overlay)
                 print(f"Network overlay saved to {directory}/{filename}")
 
     def save_id_overlay(self, directory = None, filename = None):
 
+        imagej_metadata = {
+            'spacing': self.z_scale,
+            'slices': self._id_overlay.shape[0],
+            'channels': 1,
+            'axes': 'ZYX'
+        }
+        resolution_value = 1.0 / self.xy_scale if self.xy_scale != 0 else 1
+
         if filename is None:
             filename = "overlay_2.tif"
         if not filename.endswith(('.tif', '.tiff')):
@@ -3361,11 +3405,17 @@ class Network_3D:
 
         if self._id_overlay is not None:
             if directory is None:
-                tifffile.imwrite(f"{filename}", self._id_overlay)
+                if len(self._id_overlay.shape) == 3:
+                    tifffile.imwrite(f"{filename}", self._id_overlay, imagej=True, metadata=imagej_metadata, resolution=(resolution_value, resolution_value))
+                else:
+                    tifffile.imwrite(f"{filename}", self._id_overlay, imagej=True)
                 print(f"Network overlay saved to {filename}")
 
             if directory is not None:
-                tifffile.imwrite(f"{directory}/{filename}", self._id_overlay)
+                if len(self._id_overlay.shape) == 3:
+                    tifffile.imwrite(f"{directory}/{filename}", self._id_overlay, imagej=True, metadata=imagej_metadata, resolution=(resolution_value, resolution_value))
+                else:
+                    tifffile.imwrite(f"{directory}/{filename}", self._id_overlay)
                 print(f"ID overlay saved to {directory}/{filename}")
 
 
@@ -3488,7 +3538,7 @@ class Network_3D:
 
         if file_path is not None:
             self._xy_scale, self_z_scale = read_scalings(file_path)
-            print("Succesfully loaded voxel_scalings")
+            print(f"Succesfully loaded voxel_scalings; values overriden to xy_scale: {self.xy_scale}, z_scale: {self.z_scale}")
             return
 
         items = directory_info(directory)
@@ -3497,11 +3547,11 @@ class Network_3D:
             if item == 'voxel_scalings.txt':
                 if directory is not None:
                     self._xy_scale, self._z_scale = read_scalings(f"{directory}/{item}")
-                    print("Succesfully loaded voxel_scalings")
+                    print(f"Succesfully loaded voxel_scalings; values overriden to xy_scale: {self.xy_scale}, z_scale: {self.z_scale}")
                     return
                 else:
                     self._xy_scale, self._z_scale = read_scalings(item)
-                    print("Succesfully loaded voxel_scalings")
+                    print(f"Succesfully loaded voxel_scaling; values overriden to xy_scale: {self.xy_scale}, z_scale: {self.z_scale}s")
                     return
 
         print("Could not find voxel scalings. They must be in the specified directory and named 'voxel_scalings.txt'")
@@ -5403,9 +5453,9 @@ class Network_3D:
 
 
 
-    def interactions(self, search = 0, cores = 0, resize = None, save = False, skele = False, fastdil = False):
+    def interactions(self, search = 0, cores = 0, resize = None, save = False, skele = False, length = False, auto = True, fastdil = False):
 
-        return morphology.quantify_edge_node(self._nodes, self._edges, search = search, xy_scale = self._xy_scale, z_scale = self._z_scale, cores = cores, resize = resize, save = save, skele = skele, fastdil = fastdil)
+        return morphology.quantify_edge_node(self._nodes, self._edges, search = search, xy_scale = self._xy_scale, z_scale = self._z_scale, cores = cores, resize = resize, save = save, skele = skele, length = length, auto = auto, fastdil = fastdil)