nettracer3d 0.8.9__py3-none-any.whl → 0.9.0__py3-none-any.whl

nettracer3d/cellpose_manager.py

@@ -16,14 +16,15 @@ class CellposeGUILauncher:
         """
         self.parent_widget = parent_widget
         self.cellpose_process = None
-    
-    def launch_cellpose_gui(self, image_path=None, working_directory=None):
+        
+    def launch_cellpose_gui(self, image_path=None, working_directory=None, use_3d=False):
         """
         Launch cellpose GUI in a separate thread.
         
         Args:
             image_path (str, optional): Path to image file to load automatically
             working_directory (str, optional): Directory to start cellpose in
+            use_3d (bool, optional): Whether to launch cellpose 3D version (default: False)
         
         Returns:
             bool: True if launch was initiated successfully
@@ -34,6 +35,10 @@ class CellposeGUILauncher:
                 # Build command
                 cmd = [sys.executable, "-m", "cellpose"]
                 
+                # Add 3D flag if requested
+                if use_3d:
+                    cmd.append("--Zstack")
+                
                 # Add image path if provided
                 if image_path and Path(image_path).exists():
                     cmd.extend(["--image_path", str(image_path)])
@@ -55,29 +60,35 @@ class CellposeGUILauncher:
             except Exception as e:
                 if self.parent_widget:
                     # Show error in main thread
-                    self.show_error(f"Failed to launch cellpose GUI: {str(e)}")
+                    version_str = "3D " if use_3d else ""
+                    self.show_error(f"Failed to launch cellpose {version_str}GUI: {str(e)}")
                 else:
-                    print(f"Failed to launch cellpose GUI: {str(e)}")
+                    version_str = "3D " if use_3d else ""
+                    print(f"Failed to launch cellpose {version_str}GUI: {str(e)}")
         
         try:
             # Start cellpose in separate thread
             thread = threading.Thread(target=run_cellpose, daemon=True)
             thread.start()
             
-            if self.parent_widget:
-                self.show_info("Cellpose GUI launched!")
-            else:
-                print("Cellpose GUI launched!")
+            #if self.parent_widget:
+                #version_str = "3D " if use_3d else ""
+                #self.show_info(f"Cellpose {version_str}GUI launched!")
+            #else:
+                #version_str = "3D " if use_3d else ""
+                #print(f"Cellpose {version_str}GUI launched!")
             
             return True
             
         except Exception as e:
             if self.parent_widget:
-                self.show_error(f"Failed to start cellpose thread: {str(e)}")
+                version_str = "3D " if use_3d else ""
+                self.show_error(f"Failed to start cellpose {version_str}thread: {str(e)}")
             else:
-                print(f"Failed to start cellpose thread: {str(e)}")
+                version_str = "3D " if use_3d else ""
+                print(f"Failed to start cellpose {version_str}thread: {str(e)}")
             return False
