nettracer3d 0.9.9__py3-none-any.whl → 1.1.5__py3-none-any.whl

nettracer3d/nettracer.py

@@ -35,6 +35,7 @@ from . import proximity
 from skimage.segmentation import watershed as water
 
 
+
 #These next several methods relate to searching with 3D objects by dilating each one in a subarray around their neighborhood although I don't explicitly use this anywhere... can call them deprecated although I may want to use them later again so I have them still written out here.
 
 
@@ -383,6 +384,13 @@ def invert_dict(d):
         inverted.setdefault(value, []).append(key)
     return inverted
 
+def revert_dict(d):
+    inverted = {}
+    for key, value_list in d.items():
+        for value in value_list:
+            inverted[value] = key
+    return inverted
+
 def invert_dict_special(d):
 
     d = invert_dict(d)
@@ -737,7 +745,7 @@ def estimate_object_radii(labeled_array, gpu=False, n_jobs=None, xy_scale = 1, z
         return morphology.estimate_object_radii_cpu(labeled_array, n_jobs, xy_scale = xy_scale, z_scale = z_scale)
 
 
-def break_and_label_skeleton(skeleton, peaks = 1, branch_removal = 0, comp_dil = 0, max_vol = 0, directory = None, return_skele = False, nodes = None):
+def break_and_label_skeleton(skeleton, peaks = 1, branch_removal = 0, comp_dil = 0, max_vol = 0, directory = None, return_skele = False, nodes = None, compute = True, xy_scale = 1, z_scale = 1):
     """Internal method to break open a skeleton at its branchpoints and label the remaining components, for an 8bit binary array"""
 
     if type(skeleton) == str:
@@ -746,18 +754,28 @@ def break_and_label_skeleton(skeleton, peaks = 1, branch_removal = 0, comp_dil =
     else:
         broken_skele = None
 
-    #old_skeleton = copy.deepcopy(skeleton) # The skeleton might get modified in label_vertices so we can make a preserved copy of it to use later
-
     if nodes is None:
 
-        verts = label_vertices(skeleton, peaks = peaks, branch_removal = branch_removal, comp_dil = comp_dil, max_vol = max_vol, return_skele = return_skele)
+        verts = label_vertices(skeleton, peaks = peaks, branch_removal = branch_removal, comp_dil = comp_dil, max_vol = max_vol, return_skele = return_skele, compute = compute)
 
     else:
         verts = nodes
 
     verts = invert_array(verts)
 
-    #skeleton = old_skeleton
+    """
+    if compute: # We are interested in the endpoints if we are doing the optional computation later
+        endpoints = []
+        image_copy = np.pad(skeleton, pad_width=1, mode='constant', constant_values=0)
+        nonzero_coords = np.transpose(np.nonzero(image_copy))
+        for x, y, z in nonzero_coords:
+            mini = image_copy[x-1:x+2, y-1:y+2, z-1:z+2]
+            nearby_sum = np.sum(mini)
+            threshold = 2 * image_copy[x, y, z]
+            
+            if nearby_sum <= threshold:
+                endpoints.append((x, y, z))
+    """
 
     image_copy = skeleton * verts
 
@@ -775,9 +793,137 @@ def break_and_label_skeleton(skeleton, peaks = 1, branch_removal = 0, comp_dil =
         tifffile.imwrite(filename, labeled_image, photometric='minisblack')
         print(f"Broken skeleton saved to {filename}")
 
-    return labeled_image
+    if compute:
+
+        return labeled_image, None, skeleton, None
 
+    return labeled_image, None, None, None
 
+def compute_optional_branchstats(verts, labeled_array, endpoints, xy_scale = 1, z_scale = 1):
+
+    #Lengths:
+    # Get all non-background coordinates and their labels in one pass
+    z, y, x = np.where(labeled_array != 0)
+    labels = labeled_array[z, y, x]
+
+    # Sort by label
+    sort_idx = np.argsort(labels)
+    labels_sorted = labels[sort_idx]
+    z_sorted = z[sort_idx]
+    y_sorted = y[sort_idx]
+    x_sorted = x[sort_idx]
+
+    # Find where each label starts
+    unique_labels, split_idx = np.unique(labels_sorted, return_index=True)
+    split_idx = split_idx[1:]  # Remove first index for np.split
+
+    # Split into groups
+    z_split = np.split(z_sorted, split_idx)
+    y_split = np.split(y_sorted, split_idx)
+    x_split = np.split(x_sorted, split_idx)
+
+    # Build dict
+    coords_dict = {label: np.column_stack([z, y, x]) 
+                   for label, z, y, x in zip(unique_labels, z_split, y_split, x_split)}
+
+    from sklearn.neighbors import NearestNeighbors
+    from scipy.spatial.distance import pdist, squareform
+    len_dict = {}
+    tortuosity_dict = {}
+    angle_dict = {}
+    for label, coords in coords_dict.items():
+        len_dict[label] = morphology.calculate_skeleton_lengths(labeled_array.shape, xy_scale=xy_scale, z_scale=z_scale, skeleton_coords=coords)
+        
+        # Find neighbors for all points at once
+        nbrs = NearestNeighbors(radius=1.74, algorithm='kd_tree').fit(coords)
+        neighbor_counts = nbrs.radius_neighbors(coords, return_distance=False)
+        neighbor_counts = np.array([len(n) - 1 for n in neighbor_counts])  # -1 to exclude self
+        
+        # Endpoints have exactly 1 neighbor
+        endpoints = coords[neighbor_counts == 1]
+        
+        if len(endpoints) > 1:
+            # Scale endpoints
+            scaled_endpoints = endpoints.copy().astype(float)
+            scaled_endpoints[:, 0] *= z_scale  # z dimension
+            scaled_endpoints[:, 1] *= xy_scale  # y dimension
+            scaled_endpoints[:, 2] *= xy_scale  # x dimension
+            
+            # calculate distances on scaled coordinates
+            distances = pdist(scaled_endpoints, metric='euclidean')
+            max_distance = distances.max()
+            
+            tortuosity_dict[label] = len_dict[label]/max_distance
+
+    """
+    verts = invert_array(verts)
+    for x, y, z in endpoints:
+        try:
+            verts[z,y,x] = 1
+        except IndexError:
+            print(x, y, z)
+
+    temp_network = Network_3D(nodes = verts, edges = labeled_array, xy_scale = xy_scale, z_scale = z_scale)
+    temp_network.calculate_all(temp_network.nodes, temp_network.edges, xy_scale = temp_network.xy_scale, z_scale = temp_network.z_scale, search = None, diledge = None, inners = False, remove_trunk = 0, ignore_search_region = True, other_nodes = None, label_nodes = True, directory = None, GPU = False, fast_dil = False, skeletonize = False, GPU_downsample = None)
+    temp_network.calculate_node_centroids()
+    from itertools import combinations
+    for node in temp_network.network.nodes:
+        neighbors = list(temp_network.network.neighbors(node))
+        
+        # Skip if fewer than 2 neighbors (endpoints or isolated nodes)
+        if len(neighbors) < 2:
+            continue
+        
+        # Get all unique pairs of neighbors
+        neighbor_pairs = combinations(neighbors, 2)
+        
+        angles = []
+        for neighbor1, neighbor2 in neighbor_pairs:
+            # Get coordinates from centroids
+            point_a = temp_network.node_centroids[neighbor1]
+            point_b = temp_network.node_centroids[node]  # vertex
+            point_c = temp_network.node_centroids[neighbor2]
+            
+            # Calculate angle
+            angle_result = calculate_3d_angle(point_a, point_b, point_c, xy_scale = xy_scale, z_scale = z_scale)
+            angles.append(angle_result)
+        
+        angle_dict[node] = angles
+    """
+
+    return len_dict, tortuosity_dict, angle_dict
+
+def calculate_3d_angle(point_a, point_b, point_c, xy_scale = 1, z_scale = 1):
+    """Calculate 3D angle at vertex B between points A-B-C."""
+    z1, y1, x1 = point_a
+    z2, y2, x2 = point_b  # vertex
+    z3, y3, x3 = point_c
+    
+    # Apply scaling
+    scaled_a = np.array([x1 * xy_scale, y1 * xy_scale, z1 * z_scale])
+    scaled_b = np.array([x2 * xy_scale, y2 * xy_scale, z2 * z_scale])
+    scaled_c = np.array([x3 * xy_scale, y3 * xy_scale, z3 * z_scale])
+    
+    # Create vectors from vertex B
+    vec_ba = scaled_a - scaled_b
+    vec_bc = scaled_c - scaled_b
+    
+    # Calculate angle using dot product
+    dot_product = np.dot(vec_ba, vec_bc)
+    magnitude_ba = np.linalg.norm(vec_ba)
+    magnitude_bc = np.linalg.norm(vec_bc)
+    
+    # Avoid division by zero
+    if magnitude_ba == 0 or magnitude_bc == 0:
+        return {'angle_degrees': 0}
+    
+    cos_angle = dot_product / (magnitude_ba * magnitude_bc)
+    cos_angle = np.clip(cos_angle, -1.0, 1.0)  # Handle numerical errors
+    
+    angle_radians = np.arccos(cos_angle)
+    angle_degrees = np.degrees(angle_radians)
+
+    return angle_degrees
 
 def threshold(arr, proportion, custom_rad = None):
 
@@ -803,7 +949,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
@@ -906,9 +1052,12 @@ def show_3d(arrays_3d=None, arrays_4d=None, down_factor=None, order=0, xy_scale=
         # Downsample arrays if specified
         arrays_3d = [downsample(array, down_factor, order=order) for array in arrays_3d] if arrays_3d is not None else None
         arrays_4d = [downsample(array, down_factor, order=order) for array in arrays_4d] if arrays_4d is not None else None
+        scale = [z_scale * down_factor, xy_scale * down_factor, xy_scale * down_factor]
+    else:
+        scale = [z_scale, xy_scale, xy_scale]
+
     
     viewer = napari.Viewer(ndisplay=3)
-    scale = [z_scale, xy_scale, xy_scale]  # [z, y, x] order for napari
     
     # Add 3D arrays if provided
     if arrays_3d is not None:
@@ -992,6 +1141,61 @@ def z_project(array3d, method='max'):
         raise ValueError("Method must be one of: 'max', 'mean', 'min', 'sum', 'std'")
 
 def fill_holes_3d(array, head_on = False, fill_borders = True):
+    def process_slice(slice_2d, border_threshold=0.08, fill_borders = True):
+        """
+        Process a 2D slice, considering components that touch less than border_threshold
+        of any border length as potential holes.
+        
+        Args:
+            slice_2d: 2D binary array
+            border_threshold: proportion of border that must be touched to be considered background
+        """
+        from scipy.ndimage import binary_fill_holes
+        
+        slice_2d = slice_2d.astype(np.uint8)
+
+        # Apply scipy's binary_fill_holes to the result
+        slice_2d = binary_fill_holes(slice_2d)
+        
+        return slice_2d
+        
+    print("Filling Holes...")
+    
+    array = binarize(array)
+    #inv_array = invert_array(array)
+    
+    # Create arrays for all three planes
+    array_xy = np.zeros_like(array, dtype=np.uint8)
+    array_xz = np.zeros_like(array, dtype=np.uint8)
+    array_yz = np.zeros_like(array, dtype=np.uint8)
+    
+    # Process XY plane
+    for z in range(array.shape[0]):
+        array_xy[z] = process_slice(array[z], fill_borders = fill_borders)
+        
+    if (array.shape[0] > 3) and not head_on: #only use these dimensions for sufficiently large zstacks
+        
+        # Process XZ plane    
+        for y in range(array.shape[1]):
+            slice_xz = array[:, y, :]
+            array_xz[:, y, :] = process_slice(slice_xz, fill_borders = fill_borders)
+            
+        # Process YZ plane
+        for x in range(array.shape[2]):
+            slice_yz = array[:, :, x]
+            array_yz[:, :, x] = process_slice(slice_yz, fill_borders = fill_borders)
+        
+        # Combine results from all three planes
+        filled = (array_xy | array_xz | array_yz) * 255
+        return array + filled
+    else:
+        # Apply scipy's binary_fill_holes to each XY slice
+        from scipy.ndimage import binary_fill_holes
+        for z in range(array_xy.shape[0]):
+            array_xy[z] = binary_fill_holes(array_xy[z])
+        return array_xy * 255
+
+def fill_holes_3d_old(array, head_on = False, fill_borders = True):
 
     def process_slice(slice_2d, border_threshold=0.08, fill_borders = True):
         """
@@ -1847,6 +2051,7 @@ def mirror_points_for_edge_correction(points_array, bounds, max_r, dim=3):
             all_points = np.vstack([all_points, mirrored_points])
     
     return all_points
+    
 def get_max_r_from_proportion(bounds, proportion):
     """
     Calculate max_r based on bounds and proportion, matching your generate_r_values logic.
@@ -2072,7 +2277,7 @@ def erode(arrayimage, amount, xy_scale = 1, z_scale = 1, mode = 0, preserve_labe
         arrayimage = binarize(arrayimage)
     erode_xy, erode_z = dilation_length_to_pixels(xy_scale, z_scale, amount, amount)
 
-    if mode == 0:
+    if mode == 2:
         arrayimage = (erode_3D(arrayimage, erode_xy, erode_xy, erode_z)) * 255
     else:
         arrayimage = erode_3D_dt(arrayimage, amount, xy_scaling=xy_scale, z_scaling=z_scale, preserve_labels = preserve_labels)
@@ -2127,7 +2332,7 @@ def skeletonize(arrayimage, directory = None):
 
     return arrayimage
 
-def label_branches(array, peaks = 0, branch_removal = 0, comp_dil = 0, max_vol = 0, down_factor = None, directory = None, nodes = None, bonus_array = None, GPU = True, arrayshape = None):
+def label_branches(array, peaks = 0, branch_removal = 0, comp_dil = 0, max_vol = 0, down_factor = None, directory = None, nodes = None, bonus_array = None, GPU = True, arrayshape = None, compute = False, xy_scale = 1, z_scale = 1):
     """
     Can be used to label branches 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.
     :param array: (Mandatory, string or ndarray) - If string, a path to a tif file to label. Note that the ndarray alternative is for internal use mainly and will not save its output.
@@ -2158,10 +2363,10 @@ def label_branches(array, peaks = 0, branch_removal = 0, comp_dil = 0, max_vol =
 
         other_array = skeletonize(array)
 
-        other_array = break_and_label_skeleton(other_array, peaks = peaks, branch_removal = branch_removal, comp_dil = comp_dil, max_vol = max_vol, nodes = nodes)
+        other_array, verts, skele, endpoints = break_and_label_skeleton(other_array, peaks = peaks, branch_removal = branch_removal, comp_dil = comp_dil, max_vol = max_vol, nodes = nodes, compute = compute, xy_scale = xy_scale, z_scale = z_scale)
 
     else:
-        array = break_and_label_skeleton(array, peaks = peaks, branch_removal = branch_removal, comp_dil = comp_dil, max_vol = max_vol, nodes = nodes)
+        array, verts, skele, endpoints = break_and_label_skeleton(array, peaks = peaks, branch_removal = branch_removal, comp_dil = comp_dil, max_vol = max_vol, nodes = nodes, compute = compute, xy_scale = xy_scale, z_scale = z_scale)
 
     if nodes is not None and down_factor is not None:
         array = upsample_with_padding(array, down_factor, arrayshape)
@@ -2200,7 +2405,7 @@ def label_branches(array, peaks = 0, branch_removal = 0, comp_dil = 0, max_vol =
         print("Branches labelled")
 
 
-    return array
+    return array, verts, skele, endpoints
 
 def fix_branches_network(array, G, communities, fix_val = None):
 
@@ -2870,7 +3075,7 @@ class Network_3D:
                 for _ in range(weight):
                     lista.append(u)
                     listb.append(v)
-                    listc.append(weight)
+                    listc.append(0)
             
             self._network_lists = [lista, listb, listc]
 
@@ -3086,6 +3291,15 @@ 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.
         """
+        if self._nodes is not None:
+            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')):
@@ -3094,13 +3308,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}")
@@ -3113,6 +3333,16 @@ class Network_3D:
         :param directory: (Optional - Val = None; String). The path to an indended directory to save the edges to.
         """
 
+        if self._edges is not None:
+            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')):
@@ -3120,11 +3350,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:
@@ -3280,6 +3510,14 @@ class Network_3D:
 
     def save_network_overlay(self, directory = None, filename = None):
 
+        if self._network_overlay is not 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"
@@ -3288,15 +3526,30 @@ 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):
 
+        if self._id_overlay is not 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')):
@@ -3304,11 +3557,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}")
 
 
@@ -3431,7 +3690,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)
@@ -3440,11 +3699,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'")
@@ -3877,7 +4136,7 @@ class Network_3D:
         """
         self._nodes, num_nodes = label_objects(nodes, structure_3d)
 
-    def combine_nodes(self, root_nodes, other_nodes, other_ID, identity_dict, root_ID = None, centroids = False):
+    def combine_nodes(self, root_nodes, other_nodes, other_ID, identity_dict, root_ID = None, centroids = False, down_factor = None):
 
         """Internal method to merge two labelled node arrays into one"""
 
@@ -3888,7 +4147,10 @@ class Network_3D:
             max_val = np.max(root_nodes)
             other_nodes[:] = np.where(mask, other_nodes + max_val, 0)
         if centroids:
-            new_dict = network_analysis._find_centroids(other_nodes)
+            new_dict = network_analysis._find_centroids(other_nodes, down_factor = down_factor)
+            if down_factor is not None:
+                for item in new_dict:
+                    new_dict[item] = down_factor * new_dict[item]
             self.node_centroids.update(new_dict)
 
         if root_ID is not None:
@@ -3928,7 +4190,7 @@ class Network_3D:
 
         return nodes, identity_dict
 
-    def merge_nodes(self, addn_nodes_name, label_nodes = True, root_id = "Root_Nodes", centroids = False):
+    def merge_nodes(self, addn_nodes_name, label_nodes = True, root_id = "Root_Nodes", centroids = False, down_factor = None):
         """
         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
@@ -3949,19 +4211,21 @@ class Network_3D:
         identity_dict = {} #A dictionary to deliniate the node identities
 
         if centroids:
-            self.node_centroids = network_analysis._find_centroids(self._nodes)
-
+            self.node_centroids = network_analysis._find_centroids(self._nodes, down_factor = down_factor)
+            if down_factor is not None:
+                for item in self.node_centroids:
+                    self.node_centroids[item] = down_factor * self.node_centroids[item]
 
         try: #Try presumes the input is a tif
             addn_nodes = tifffile.imread(addn_nodes_name) #If not this will fail and activate the except block
 
             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.
-                node_labels, identity_dict = self.combine_nodes(self._nodes, addn_nodes, addn_nodes_name, identity_dict, nodes_name, centroids = centroids) #This method stacks labelled arrays
+                node_labels, identity_dict = self.combine_nodes(self._nodes, addn_nodes, addn_nodes_name, identity_dict, nodes_name, centroids = centroids, down_factor = down_factor) #This method stacks labelled arrays
                 num_nodes = np.max(node_labels)
 
             else: #If nodes already labelled
-                node_labels, identity_dict = self.combine_nodes(self._nodes, addn_nodes, addn_nodes_name, identity_dict, nodes_name, centroids = centroids)
+                node_labels, identity_dict = self.combine_nodes(self._nodes, addn_nodes, addn_nodes_name, identity_dict, nodes_name, centroids = centroids, down_factor = down_factor)
                 num_nodes = int(np.max(node_labels))
 
         except: #Exception presumes the input is a directory containing multiple tifs, to allow multi-node stackage.
@@ -3979,15 +4243,15 @@ class Network_3D:
                     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.
                         if i == 0:
-                            node_labels, identity_dict = self.combine_nodes(self._nodes, addn_nodes, addn_nodes_ID, identity_dict, nodes_name, centroids = centroids)
+                            node_labels, identity_dict = self.combine_nodes(self._nodes, addn_nodes, addn_nodes_ID, identity_dict, nodes_name, centroids = centroids, down_factor = down_factor)
                         else:
-                            node_labels, identity_dict = self.combine_nodes(node_labels, addn_nodes, addn_nodes_ID, identity_dict, centroids = centroids)
+                            node_labels, identity_dict = self.combine_nodes(node_labels, addn_nodes, addn_nodes_ID, identity_dict, centroids = centroids, down_factor = down_factor)
 
                     else:
                         if i == 0:
-                            node_labels, identity_dict = self.combine_nodes(self._nodes, addn_nodes, addn_nodes_ID, identity_dict, nodes_name, centroids = centroids)
+                            node_labels, identity_dict = self.combine_nodes(self._nodes, addn_nodes, addn_nodes_ID, identity_dict, nodes_name, centroids = centroids, down_factor = down_factor)
                         else:
-                            node_labels, identity_dict = self.combine_nodes(node_labels, addn_nodes, addn_nodes_ID, identity_dict, centroids = centroids)
+                            node_labels, identity_dict = self.combine_nodes(node_labels, addn_nodes, addn_nodes_ID, identity_dict, centroids = centroids, down_factor = down_factor)
                 except Exception as e:
                     print("Could not open additional nodes, verify they are being inputted correctly...")
 
@@ -4037,6 +4301,88 @@ class Network_3D:
             self._network_lists = network_analysis.read_excel_to_lists(df)
             self._network, net_weights = network_analysis.weighted_network(df)
 
+    def create_id_network(self, n=5):
+        import ast
+        import random
+        
+        if self.node_identities is None:
+            return
+        
+        def invert_dict(d):
+            inverted = {}
+            for key, value in d.items():
+                inverted.setdefault(value, []).append(key)
+            return inverted
+        
+        # Invert to get identity -> list of nodes
+        identity_to_nodes = invert_dict(self.node_identities)
+        
+        G = nx.Graph()
+        edge_set = set()
+        
+        # Step 1: Connect nodes within same exact identity
+        for identity, nodes in identity_to_nodes.items():
+            if len(nodes) <= 1:
+                continue
+            
+            # Each node chooses n random neighbors from its identity group
+            for node in nodes:
+                available = [other for other in nodes if other != node]
+                num_to_choose = min(n, len(available))
+                neighbors = random.sample(available, num_to_choose)
+                
+                for neighbor in neighbors:
+                    edge = tuple(sorted([node, neighbor]))
+                    edge_set.add(edge)
+        
+        # Step 2: For list-like identities, connect across groups with shared sub-identities
+        for identity, nodes in identity_to_nodes.items():
+            if identity.startswith('['):
+                try:
+                    sub_identities = ast.literal_eval(identity)
+                    
+                    # For each sub-identity in this list-like identity
+                    for sub_id in sub_identities:
+                        # Find all OTHER identity groups that contain this sub-identity
+                        for other_identity, other_nodes in identity_to_nodes.items():
+                            if other_identity == identity:
+                                continue  # Skip connecting to same exact identity (already done in Step 1)
+                            
+                            # Check if other_identity contains sub_id
+                            contains_sub_id = False
+                            
+                            if other_identity.startswith('['):
+                                try:
+                                    other_sub_ids = ast.literal_eval(other_identity)
+                                    if sub_id in other_sub_ids:
+                                        contains_sub_id = True
+                                except (ValueError, SyntaxError):
+                                    pass
+                            elif other_identity == sub_id:
+                                # Single identity that matches our sub-identity
+                                contains_sub_id = True
+                            
+                            if contains_sub_id:
+                                # Each node from current identity connects to n nodes from other_identity
+                                for node in nodes:
+                                    num_to_choose = min(n, len(other_nodes))
+                                    if num_to_choose > 0:
+                                        neighbors = random.sample(other_nodes, num_to_choose)
+                                        
+                                        for neighbor in neighbors:
+                                            edge = tuple(sorted([node, neighbor]))
+                                            edge_set.add(edge)
+                
+                except (ValueError, SyntaxError):
+                    pass  # Not a valid list, treat as already handled in Step 1
+        
+        G.add_edges_from(edge_set)
+        self.network = G
+
+
+
+
+
     def calculate_all(self, nodes, edges, xy_scale = 1, z_scale = 1, down_factor = None, search = None, diledge = None, inners = True, remove_trunk = 0, ignore_search_region = False, other_nodes = None, label_nodes = True, directory = None, GPU = True, fast_dil = True, skeletonize = False, GPU_downsample = None):
         """
         Method to calculate and save to mem all properties of a Network_3D object. In general, after initializing a Network_3D object, this method should be called on the node and edge masks that will be used to calculate the network.
@@ -5232,32 +5578,35 @@ class Network_3D:
                             new_list.append(centroid)
 
             else:
-
                 if mode == 1:
-
                     legal = self.edges != 0
-
                 elif mode == 2:
-
                     legal = self.network_overlay != 0
-
                 elif mode == 3:
-
                     legal = self.id_overlay != 0
-
                 if self.nodes is None:
-
                     temp_array = proximity.populate_array(self.node_centroids, shape = legal.shape)
                 else:
                     temp_array = self.nodes
-
                 if dim == 2:
                     volume = np.count_nonzero(legal) * self.xy_scale**2
+                    # Pad in x and y dimensions (assuming shape is [y, x])
+                    legal = np.pad(legal, pad_width=1, mode='constant', constant_values=0)
                 else:
                     volume = np.count_nonzero(legal) * self.z_scale * self.xy_scale**2
+                    # Pad in x, y, and z dimensions (assuming shape is [z, y, x])
+                    legal = np.pad(legal, pad_width=1, mode='constant', constant_values=0)
+                
                 print(f"Using {volume} for the volume measurement (Volume of provided mask as scaled by xy and z scaling)")
-
-                legal = smart_dilate.compute_distance_transform_distance(legal, sampling = [self.z_scale, self.xy_scale, self.xy_scale]) # Get true distances
+                
+                # Compute distance transform on padded array
+                legal = smart_dilate.compute_distance_transform_distance(legal, sampling = [self.z_scale, self.xy_scale, self.xy_scale])
+                
+                # Remove padding after distance transform
+                if dim == 2:
+                    legal = legal[1:-1, 1:-1]  # Remove padding from x and y dimensions
+                else:
+                    legal = legal[1:-1, 1:-1, 1:-1]  # Remove padding from x, y, and z dimensions
                 
                 max_avail = np.max(legal) # Most internal point
                 min_legal = factor * max_avail # Values of stuff 25% within the tissue
@@ -5338,9 +5687,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)
 
 
 
@@ -5511,7 +5860,7 @@ class Network_3D:
         neighborhoods.visualize_cluster_composition_umap(self.node_centroids, None, id_dictionary = self.node_identities, graph_label = "Node ID", title = 'UMAP Visualization of Node Centroids') 
 
 
-    def identity_umap(self, data):
+    def identity_umap(self, data, mode = 0):
 
         try:
 
@@ -5531,16 +5880,18 @@ class Network_3D:
                 else:
                     del umap_dict[item]
 
-            from scipy.stats import zscore
+            #from scipy.stats import zscore
 
             # Z-score normalize each marker (column)
-            for key in umap_dict:
-                umap_dict[key] = zscore(umap_dict[key])
-
+            #for key in umap_dict:
+                #umap_dict[key] = zscore(umap_dict[key])
 
             from . import neighborhoods
 
-            neighborhoods.visualize_cluster_composition_umap(umap_dict, None, id_dictionary = neighbor_classes, graph_label = "Node ID", title = 'UMAP Visualization of Node Identities by Z-Score') 
+            if mode == 0:
+                neighborhoods.visualize_cluster_composition_umap(umap_dict, None, id_dictionary = neighbor_classes, graph_label = "Node ID", title = 'UMAP Visualization of Node Identities by Z-Score') 
+            else:
+                neighborhoods.visualize_cluster_composition_umap(umap_dict, None, id_dictionary = neighbor_classes, graph_label = "Node ID", title = 'UMAP Visualization of Node Identities by Z-Score', neighborhoods = self.communities, original_communities = self.communities) 
 
         except Exception as e:
             import traceback
@@ -5659,7 +6010,7 @@ class Network_3D:
                         neighbor_group[com] = neighbors[node]
                     except:
                         neighbor_group[com] = 0
-                neighborhoods.visualize_cluster_composition_umap(umap_dict, id_set, neighborhoods = neighbor_group)
+                neighborhoods.visualize_cluster_composition_umap(umap_dict, id_set, neighborhoods = neighbor_group, original_communities = neighbors)
             elif label == 1:
                 neighborhoods.visualize_cluster_composition_umap(umap_dict, id_set, label = True) 
             else:
@@ -5671,6 +6022,19 @@ class Network_3D:
         return output, id_set
 
 
+    def group_nodes_by_intensity(self, data, count = None):
+
+        from . import neighborhoods
+
+        clusters = neighborhoods.cluster_arrays(data, count, seed = 42)
+
+        coms = {}
+
+        for i, cluster in enumerate(clusters):
+            coms[i + 1] = cluster
+
+        self.communities = revert_dict(coms)
+
     def assign_neighborhoods(self, seed, count, limit = None, prev_coms = None, proportional = False, mode = 0):
 
         from . import neighborhoods
@@ -5821,13 +6185,6 @@ class Network_3D:
 
     def community_cells(self, size = 32, xy_scale = 1, z_scale = 1):
 
-        def revert_dict(d):
-            inverted = {}
-            for key, value_list in d.items():
-                for value in value_list:
-                    inverted[value] = key
-            return inverted
-
         size_x = int(size * xy_scale)
         size_z = int(size * z_scale)
 
@@ -5992,57 +6349,94 @@ class Network_3D:
         self.node_identities = modify_dict
 
 
-    def nearest_neighbors_avg(self, root, targ, xy_scale = 1, z_scale = 1, num = 1, heatmap = False, threed = True, numpy = False, quant = False, centroids = True):
-
-        def distribute_points_uniformly(n, shape, z_scale, xy_scale, num, is_2d=False):
+    def nearest_neighbors_avg(self, root, targ, xy_scale = 1, z_scale = 1, num = 1, heatmap = False, threed = True, numpy = False, quant = False, centroids = True, mask = None):
 
+        def distribute_points_uniformly(n, shape, z_scale, xy_scale, num, is_2d=False, mask=None):
             from scipy.spatial import KDTree
-
             if n <= 1:
                 return 0
-                        
-            # Calculate total positions and sampling step
-            total_positions = np.prod(shape)
-            if n >= total_positions:
-                # If we want more points than positions, just return scaled unit distance
-                return xy_scale if is_2d else min(z_scale, xy_scale)
-            
-            # Create uniformly spaced indices
-            indices = np.linspace(0, total_positions - 1, n, dtype=int)
             
-            # Convert flat indices to coordinates
-            coords = []
-            for idx in indices:
-                coord = np.unravel_index(idx, shape)
+            if mask is not None:
+                # Handle mask-based distribution
+                # Find all valid positions where mask is True
+                valid_positions = np.where(mask)
+                total_valid_positions = len(valid_positions[0])
+                
+                if total_valid_positions == 0:
+                    raise ValueError("No valid positions found in mask")
+                
+                if n >= total_valid_positions:
+                    # If we want more points than valid positions, return scaled unit distance
+                    return xy_scale if is_2d else min(z_scale, xy_scale)
+                
+                # Create uniformly spaced indices within valid positions
+                valid_indices = np.linspace(0, total_valid_positions - 1, n, dtype=int)
+                
+                # Convert to coordinates and apply scaling
+                coords = []
+                for idx in valid_indices:
+                    if len(shape) == 3:
+                        coord = (valid_positions[0][idx], valid_positions[1][idx], valid_positions[2][idx])
+                        scaled_coord = [coord[0] * z_scale, coord[1] * xy_scale, coord[2] * xy_scale]
+                    elif len(shape) == 2:
+                        coord = (valid_positions[0][idx], valid_positions[1][idx])
+                        scaled_coord = [coord[0] * xy_scale, coord[1] * xy_scale]
+                    coords.append(scaled_coord)
+                
+                coords = np.array(coords)
+                
+                # Find a good query point (closest to center of valid region)
                 if len(shape) == 3:
-                    # Apply scaling: [z, y, x] with respective scales
-                    scaled_coord = [coord[0] * z_scale, coord[1] * xy_scale, coord[2] * xy_scale]
-                elif len(shape) == 2:
-                    # Apply scaling: [y, x] with xy_scale
-                    scaled_coord = [coord[0] * xy_scale, coord[1] * xy_scale]
-                coords.append(scaled_coord)
-            
-            coords = np.array(coords)
+                    center_pos = [np.mean(valid_positions[0]) * z_scale, 
+                                 np.mean(valid_positions[1]) * xy_scale,
+                                 np.mean(valid_positions[2]) * xy_scale]
+                else:
+                    center_pos = [np.mean(valid_positions[0]) * xy_scale,
+                                 np.mean(valid_positions[1]) * xy_scale]
+                
+                # Find point closest to center of valid region
+                center_distances = np.sum((coords - center_pos)**2, axis=1)
+                middle_idx = np.argmin(center_distances)
+                query_point = coords[middle_idx]
+                
+            else:
+                # Original behavior when no mask is provided
+                total_positions = np.prod(shape)
+                if n >= total_positions:
+                    return xy_scale if is_2d else min(z_scale, xy_scale)
+                
+                # Create uniformly spaced indices
+                indices = np.linspace(0, total_positions - 1, n, dtype=int)
+                
+                # Convert flat indices to coordinates
+                coords = []
+                for idx in indices:
+                    coord = np.unravel_index(idx, shape)
+                    if len(shape) == 3:
+                        scaled_coord = [coord[0] * z_scale, coord[1] * xy_scale, coord[2] * xy_scale]
+                    elif len(shape) == 2:
+                        scaled_coord = [coord[0] * xy_scale, coord[1] * xy_scale]
+                    coords.append(scaled_coord)
+                
+                coords = np.array(coords)
+                
+                # Pick a point near the middle of the array
+                middle_idx = len(coords) // 2
+                query_point = coords[middle_idx]
             
             # Build KDTree
             tree = KDTree(coords)
             
-            # Pick a point near the middle of the array
-            middle_idx = len(coords) // 2
-            query_point = coords[middle_idx]
-            
             # Find the num+1 nearest neighbors (including the point itself)
             distances, indices = tree.query(query_point, k=num+1)
             
             # Exclude the point itself (distance 0) and get the actual neighbors
             neighbor_distances = distances[1:num+1]
-
             if num == n:
                 neighbor_distances[-1] = neighbor_distances[-2]
             
             avg_distance = np.mean(neighbor_distances)
             
-            
             return avg_distance
 
         do_borders = not centroids
@@ -6064,14 +6458,25 @@ class Network_3D:
 
                 for node, iden in self.node_identities.items():
 
-                    if iden == root:
+                    if iden == root: # Standard behavior
 
                         root_set.append(node)
 
-                    elif (iden == targ) or (targ == 'All Others (Excluding Self)'):
+                    elif '[' in iden and root != "All (Excluding Targets)": # For multiple nodes
+                        if root in iden:
+                            root_set.append(node)
+
+                    elif (iden == targ) or (targ == 'All Others (Excluding Self)'): # The other group
 
                         compare_set.append(node)
 
+                    elif '[' in iden: # The other group, for multiple nodes
+                        if targ in iden:
+                            compare_set.append(node)
+
+                    elif root == "All (Excluding Targets)": # If not assigned to the other group but the comprehensive root option is used
+                        root_set.append(node)
+
             if root == targ:
 
                 compare_set = root_set
@@ -6094,11 +6499,11 @@ class Network_3D:
             if heatmap:
                 root_set = []
                 compare_set = []
-                if root is None:
-
-                    root_set = list(self.node_centroids.keys())
+                if root is None and not do_borders:
                     compare_set = root_set
-                else:
+                    if not do_borders:
+                        root_set = list(self.node_centroids.keys())
+                elif self.node_identities is not None:
                     for node, iden in self.node_identities.items():
 
                         if iden == root:
@@ -6126,7 +6531,8 @@ class Network_3D:
                     targ = [targ]
 
                 compare_set_neigh = approx_boundaries(self.nodes, targ, self.node_identities, keep_labels = False)
-                avg, output = proximity.average_nearest_neighbor_distances(self.node_centroids, root_set_neigh, compare_set_neigh, xy_scale=self.xy_scale, z_scale=self.z_scale, num = num, do_borders = do_borders)
+
+            avg, output = proximity.average_nearest_neighbor_distances(self.node_centroids, root_set_neigh, compare_set_neigh, xy_scale=self.xy_scale, z_scale=self.z_scale, num = num, do_borders = do_borders)
 
         if quant:
             try:
@@ -6168,7 +6574,15 @@ class Network_3D:
             else:
                 is_2d = False
 
-            pred = distribute_points_uniformly(len(compare_set), bounds, self.z_scale, self.xy_scale, num = num, is_2d = is_2d)
+            if root_set == []:
+                avail_nodes = np.unique(self.nodes)
+                compare_set = list(avail_nodes)
+                if 0 in compare_set:
+                    del compare_set[0]
+                root_set = compare_set
+            elif compare_set == []:
+                compare_set = root_set
+            pred = distribute_points_uniformly(len(compare_set), bounds, self.z_scale, self.xy_scale, num = num, is_2d = is_2d, mask = mask)
 
             node_intensity = {}
             import math
@@ -6176,7 +6590,6 @@ class Network_3D:
 
             for node in root_set:
                 node_intensity[node] = math.log(pred/output[node])
-                #print(output[node])
                 node_centroids[node] = self.node_centroids[node]
 
             if numpy: