nettracer3d 0.2.6__py3-none-any.whl → 0.2.8__py3-none-any.whl

nettracer3d/nettracer.py

@@ -362,51 +362,108 @@ def establish_inner_edges(nodes, edge):
     return inner_edges
 
 
-def upsample_with_padding(data, factor, original_shape): #Not the most nuanced upsampler but essentially just used to undo downsamples... I generally never have use for any other sort of upsample so this one is the one I am using
-    """Internal method used for upsampling"""
-    # Upsample the input binary array while adding padding to match an arbitrary shape
+def upsample_with_padding(data, factor=None, original_shape=None):
+    """
+    Upsample a 3D or 4D array with optional different scaling factors per dimension.
+    
+    Parameters:
+    -----------
+    data : ndarray
+        Input 3D array or 4D array (where 4th dimension is RGB) to be upsampled
+    factor : float or tuple, optional
+        Upsampling factor. If float, same factor is applied to all dimensions.
+        If tuple, should contain three values for z, y, x dimensions respectively.
+        If None, factor is calculated from original_shape.
+    original_shape : tuple, optional
+        Target shape for the output array. Used to calculate factors if factor is None.
+        
+    Returns:
+    --------
+    ndarray
+        Upsampled and padded array matching the original shape
+    """
+    if original_shape is None:
+        raise ValueError("original_shape must be provided")
+        
+    # Handle 4D color arrays
+    is_color = len(data.shape) == 4 and data.shape[-1] == 3
+    if is_color:
+        # Split into separate color channels
+        channels = [data[..., i] for i in range(3)]
+        upsampled_channels = []
+        
+        for channel in channels:
+            # Upsample each channel separately
+            upsampled_channel = _upsample_3d_array(channel, factor, original_shape)
+            upsampled_channels.append(upsampled_channel)
+            
+        # Stack the channels back together
+        return np.stack(upsampled_channels, axis=-1)
+    else:
+        # Handle regular 3D array
+        return _upsample_3d_array(data, factor, original_shape)
 
-    # Get the dimensions of the original and upsampled arrays
+def _upsample_3d_array(data, factor, original_shape):
+    """Helper function to handle the upsampling of a single 3D array"""
     original_shape = np.array(original_shape)
+    current_shape = np.array(data.shape)
+    
+    # Calculate factors if not provided
+    if factor is None:
+        # Compute the ratio between original and current shape for each dimension
+        factors = [os / cs for os, cs in zip(original_shape, current_shape)]
+        # If all factors are the same, use a single number for efficiency
+        if len(set(factors)) == 1:
+            factor = factors[0]
+        else:
+            factor = tuple(factors)
+    elif isinstance(factor, (int, float)):
+        factor = factor  # Keep it as a single number
+        
+    # Upsample the input array
     binary_array = zoom(data, factor, order=0)
     upsampled_shape = np.array(binary_array.shape)
-
+    
     # Calculate the positive differences in dimensions
     difference_dims = original_shape - upsampled_shape
-
+    
     # Calculate the padding amounts for each dimension
     padding_dims = np.maximum(difference_dims, 0)
     padding_before = padding_dims // 2
     padding_after = padding_dims - padding_before
-
+    
     # Pad the binary array along each dimension
-    padded_array = np.pad(binary_array, [(padding_before[0], padding_after[0]),
-                                         (padding_before[1], padding_after[1]),
-                                         (padding_before[2], padding_after[2])], mode='constant', constant_values=0)
-
+    padded_array = np.pad(binary_array, 
+                         [(padding_before[0], padding_after[0]),
+                          (padding_before[1], padding_after[1]),
+                          (padding_before[2], padding_after[2])],
+                         mode='constant',
+                         constant_values=0)
+    
     # Calculate the subtraction amounts for each dimension
     sub_dims = np.maximum(-difference_dims, 0)
     sub_before = sub_dims // 2
     sub_after = sub_dims - sub_before
-
+    
+    # Remove excess dimensions sequentially
     # Remove planes from the beginning and end
     if sub_dims[0] == 0:
         trimmed_planes = padded_array
     else:
         trimmed_planes = padded_array[sub_before[0]:-sub_after[0], :, :]