-    
+        
     def launch_with_directory(self, directory_path):
         """
         Launch cellpose GUI with a specific directory.

nettracer3d/modularity.py

@@ -103,7 +103,7 @@ def read_excel_to_lists(file_path, sheet_name=0):
 
 
 
-def show_communities_flex(G, master_list, normalized_weights, geo_info = None, geometric=False, directory=None, weighted=True, partition=None, style=0):
+def show_communities_flex(G, master_list, normalized_weights, geo_info=None, geometric=False, directory=None, weighted=True, partition=None, style=0):
 
     if normalized_weights is None:
         G, edge_weights = network_analysis.weighted_network(master_list)
@@ -137,10 +137,25 @@ def show_communities_flex(G, master_list, normalized_weights, geo_info = None, g
 
     # Create a mapping of community IDs to sequential indices
     unique_communities = sorted(set(partition.values()))
-    community_to_index = {comm: idx for idx, comm in enumerate(unique_communities)}
-
-    # Prepare colors using the number of unique communities
-    colors = [plt.cm.jet(i / len(unique_communities)) for i in range(len(unique_communities))]
+    
+    # Use the same color generation method as the overlay system
+    # Get community sizes for sorting (largest first)
+    from collections import Counter
+    community_sizes = Counter(partition.values())
+    sorted_communities = sorted(unique_communities, key=lambda x: community_sizes[x], reverse=True)
+    
+    from . import community_extractor
+
+    # Generate distinct colors using the same method as assign_community_colors
+    colors_rgb = community_extractor.generate_distinct_colors(len(unique_communities))
+    
+    # Create community to color mapping (same order as the overlay system)
+    community_to_color = {comm: colors_rgb[i] for i, comm in enumerate(sorted_communities)}
+    
+    # Convert RGB tuples to matplotlib format (0-1 range)
+    colors_matplotlib = {}
+    for comm, rgb in community_to_color.items():
+        colors_matplotlib[comm] = tuple(c/255.0 for c in rgb)
 
     if weighted:
         G = nx.Graph()
@@ -156,7 +171,7 @@ def show_communities_flex(G, master_list, normalized_weights, geo_info = None, g
             for community_id, nodes in communities.items():
                 node_sizes_list = [z_pos[node] for node in nodes]
                 nx.draw_networkx_nodes(G, pos, nodelist=nodes, 
-                                     node_color=[colors[community_to_index[community_id]]], 
+                                     node_color=[colors_matplotlib[community_id]], 
                                      node_size=node_sizes_list, alpha=0.8)
 
             # Draw edges with normalized weights
@@ -172,7 +187,7 @@ def show_communities_flex(G, master_list, normalized_weights, geo_info = None, g
             # Draw the nodes, coloring them according to their community
             for community_id, nodes in communities.items():
                 nx.draw_networkx_nodes(G, pos, nodelist=nodes, 
-                                     node_color=[colors[community_to_index[community_id]]], 
+                                     node_color=[colors_matplotlib[community_id]], 
                                      node_size=100, alpha=0.8)
 
             # Draw edges with normalized weights
@@ -183,8 +198,8 @@ def show_communities_flex(G, master_list, normalized_weights, geo_info = None, g
             nx.draw_networkx_labels(G, pos)
 
     else:
-        # Create node color list based on partition and mapping
-        node_colors = [colors[community_to_index[partition[node]]] for node in G.nodes()]
+        # Create node color list based on partition and the same color mapping
+        node_colors = [colors_matplotlib[partition[node]] for node in G.nodes()]
 
         if geometric:
             pos, z_pos = simple_network.geometric_positions(geo_info[0], geo_info[1])

nettracer3d/neighborhoods.py

@@ -644,25 +644,41 @@ def create_community_heatmap(community_intensity, node_community, node_centroids
         
         # Create colormap function (RdBu_r - red for high, blue for low, yellow/white for middle)
         def intensity_to_rgb(intensity, min_val, max_val):
-            """Convert intensity value to RGB using RdBu_r colormap logic"""
+            """Convert intensity value to RGB using RdBu_r colormap logic, centered at 0"""
+            
+            # Handle edge case where all values are the same
             if max_val == min_val:
-                # All same value, use neutral color
+                if intensity == 0:
+                    return np.array([255, 255, 255], dtype=np.uint8)  # White for 0
+                elif intensity > 0:
+                    return np.array([255, 200, 200], dtype=np.uint8)  # Light red for positive
+                else:
+                    return np.array([200, 200, 255], dtype=np.uint8)  # Light blue for negative
+            
+            # Find the maximum absolute value for symmetric scaling around 0
+            max_abs = max(abs(min_val), abs(max_val))
+            
+            # If max_abs is 0, everything is 0, so return white
+            if max_abs == 0:
                 return np.array([255, 255, 255], dtype=np.uint8)  # White
             
-            # Normalize to -1 to 1 range (like RdBu_r colormap)
-            normalized = 2 * (intensity - min_val) / (max_val - min_val) - 1
+            # Normalize intensity to -1 to 1 range, centered at 0
+            normalized = intensity / max_abs
             normalized = np.clip(normalized, -1, 1)
             
             if normalized > 0:
-                # Positive values: white to red
+                # Positive values: white to red (intensity 0 = white, max positive = red)
                 r = 255
                 g = int(255 * (1 - normalized))
                 b = int(255 * (1 - normalized))
-            else:
-                # Negative values: white to blue
+            elif normalized < 0:
+                # Negative values: white to blue (intensity 0 = white, max negative = blue)  
                 r = int(255 * (1 + normalized))
                 g = int(255 * (1 + normalized))
                 b = 255
+            else:
+                # Exactly 0: white
+                r, g, b = 255, 255, 255
             
             return np.array([r, g, b], dtype=np.uint8)
         
@@ -868,25 +884,41 @@ def create_node_heatmap(node_intensity, node_centroids, shape=None, is_3d=True,
         
         # Create colormap function (RdBu_r - red for high, blue for low, yellow/white for middle)
         def intensity_to_rgb(intensity, min_val, max_val):
-            """Convert intensity value to RGB using RdBu_r colormap logic"""
+            """Convert intensity value to RGB using RdBu_r colormap logic, centered at 0"""
+            
+            # Handle edge case where all values are the same
             if max_val == min_val:
-                # All same value, use neutral color
+                if intensity == 0:
+                    return np.array([255, 255, 255], dtype=np.uint8)  # White for 0
+                elif intensity > 0:
+                    return np.array([255, 200, 200], dtype=np.uint8)  # Light red for positive
+                else:
+                    return np.array([200, 200, 255], dtype=np.uint8)  # Light blue for negative
+            
+            # Find the maximum absolute value for symmetric scaling around 0
+            max_abs = max(abs(min_val), abs(max_val))
+            
+            # If max_abs is 0, everything is 0, so return white
+            if max_abs == 0:
                 return np.array([255, 255, 255], dtype=np.uint8)  # White
             
-            # Normalize to -1 to 1 range (like RdBu_r colormap)
-            normalized = 2 * (intensity - min_val) / (max_val - min_val) - 1
+            # Normalize intensity to -1 to 1 range, centered at 0
+            normalized = intensity / max_abs
             normalized = np.clip(normalized, -1, 1)
             
             if normalized > 0:
-                # Positive values: white to red
+                # Positive values: white to red (intensity 0 = white, max positive = red)
                 r = 255
                 g = int(255 * (1 - normalized))
                 b = int(255 * (1 - normalized))
-            else:
-                # Negative values: white to blue
+            elif normalized < 0:
+                # Negative values: white to blue (intensity 0 = white, max negative = blue)  
                 r = int(255 * (1 + normalized))
                 g = int(255 * (1 + normalized))
                 b = 255
+            else:
+                # Exactly 0: white
+                r, g, b = 255, 255, 255
             
             return np.array([r, g, b], dtype=np.uint8)
         

nettracer3d/nettracer.py

@@ -500,7 +500,7 @@ def _upsample_3d_array(data, factor, original_shape):
     else:
         trimmed_rows = trimmed_planes[:, sub_before[1]:-sub_after[1], :]
     
-    # Remove columns from the beginning and end
+    # Remove    columns from the beginning and end
     if sub_dims[2] == 0:
         trimmed_array = trimmed_rows
     else:
@@ -508,6 +508,101 @@ def _upsample_3d_array(data, factor, original_shape):
     
     return trimmed_array
 
+
+def remove_branches_new(skeleton, length):
+    """Used to compensate for overly-branched skeletons resulting from the scipy 3d skeletonization algorithm"""
+    def find_coordinate_difference(arr):
+        try:
+            arr[1,1,1] = 0
+            # Find the indices of non-zero elements
+            indices = np.array(np.nonzero(arr)).T
+            
+            # Calculate the difference
+            diff = np.array([1,1,1]) - indices[0]
+            
+            return diff
+        except:
+            return None
+    
+    skeleton = np.pad(skeleton, pad_width=1, mode='constant', constant_values=0) #Add black planes over the 3d space to avoid index errors
+    image_copy = np.copy(skeleton)
+    
+    # Find all endpoints ONCE at the beginning
+    nonzero_coords = np.transpose(np.nonzero(image_copy))
+    endpoints = []
+    nubs = []
+    
+    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))
+    
+    x, y, z = endpoints[0]
+    original_val = image_copy[x, y, z]
+
+    # Process each endpoint individually for nub assessment
+    for start_x, start_y, start_z in endpoints:
+            
+        # Trace the branch from this endpoint, removing points as we go
+        branch_coords = []
+        current_coord = (start_x, start_y, start_z)
+        nub_reached = False
+        
+        for step in range(length):
+            x, y, z = current_coord
+            
+            # Store original value and coordinates
+            branch_coords.append((x, y, z))
+            
+            # Remove this point temporarily
+            image_copy[x, y, z] = 0
+            
+            # If we've reached the maximum length without hitting a nub, break
+            if step == length - 1:
+                break
+            
+            # Find next coordinate in the branch
+            mini = image_copy[x-1:x+2, y-1:y+2, z-1:z+2]
+            dif = find_coordinate_difference(mini.copy())
+            if dif is None:
+                break
+                
+            next_coord = (x - dif[0], y - dif[1], z - dif[2])
+            
+            # Check if next coordinate is valid and exists
+            nx, ny, nz = next_coord
+            
+            # Check if next point is a nub (has more neighbors than expected)
+            next_mini = image_copy[nx-1:nx+2, ny-1:ny+2, nz-1:nz+2]
+            next_nearby_sum = np.sum(next_mini)
+            next_threshold = 2 * image_copy[nx, ny, nz]
+            
+            if next_nearby_sum > next_threshold:
+                nub_reached = True
+                nubs.append(next_coord)
+                nubs.append(current_coord) # Note, if we don't add the current coord here (and restore it below), the behavior of this method can be changed to trim branches beneath previous branches, which could be neat but its somewhat unpredictable so I opted out of it.
+                image_copy[x, y, z] = original_val
+                #image_copy[nx, ny, nz] = 0
+                break
+                
+            current_coord = next_coord
+        
+        # If no nub was reached, restore all the points we removed
+        if not nub_reached:
+            for i, (bx, by, bz) in enumerate(branch_coords):
+                image_copy[bx, by, bz] = original_val
+        # If nub was reached, points stay removed (branch is eliminated)
+
+    for item in nubs: #The nubs are endpoints of length = 1. They appear a bit different in the array so we just note when one is created and remove them all at the end in a batch.
+        image_copy[item[0], item[1], item[2]] = 0 # Removing the nub itself leaves a hole in the skeleton but for branchpoint detection that doesn't matter, which is why it behaves this way. To fill the hole, one option is to dilate once then erode/skeletonize again, but we want to avoid making anything that looks like local branching so I didn't bother.
+
+    # Remove padding and return
+    image_copy = (image_copy[1:-1, 1:-1, 1:-1]).astype(np.uint8)
+    return image_copy
+
 def remove_branches(skeleton, length):
     """Used to compensate for overly-branched skeletons resulting from the scipy 3d skeletonization algorithm"""
 
@@ -532,6 +627,7 @@ def remove_branches(skeleton, length):
     x, y, z = nonzero_coords[0]
     threshold = 2 * skeleton[x, y, z]
     nubs = []
+    
 
     for b in range(length):
 
@@ -628,6 +724,8 @@ 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)
@@ -637,6 +735,8 @@ def break_and_label_skeleton(skeleton, peaks = 1, branch_removal = 0, comp_dil =
 
     verts = invert_array(verts)
 
+    #skeleton = old_skeleton
+
     image_copy = skeleton * verts
 
  
@@ -1031,10 +1131,93 @@ def remove_trunk(edges, num_iterations=1):
     
     return edges
 
-def hash_inners(search_region, inner_edges, GPU = True):
+def get_all_label_coords(labeled_array, background=0):
+    """
+    Get coordinates for all labels using single pass method.
+    
+    Parameters:
+    -----------
+    labeled_array : numpy.ndarray
+        Labeled array with integer labels
+    background : int, optional
+        Background label to exclude (default: 0)
+    
+    Returns:
+    --------
+    dict : {label: coordinates_array}
+        Dictionary mapping each label to its coordinate array
+    """
+    coords_dict = {}
+    
+    # Get all non-background coordinates at once
+    all_coords = np.argwhere(labeled_array != background)
+    
+    if len(all_coords) == 0:
+        return coords_dict
+    
+    # Get the label values at those coordinates
+    labels_at_coords = labeled_array[tuple(all_coords.T)]
+    
+    # Group by label
+    unique_labels = np.unique(labels_at_coords)
+    for label in unique_labels:
+        mask = labels_at_coords == label
+        coords_dict[label] = all_coords[mask]
+    
+    return coords_dict
+
+def approx_boundaries(array, iden_set = None, node_identities = None, keep_labels = False):
+
+    """Hollows out an array, can do it for only a set number of identities. Returns coords as dict if labeled or as 1d numpy array if binary is desired"""
+
+    if node_identities is not None:
+
+        nodes = []
+
+        for node in node_identities:
+
+            if node_identities[node] in iden_set: #Filter out only idens we need
+                nodes.append(node)
+
+        mask = np.isin(array, nodes)
+
+        if keep_labels:
+
+            array = array * mask
+        else:
+            array = mask
+        del mask
+
+    from skimage.segmentation import find_boundaries
+
+    borders = find_boundaries(array, mode='thick')
+    array = array * borders
+    del borders
+    if not keep_labels:
+        return np.argwhere(array != 0)
+    else:
+        return get_all_label_coords(array)
+
+
+
+def hash_inners(search_region, inner_edges, GPU = False):
     """Internal method used to help sort out inner edge connections. The inner edges of the array will not differentiate between what nodes they contact if those nodes themselves directly touch each other.
     This method allows these elements to be efficiently seperated from each other"""
 
+    from skimage.segmentation import find_boundaries
+
+    borders = find_boundaries(search_region, mode='thick')
+
+    inner_edges = inner_edges * borders #And as a result, we can mask out only 'inner edges' that themselves exist within borders
+
+    inner_edges = dilate_3D_old(inner_edges, 3, 3, 3) #Not sure if dilating is necessary. Want to ensure that the inner edge pieces still overlap with the proper nodes after the masking.
+
+    return inner_edges
+
+def hash_inners_old(search_region, inner_edges, GPU = True):
+    """Internal method used to help sort out inner edge connections. The inner edges of the array will not differentiate between what nodes they contact if those nodes themselves directly touch each other.
+    This method allows these elements to be efficiently seperated from each other. Originally this was implemented using the gaussian blur because i didn't yet realize skimage could do the same more efficiently."""
+
     print("Performing gaussian blur to hash inner edges.")
 
     blurred_search = smart_dilate.gaussian(search_region, GPU = GPU) 
