nettracer3d 1.0.8__py3-none-any.whl → 1.0.9__py3-none-any.whl

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/nettracer.py

@@ -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)