-
+    
     # Remove rows from the beginning and end
     if sub_dims[1] == 0:
         trimmed_rows = trimmed_planes
     else:
         trimmed_rows = trimmed_planes[:, sub_before[1]:-sub_after[1], :]
-
+    
     # Remove columns from the beginning and end
     if sub_dims[2] == 0:
         trimmed_array = trimmed_rows
     else:
         trimmed_array = trimmed_rows[:, :, sub_before[2]:-sub_after[2]]
-
+    
     return trimmed_array
 
 def remove_branches(skeleton, length):
@@ -556,6 +613,104 @@ def threshold(arr, proportion, custom_rad = None):
 
     return arr
 
+def z_project(array3d, method='max'):
+    """
+    Project a 3D numpy array along the Z axis to create a 2D array.
+    
+    Parameters:
+        array3d (numpy.ndarray): 3D input array with shape (Z, Y, X)
+        method (str): Projection method - 'max', 'mean', 'min', 'sum', or 'std'
+    
+    Returns:
+        numpy.ndarray: 2D projected array with shape (Y, X)
+    """
+    if not isinstance(array3d, np.ndarray) or array3d.ndim != 3:
+        raise ValueError("Input must be a 3D numpy array")
+        
+    if method == 'max':
+        return np.max(array3d, axis=0)
+    elif method == 'mean':
+        return np.mean(array3d, axis=0)
+    elif method == 'min':
+        return np.min(array3d, axis=0)
+    elif method == 'sum':
+        return np.sum(array3d, axis=0)
+    elif method == 'std':
+        return np.std(array3d, axis=0)
+    else:
+        raise ValueError("Method must be one of: 'max', 'mean', 'min', 'sum', 'std'")
+
+def fill_holes_3d(array):
+
+    def process_slice(slice_2d, border_threshold=0.08):
+        """
+        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
+        """
+        slice_2d = slice_2d.astype(np.uint8)
+        labels, num_features = ndimage.label(slice_2d)
+        
+        if num_features == 0:
+            return np.zeros_like(slice_2d)
+        
+        # Get dimensions for threshold calculations
+        height, width = slice_2d.shape
+        
+        # Dictionary to store border intersection lengths for each label
+        border_proportions = {}
+        
+        for label in range(1, num_features + 1):
+            mask = labels == label
+            
+            # Calculate proportion of each border this component touches
+            top_prop = np.sum(mask[0, :]) / width
+            bottom_prop = np.sum(mask[-1, :]) / width
+            left_prop = np.sum(mask[:, 0]) / height
+            right_prop = np.sum(mask[:, -1]) / height
+            
+            # If it touches any border significantly, consider it background
+            border_proportions[label] = max(top_prop, bottom_prop, left_prop, right_prop)
+        
+        # Create mask of components that either don't touch borders
+        # or touch less than the threshold proportion
+        background_labels = {label for label, prop in border_proportions.items() 
+                            if prop > border_threshold}
+        
+        holes_mask = ~np.isin(labels, list(background_labels))
+        
+        return holes_mask
+
+    array = binarize(array)
+    inv_array = invert_array(array)
+    
+    # Create arrays for all three planes
+    array_xy = np.zeros_like(inv_array, dtype=np.uint8)
+    array_xz = np.zeros_like(inv_array, dtype=np.uint8)
+    array_yz = np.zeros_like(inv_array, dtype=np.uint8)
+    
+    # Process XY plane
+    for z in range(inv_array.shape[0]):
+        array_xy[z] = process_slice(inv_array[z])
+        
+    # Process XZ plane    
+    for y in range(inv_array.shape[1]):
+        slice_xz = inv_array[:, y, :]
+        array_xz[:, y, :] = process_slice(slice_xz)
+        
+    # Process YZ plane
+    for x in range(inv_array.shape[2]):
+        slice_yz = inv_array[:, :, x]
+        array_yz[:, :, x] = process_slice(slice_yz)
+    
+    # Combine results from all three planes
+    filled = (array_xy | array_xz | array_yz) * 255
+    return array + filled
+
+
 
 
 
@@ -813,6 +968,205 @@ def dilate_3D(tiff_array, dilated_x, dilated_y, dilated_z):
 
     return final_result
 