@@ -2170,6 +2353,9 @@ def label_vertices(array, peaks = 0, branch_removal = 0, comp_dil = 0, max_vol =
 
     array = skeletonize(array)
 
+    if return_skele:
+        old_skeleton = copy.deepcopy(array) # The skeleton might get modified in label_vertices so we can make a preserved copy of it to use later
+
     if branch_removal > 0:
         array = remove_branches(array, branch_removal)
 
@@ -2235,7 +2421,7 @@ def label_vertices(array, peaks = 0, branch_removal = 0, comp_dil = 0, max_vol =
 
     if return_skele:
 
-        return labeled_image, (array[1:-1, 1:-1, 1:-1]).astype(np.uint8)
+        return labeled_image, old_skeleton
 
     else:
 
@@ -5668,75 +5854,128 @@ class Network_3D:
                     pass
 
 
-    def nearest_neighbors_avg(self, root, targ, xy_scale = 1, z_scale = 1, num = 1, heatmap = False, threed = True, numpy = False, quant = 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):
 
-        def get_theoretical_nearest_neighbor_distance(compare_set, num_neighbors, volume, is_2d=False):
-            """
-            Calculate theoretical expected distance to k-th nearest neighbor 
-            assuming random uniform distribution in 2D or 3D space.
-            """
-            import math
+
+        def distribute_points_uniformly(n, shape, z_scale, xy_scale, is_2d=False):
+            if n <= 1:
+                return 0
+            
+            # Calculate total number of positions
+            total_positions = np.prod(shape)
+            
+            # Calculate the flat index spacing
+            flat_spacing = total_positions / n
+            
+            # Get the first two flat indices
+            idx1 = 0
+            idx2 = int(flat_spacing)
+            
+            # Convert to multi-dimensional coordinates theoretically
+            coord1 = np.unravel_index(idx1, shape)
+            coord2 = np.unravel_index(idx2, shape)
             
-            if len(compare_set) == 0 or volume <= 0:
-                raise ValueError("Invalid input: empty set or non-positive volume")
+            # Apply scaling
+            if len(shape) == 3:
+                p1 = np.array([coord1[0] * z_scale, coord1[1] * xy_scale, coord1[2] * xy_scale])
+                p2 = np.array([coord2[0] * z_scale, coord2[1] * xy_scale, coord2[2] * xy_scale])
+            elif len(shape) == 2:
+                p1 = np.array([coord1[0] * xy_scale, coord1[1] * xy_scale])
+                p2 = np.array([coord2[0] * xy_scale, coord2[1] * xy_scale])
             
-            density = len(compare_set) / volume
-            k = num_neighbors
+            # Calculate neighbor distance
+            neighbor_distance = np.linalg.norm(p2 - p1)
             
+            # Apply the dimensional factor
             if is_2d:
-                # Expected distance to k-th nearest neighbor in 2D
-                # μ1' = Γ(k + 1/2) / (Γ(k) × √(m × π))
-                expected_distance = math.gamma(k + 0.5) / (math.gamma(k) * math.sqrt(density * math.pi))
+                neighbor_distance = neighbor_distance * 0.38
             else:
-                # Expected distance to k-th nearest neighbor in 3D
-                # μ1' = Γ(k + 1/3) / (Γ(k) × (m × Φ)^(1/3))
-                # where Φ = π^(3/2) / Γ(3/2 + 1) = π^(3/2) / Γ(5/2) = 4π/3
-                phi_3d = 4 * math.pi / 3  # Volume of unit sphere in 3D
-                expected_distance = math.gamma(k + 1/3) / (math.gamma(k) * (density * phi_3d)**(1/3))
+                neighbor_distance = neighbor_distance * 0.45
             
-            return expected_distance
+            return neighbor_distance
+            
+        do_borders = not centroids
 
-        root_set = []
+        if centroids:
+            root_set = []
 
-        compare_set = []
+            compare_set = []
 
-        if root is None:
+            if root is None:
 
-            root_set = list(self.node_centroids.keys())
-            compare_set = root_set
-            title = "Nearest Neighbors Between Nodes Heatmap"
+                root_set = list(self.node_centroids.keys())
+                compare_set = root_set
+                title = "Nearest Neighbors Between Nodes Heatmap"
 
-        else:
+            else:
+
+                title = f"Nearest Neighbors of ID {targ} from ID {root} Heatmap"
 
-            title = f"Nearest Neighbors of ID {targ} from ID {root} Heatmap"
+                for node, iden in self.node_identities.items():
 
-            for node, iden in self.node_identities.items():
+                    if iden == root:
 
-                if iden == root:
+                        root_set.append(node)
 
-                    root_set.append(node)
+                    elif (iden == targ) or (targ == 'All Others (Excluding Self)'):
 
-                elif (iden == targ) or (targ == 'All Others (Excluding Self)'):
+                        compare_set.append(node)
 
-                    compare_set.append(node)
+            if root == targ:
 
-        if root == targ:
+                compare_set = root_set
+                if len(compare_set) - 1 < num:
+
+                    num = len(compare_set) - 1
+
+                    print(f"Error: Not enough neighbor nodes for requested number of neighbors. Using max available neighbors: {num}")
+                    
 
-            compare_set = root_set
-            if len(compare_set) - 1 < num:
+            if len(compare_set) < num:
 
-                num = len(compare_set) - 1
+                num = len(compare_set)
 
                 print(f"Error: Not enough neighbor nodes for requested number of neighbors. Using max available neighbors: {num}")
-                
 
-        if len(compare_set) < num:
+            avg, output = proximity.average_nearest_neighbor_distances(self.node_centroids, root_set, compare_set, xy_scale=self.xy_scale, z_scale=self.z_scale, num = num, do_borders = do_borders)
 
-            num = len(compare_set)
+        else:
+            if heatmap:
+                root_set = []
+                compare_set = []
+                if root is None:
 
-            print(f"Error: Not enough neighbor nodes for requested number of neighbors. Using max available neighbors: {num}")
-            
-        avg, output = proximity.average_nearest_neighbor_distances(self.node_centroids, root_set, compare_set, xy_scale=self.xy_scale, z_scale=self.z_scale, num = num)
+                    root_set = list(self.node_centroids.keys())
+                    compare_set = root_set
+                else:
+                    for node, iden in self.node_identities.items():
+
+                        if iden == root:
+
+                            root_set.append(node)
+
+                        elif (iden == targ) or (targ == 'All Others (Excluding Self)'):
+
+                            compare_set.append(node)
+
+            if root is None:
+                title = "Nearest Neighbors Between Nodes Heatmap"
+                root_set_neigh = approx_boundaries(self.nodes, keep_labels = True)
+                compare_set_neigh = approx_boundaries(self.nodes, keep_labels = False)
+            else:
+                title = f"Nearest Neighbors of ID {targ} from ID {root} Heatmap"
+
+                root_set_neigh = approx_boundaries(self.nodes, [root], self.node_identities, keep_labels = True)
+
+                if targ == 'All Others (Excluding Self)':
+                    compare_set_neigh = set(self.node_identities.values())
+                    compare_set_neigh.remove(root)
+                    targ = compare_set_neigh
+                else:
+                    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)
 
         if quant:
             try:
@@ -5778,8 +6017,7 @@ class Network_3D:
             else:
                 is_2d = False
 
-            pred = get_theoretical_nearest_neighbor_distance(compare_set, num, volume, is_2d = is_2d)
-            #pred = avg
+            pred = distribute_points_uniformly(len(compare_set), bounds, self.z_scale, self.xy_scale, is_2d = is_2d)
 
             node_intensity = {}
             import math