+def dilate_3D_recursive(tiff_array, dilated_x, dilated_y, dilated_z, step_size=None):
+    """Recursive 3D dilation method that handles odd-numbered dilations properly.
+    
+    Args:
+        tiff_array: Input 3D array
+        dilated_x, dilated_y, dilated_z: Odd numbers representing total dilation size
+        step_size: Size of dilation step for this iteration
+    
+    Each dilation parameter represents (n-1)/2 steps outward from the object.
+    """
+    # Calculate the smallest dimension of the array
+    min_dim = min(tiff_array.shape)
+    
+    # For small dilations relative to array size, don't use recursion
+    max_dilation = max(dilated_x, dilated_y, dilated_z)
+    if max_dilation < (0.2 * min_dim):
+        return dilate_3D_recursive(tiff_array, dilated_x, dilated_y, dilated_z, step_size=1)
+    
+    # Initialize step_size for first call
+    if step_size is None:
+        # Start with a reasonable step size based on the largest dilation
+        step_size = min(5, max((max_dilation - 1) // 2 // 3, 1))
+    
+    # Base case: if step_size is 1 or we've achieved full dilation
+    if step_size == 1 or (dilated_x <= 1 and dilated_y <= 1 and dilated_z <= 1):
+        def create_circular_kernel(diameter):
+            radius = diameter/2
+            size = radius
+            size = int(np.ceil(size))
+            y, x = np.ogrid[-radius:radius+1, -radius:radius+1]
+            distance = np.sqrt(x**2 + y**2)
+            kernel = distance <= radius
+            return kernel.astype(np.uint8)
+
+        def create_ellipsoidal_kernel(long_axis, short_axis):
+            semi_major, semi_minor = long_axis / 2, short_axis / 2
+            size_y = int(np.ceil(semi_minor))
+            size_x = int(np.ceil(semi_major))
+            y, x = np.ogrid[-semi_minor:semi_minor+1, -semi_major:semi_major+1]
+            ellipse = (x**2 / semi_major**2) + (y**2 / semi_minor**2) <= 1
+            return ellipse.astype(np.uint8)
+
+        def process_slice(z):
+            tiff_slice = tiff_array[z].astype(np.uint8)
+            dilated_slice = cv2.dilate(tiff_slice, kernel, iterations=1)
+            return z, dilated_slice
+
+        def process_slice_other(y):
+            tiff_slice = tiff_array[:, y, :].astype(np.uint8)
+            dilated_slice = cv2.dilate(tiff_slice, kernel, iterations=1)
+            return y, dilated_slice
+
+        # Create empty arrays for the dilated results
+        dilated_xy = np.zeros_like(tiff_array, dtype=np.uint8)
+        dilated_xz = np.zeros_like(tiff_array, dtype=np.uint8)
+
+        # Create kernels for final dilation
+        kernel = create_circular_kernel(dilated_x)
+        
+        # Process XY plane
+        num_cores = mp.cpu_count()
+        with ThreadPoolExecutor(max_workers=num_cores) as executor:
+            futures = {executor.submit(process_slice, z): z for z in range(tiff_array.shape[0])}
+            for future in as_completed(futures):
+                z, dilated_slice = future.result()
+                dilated_xy[z] = dilated_slice
+
+        # Process XZ plane
+        kernel = create_ellipsoidal_kernel(dilated_x, dilated_z)
+        with ThreadPoolExecutor(max_workers=num_cores) as executor:
+            futures = {executor.submit(process_slice_other, y): y for y in range(tiff_array.shape[1])}
+            for future in as_completed(futures):
+                y, dilated_slice = future.result()
+                dilated_xz[:, y, :] = dilated_slice
+
+        return dilated_xy | dilated_xz
+
+    # Calculate current iteration's dilation sizes (must be odd numbers)
+    current_x_steps = min((dilated_x - 1) // 2, step_size)
+    current_y_steps = min((dilated_y - 1) // 2, step_size)
+    current_z_steps = min((dilated_z - 1) // 2, step_size)
+    
+    current_x_dilation = current_x_steps * 2 + 1
+    current_y_dilation = current_y_steps * 2 + 1
+    current_z_dilation = current_z_steps * 2 + 1
+    
+    # Perform current iteration's dilation
+    current_result = dilate_3D_recursive(tiff_array, current_x_dilation, current_y_dilation, current_z_dilation, step_size=1)
+    
+    # Calculate remaining dilation needed
+    # For X and Y, use the circle radius (current_x_steps)
+    # For Z, use the ellipse short axis (current_z_steps)
+    remaining_x = max(1, dilated_x - (current_x_steps * 2))
+    remaining_y = max(1, dilated_y - (current_y_steps * 2))
+    remaining_z = max(1, dilated_z - (current_z_steps * 2))
+    
+    # If no more dilation needed, return current result
+    if remaining_x == 1 and remaining_y == 1 and remaining_z == 1:
+        return current_result
+    
+    # Recursive call with remaining dilation and decreased step size
+    return dilate_3D_recursive(current_result, remaining_x, remaining_y, remaining_z, step_size=max(1, step_size - 1))
+
+def erode_3D(tiff_array, eroded_x, eroded_y, eroded_z):
+    """Internal method to erode an array in 3D. Erosion this way is much faster than using a distance transform although the latter is theoretically more accurate.
+    Arguments are an array, and the desired pixel erosion amounts in X, Y, Z."""
+    def create_circular_kernel(diameter):
+        """Create a 2D circular kernel with a given radius.
+        Parameters:
+        radius (int or float): The radius of the circle.
+        Returns:
+        numpy.ndarray: A 2D numpy array representing the circular kernel.
+        """
+        # Determine the size of the kernel
+        radius = diameter/2
+        size = radius  # Diameter of the circle
+        size = int(np.ceil(size))  # Ensure size is an integer
+        
+        # Create a grid of (x, y) coordinates
+        y, x = np.ogrid[-radius:radius+1, -radius:radius+1]
+        
+        # Calculate the distance from the center (0,0)
+        distance = np.sqrt(x**2 + y**2)
+        
+        # Create the circular kernel: points within the radius are 1, others are 0
+        kernel = distance <= radius
+        
+        # Convert the boolean array to integer (0 and 1)
+        return kernel.astype(np.uint8)
+
+    def create_ellipsoidal_kernel(long_axis, short_axis):
+        """Create a 2D ellipsoidal kernel with specified axis lengths and orientation.
+        Parameters:
+        long_axis (int or float): The length of the long axis.
+        short_axis (int or float): The length of the short axis.
+        Returns:
+        numpy.ndarray: A 2D numpy array representing the ellipsoidal kernel.
+        """
+        semi_major, semi_minor = long_axis / 2, short_axis / 2
+        # Determine the size of the kernel
+        size_y = int(np.ceil(semi_minor))
+        size_x = int(np.ceil(semi_major))
+        
+        # Create a grid of (x, y) coordinates centered at (0,0)
+        y, x = np.ogrid[-semi_minor:semi_minor+1, -semi_major:semi_major+1]
+        
+        # Ellipsoid equation: (x/a)^2 + (y/b)^2 <= 1
+        ellipse = (x**2 / semi_major**2) + (y**2 / semi_minor**2) <= 1
+        
+        return ellipse.astype(np.uint8)
+
+    z_depth = tiff_array.shape[0]
+
+    # Function to process each slice
+    def process_slice(z):
+        tiff_slice = tiff_array[z].astype(np.uint8)
+        eroded_slice = cv2.erode(tiff_slice, kernel, iterations=1)
+        return z, eroded_slice
+
+    def process_slice_other(y):
+        tiff_slice = tiff_array[:, y, :].astype(np.uint8)
+        eroded_slice = cv2.erode(tiff_slice, kernel, iterations=1)
+        return y, eroded_slice
+
+    # Create empty arrays to store the eroded results for the XY and XZ planes
+    eroded_xy = np.zeros_like(tiff_array, dtype=np.uint8)
+    eroded_xz = np.zeros_like(tiff_array, dtype=np.uint8)
+
+    kernel_x = int(eroded_x)
+    kernel = create_circular_kernel(kernel_x)
+
+    num_cores = mp.cpu_count()
+    with ThreadPoolExecutor(max_workers=num_cores) as executor:
+        futures = {executor.submit(process_slice, z): z for z in range(tiff_array.shape[0])}
+        for future in as_completed(futures):
+            z, eroded_slice = future.result()
+            eroded_xy[z] = eroded_slice
+
+    kernel_x = int(eroded_x)
+    kernel_z = int(eroded_z)
+    kernel = create_ellipsoidal_kernel(kernel_x, kernel_z)
+
+    if z_depth != 2:
+
+        with ThreadPoolExecutor(max_workers=num_cores) as executor:
+            futures = {executor.submit(process_slice_other, y): y for y in range(tiff_array.shape[1])}
+            
+            for future in as_completed(futures):
+                y, eroded_slice = future.result()
+                eroded_xz[:, y, :] = eroded_slice
+
+    # Overlay the results using AND operation instead of OR for erosion
+    if z_depth != 2:
+        final_result = eroded_xy & eroded_xz
+    else:
+        return eroded_xy
+    
+    return final_result
+
 
 def dilate_3D_old(tiff_array, dilated_x, dilated_y, dilated_z):
     """(For cubey dilation only). Internal method to dilate an array in 3D.
@@ -947,6 +1301,10 @@ def combine_nodes(root_nodes, other_nodes, other_ID, identity_dict, root_ID = No
             identity_dict[item] = root_ID
 
     for item in otherIDs: #Always adds the other vals to the dictionary
+        try:
+            other_ID = os.path.basename(other_ID)
+        except:
+            pass
         identity_dict[item] = other_ID
 
     nodes = root_nodes + other_nodes #Combine the outer edges with the inner edges modified via the above steps
@@ -1025,7 +1383,7 @@ def binarize(arrayimage, directory = None):
 
     return arrayimage
 
-def dilate(arrayimage, amount, xy_scale = 1, z_scale = 1, directory = None, fast_dil = False):
+def dilate(arrayimage, amount, xy_scale = 1, z_scale = 1, directory = None, fast_dil = False, recursive = False):
     """
     Can be used to dilate a binary image in 3D. Dilated output will be saved to the active directory if none is specified. Note that dilation is done with single-instance kernels and not iterations, and therefore
     objects will lose their shape somewhat and become cube-ish if the 'amount' param is ever significantly larger than the objects in quesiton.
@@ -1050,13 +1408,15 @@ def dilate(arrayimage, amount, xy_scale = 1, z_scale = 1, directory = None, fast
     if len(np.unique(arrayimage)) > 2: #binarize
         arrayimage = binarize(arrayimage)
 
-    if not fast_dil:
+    if not fast_dil and not recursive:
         arrayimage = (dilate_3D(arrayimage, dilate_xy, dilate_xy, dilate_z)) * 255
         if np.max(arrayimage) == 1:
             arrayimage = arrayimage * 255
-
-    else:
+    elif not recursive:
         arrayimage = (dilate_3D_old(arrayimage, dilate_xy, dilate_xy, dilate_z)) * 255
+    else:
+        arrayimage = (dilate_3D_recursive(arrayimage, dilate_xy, dilate_xy, dilate_z)) * 255
+
 
 
     if type(image) == str:
@@ -1070,6 +1430,23 @@ def dilate(arrayimage, amount, xy_scale = 1, z_scale = 1, directory = None, fast
 
     return arrayimage
 
+def erode(arrayimage, amount, xy_scale = 1, z_scale = 1):
+    if len(np.unique(arrayimage)) > 2: #binarize
+        arrayimage = binarize(arrayimage)
+    erode_xy, erode_z = dilation_length_to_pixels(xy_scale, z_scale, amount, amount)
+
+    if len(np.unique(arrayimage)) > 2: #binarize
+        arrayimage = binarize(arrayimage)
+
+    arrayimage = (erode_3D(arrayimage, erode_xy, erode_xy, erode_z)) * 255
+    if np.max(arrayimage) == 1:
+        arrayimage = arrayimage * 255
+
+    return arrayimage
+
+
+
+
 
 def skeletonize(arrayimage, directory = None):
     """
@@ -1560,6 +1937,9 @@ def encapsulate(parent_dir = None, name = None):
     
     return new_folder_path
 
+
+
+
 #THE 3D NETWORK CLASS
 
 class Network_3D:
@@ -1617,7 +1997,8 @@ class Network_3D:
         if array is not None and not isinstance(array, np.ndarray):
             raise ValueError("nodes must be a (preferably labelled) numpy array.")
         if array is not None and len(array.shape) == 2: #For dealing with 2D images
-            array = np.stack((array, array), axis = 0)
+            #array = np.stack((array, array), axis = 0)
+            array = np.expand_dims(array, axis=0)
         self._nodes = array
 
     @nodes.deleter
@@ -1735,7 +2116,8 @@ class Network_3D:
         if array is not None and not isinstance(array, np.ndarray):
             raise ValueError("edges must be a (preferably labelled) numpy array.")
         if array is not None and len(array.shape) == 2: #For dealing with 2D images
-            array = np.stack((array, array), axis = 0)
+            #array = np.stack((array, array), axis = 0)
+            array = np.expand_dims(array, axis=0)
         self._edges = array
 
     @edges.deleter
@@ -1756,6 +2138,9 @@ class Network_3D:
         """Sets the search_region property"""
         if array is not None and not isinstance(array, np.ndarray):
             raise ValueError("search_region must be a (preferably labelled) numpy array.")
+        if array is not None and len(array.shape) == 2: #For dealing with 2D images
+            #array = np.stack((array, array), axis = 0)
+            array = np.expand_dims(array, axis=0)
         self._search_region = array
 
     @search_region.deleter
@@ -1836,6 +2221,9 @@ class Network_3D:
         """Sets the nodes property"""
         if array is not None and not isinstance(array, np.ndarray):
             raise ValueError("network overlay must be a (preferably labelled) numpy array.")
+        if array is not None and len(array.shape) == 2: #For dealing with 2D images
+            #array = np.stack((array, array), axis = 0)
+            array = np.expand_dims(array, axis=0)
  
         self._network_overlay = array
 
@@ -1852,6 +2240,9 @@ class Network_3D:
         """Sets the nodes property"""
         if array is not None and not isinstance(array, np.ndarray):
             raise ValueError("id overlay must be a (preferably labelled) numpy array.")
+        if array is not None and len(array.shape) == 2: #For dealing with 2D images
+            #array = np.stack((array, array), axis = 0)
+            array = np.expand_dims(array, axis=0)
  
         self._id_overlay = array
 
@@ -2868,12 +3259,14 @@ class Network_3D:
 
     #Some methods that may be useful:
 
-    def community_partition(self, weighted = False, style = 0):
+    def community_partition(self, weighted = False, style = 0, dostats = True):
         """
         Sets the communities attribute by splitting the network into communities
         """
 
-        self._communities, self.normalized_weights = modularity.community_partition(self._network_lists, weighted = weighted, style = style)
+        self._communities, self.normalized_weights, stats = modularity.community_partition(self._network_lists, weighted = weighted, style = style, dostats = dostats)
+
+        return stats
 
     def remove_edge_weights(self):
         """
@@ -2966,6 +3359,19 @@ class Network_3D:
         elif num_edge < 65536:
             self._edges = self._edges.astype(np.uint16)
 
+        node_bools = self._nodes == 0
+
+        self._nodes = self._nodes.astype(np.uint32)
+        self._edges = self._edges * node_bools
+        self._nodes = self._nodes + self._edges
+        num_node = np.max(self._nodes)
+
+        if num_node < 256:
+            self._nodes = self._nodes.astype(np.uint8)
+        elif num_node < 65536:
+            self._nodes = self._nodes.astype(np.uint16)
+
+
     def trunk_to_node(self):
         """
         Converts the edge 'trunk' into a node. In this case, the trunk is the edge that creates the most node-node connections. There may be times when many nodes are connected by a single, expansive edge that obfuscates the rest of the edges. Converting the trunk to a node can better reveal these edges.
@@ -2989,16 +3395,14 @@ class Network_3D:
                 nodeb.append(addtrunk)
                 nodea.append(nodesb[i])
                 nodeb.append(addtrunk)
-                edgec.append(None)
-                edgec.append(None)
+                edgec.append(0)
+                edgec.append(0)
             else:
                 nodea.append(nodesa[i])
                 nodeb.append(nodesb[i])
                 edgec.append(edgesc[i])
 
-        self._network_lists = [nodea, nodeb, edgec]
-
-        self.network, _ = network_analysis.weighted_network(self._network_lists)
+        self.network_lists = [nodea, nodeb, edgec]
 
         self._node_centroids[addtrunk] = self._edge_centroids[trunk]
 
@@ -3013,6 +3417,19 @@ class Network_3D:
         else:
             self._node_identities[addtrunk] = "Trunk"
 
+        if self._edges is not None and self._nodes is not None:
+
+            node_bools = self._nodes == 0
+
+            trunk = self._edges == trunk
+
+            trunk = trunk * addtrunk
+
+            trunk = trunk * node_bools
+
+            self._nodes = self._nodes + trunk
+
+
 
 
 
@@ -3480,28 +3897,55 @@ class Network_3D:
                 mothers, overlay = community_extractor.extract_mothers(self._nodes, self._network, centroid_dic = self._node_centroids, directory = directory, louvain = louvain, called = called)
             return mothers, overlay
 
-    def extract_communities(self, directory = None, down_factor = 1, color_code = True):
-        """
-        Method to generate overlays that relate community detection in a network to the 3D structure.
-        Overlays include a grayscale image where nodes are assigned a grayscale value corresponding to their community, a numerical index where numbers are drawn at nodes corresponding to their community, and a
-        color coded overlay where a nodes color corresponds to its community. Community detection will be done with label propogation.
-        These will be saved to the active directory if none is specified.
-        :param directory: (Optional - Val = None; string). A path to a directory to save outputs.
-        :param down_factor: (Optional - Val = 1; int). A factor to downsample nodes by while drawing overlays. Note this option REQUIRES node_centroids to already be set.
-        :param color code: (Optional - Val = True; boolean). If set to False, the color-coded overlay will not be drawn.
-        :returns: A dictionary where nodes are grouped by community.
-        """
-        if down_factor > 1:
-            centroids = self._node_centroids.copy()
-            for item in self._node_centroids:
-                centroids[item] = np.round((self._node_centroids[item]) / down_factor)
-            nodes = downsample(self._nodes, down_factor)
-            partition = network_analysis.community_partition_simple(nodes, self._network, directory = directory, centroids = centroids, color_code = color_code)
 
+    def isolate_hubs(self, proportion = 0.1, retimg = True):
+
+        hubs = community_extractor.find_hub_nodes(self._network, proportion)
+
+        if retimg:
+
+            hub_img = np.isin(self._nodes, hubs) * self._nodes
         else:
-            partition = network_analysis.community_partition_simple(self._nodes, self._network, directory = directory, centroids = self._node_centroids, color_code = color_code)
+            hub_iimg = None
+
+        return hubs, hub_img
+
+
+    def extract_communities(self, color_code = True, down_factor = None, identities = False):
+
+        if down_factor is not None:
+            original_shape = self._nodes.shape
+            temp = downsample(self._nodes, down_factor)
+            if color_code:
+                if not identities:
+                    image, output = community_extractor.assign_community_colors(self.communities, temp)
+                else:
+                    image, output = community_extractor.assign_community_colors(self.node_identities, temp)
+            else:
+                if not identities:
+                    image, output = community_extractor.assign_community_grays(self.communities, temp)
+                else:
+                    image, output = community_extractor.assign_community_grays(self.node_identities, temp)
+            image = upsample_with_padding(image, down_factor, original_shape)
+        else:
+
+            if color_code:
+                if not identities:
+                    image, output = community_extractor.assign_community_colors(self.communities, self._nodes)
+                else:
+                    image, output = community_extractor.assign_community_colors(self.node_identities, self._nodes)
+            else:
+                if not identities:
+                    image, output = community_extractor.assign_community_grays(self.communities, self._nodes)
+                else:
+                    image, output = community_extractor.assign_community_grays(self.node_identities, self._nodes)
+
+
+        return image, output
+        
+
+
 
-        return partition
 
     def extract_communities_louvain(self, directory = None, down_factor = 1, color_code = True):
         """
@@ -3561,9 +4005,9 @@ class Network_3D:
         :returns: an equivalent random networkx graph object
         """
 
-        G = network_analysis.generate_random(self._network, self._network_lists, weighted = weighted)
+        G, df = network_analysis.generate_random(self._network, self._network_lists, weighted = weighted)
 
-        return G
+        return G, df
 
     def degree_distribution(self, directory = None):
         """
@@ -3645,12 +4089,79 @@ class Network_3D:
         except:
             stats['degree_assortativity'] = "Failed to compute"
 
+        try:
+            nodes = np.unique(self._nodes)
+            if nodes[0] == 0:
+                nodes = np.delete(nodes, 0)
+            stats['Unconnected nodes (left out from node image)'] = (len(nodes) - len(G.nodes()))
+        except:
+            stats['Unconnected nodes (left out from node image)'] = "Failed to compute"
+
         
         return stats
 
 
+    def neighborhood_identities(self, root, directory = None, mode = 0, search = 0):
+
+
+
+        targets = []
+        total_dict = {}
+        neighborhood_dict = {}
+        proportion_dict = {}
+        G = self._network
+        node_identities = self._node_identities
+        for val in set(node_identities.values()):
+            total_dict[val] = 0
+            neighborhood_dict[val] = 0
+
+        for node in node_identities:
+            nodeid = node_identities[node]
+            total_dict[nodeid] += 1
+            if nodeid == root:
+                targets.append(node)
+
+
+        if mode == 0: #search neighbor ids within the network
+
+
+            for node in G.nodes():
+                nodeid = node_identities[node]
+                neighbors = list(G.neighbors(node))
+                for subnode in neighbors:
+                    subnodeid = node_identities[subnode]
+                    if subnodeid == root:
+                        neighborhood_dict[nodeid] += 1
+                        break
+
+            title1 = f'Neighborhood Distribution of Nodes in Network from Nodes: {root}'
+            title2 = f'Neighborhood Distribution of Nodes in Network from Nodes {root} as a proportion of total nodes of that ID'
+
+
+        elif mode == 1: #Search neighborhoods morphologically, obtain densities
+            neighborhood_dict, total_dict, densities = morphology.search_neighbor_ids(self._nodes, targets, node_identities, neighborhood_dict, total_dict, search, self._xy_scale, self._z_scale, root)
+            title1 = f'Volumetric Neighborhood Distribution of Nodes in image that are {search} from nodes: {root}'
+            title2 = f'Density Distribution of Nodes in image that are {search} from Nodes {root} as a proportion of total node volume of that ID'
+
+
+        for identity in neighborhood_dict:
+            proportion_dict[identity] = neighborhood_dict[identity]/total_dict[identity]
 
-#Morphological stats:
+        network_analysis.create_bar_graph(neighborhood_dict, title1, "Node Identity", "Amount", directory=directory)
+
+        network_analysis.create_bar_graph(proportion_dict, title2, "Node Identity", "Proportion", directory=directory)
+
+        try:
+            network_analysis.create_bar_graph(densities, f'Clustering Factor of Node Identities with {search} from nodes {root}', "Node Identity", "Density Search/Density Total", directory=directory)
+        except:
+            densities = None
+
+
+        return neighborhood_dict, proportion_dict, title1, title2, densities
+
+
+
+#Morphological stats or network linking:
 
     def volumes(self, sort = 'nodes'):
 
@@ -3664,6 +4175,16 @@ class Network_3D:
 
             return morphology.calculate_voxel_volumes(self._edges, self._xy_scale, self._z_scale)
 
+        elif sort == 'network_overlay':
+
+            return morphology.calculate_voxel_volumes(self._network_overlay, self._xy_scale, self._z_scale)
+
+        elif sort == 'id_overlay':
+
+            return morphology.calculate_voxel_volumes(self._id_overlay, self._xy_scale, self._z_scale)
+
+
+
 
     def interactions(self, search = 0, cores = 0, resize = None, save = False, skele = False):
 
@@ -3671,13 +4192,13 @@ class Network_3D:
 
 
 
-    def morph_proximity(self, search = 0):
+    def morph_proximity(self, search = 0, targets = None):
 
         search_x, search_z = dilation_length_to_pixels(self._xy_scale, self._z_scale, search, search)
 
         num_nodes = np.max(self._nodes)
 
-        my_dict = proximity.create_node_dictionary(self._nodes, num_nodes, search_x, search_z)
+        my_dict = proximity.create_node_dictionary(self._nodes, num_nodes, search_x, search_z, targets = targets)
 
         my_dict = proximity.find_shared_value_pairs(my_dict)