nettracer3d 0.6.5__py3-none-any.whl → 0.6.7__py3-none-any.whl

nettracer3d/nettracer.py

@@ -547,7 +547,7 @@ def remove_branches(skeleton, length):
     return image_copy
 
 
-def estimate_object_radii(labeled_array, gpu=False, n_jobs=None):
+def estimate_object_radii(labeled_array, gpu=False, n_jobs=None, xy_scale = 1, z_scale = 1):
     """
     Estimate the radii of labeled objects in a 3D numpy array.
     Dispatches to appropriate implementation based on parameters.
@@ -579,9 +579,9 @@ def estimate_object_radii(labeled_array, gpu=False, n_jobs=None):
         gpu = False
     
     if gpu:
-        return morphology.estimate_object_radii_gpu(labeled_array)
+        return morphology.estimate_object_radii_gpu(labeled_array, xy_scale = xy_scale, z_scale = z_scale)
     else:
-        return morphology.estimate_object_radii_cpu(labeled_array, n_jobs)
+        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):
@@ -744,9 +744,9 @@ def z_project(array3d, method='max'):
     else:
         raise ValueError("Method must be one of: 'max', 'mean', 'min', 'sum', 'std'")
 
-def fill_holes_3d(array):
+def fill_holes_3d(array, head_on = False, fill_borders = True):
 
-    def process_slice(slice_2d, border_threshold=0.08):
+    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.
@@ -757,6 +757,9 @@ def fill_holes_3d(array):
         """
         slice_2d = slice_2d.astype(np.uint8)
         labels, num_features = ndimage.label(slice_2d)
+
+        if not fill_borders:
+            border_threshold = 0 #Testing
         
         if num_features == 0:
             return np.zeros_like(slice_2d)
@@ -781,8 +784,10 @@ def fill_holes_3d(array):
         
         # 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))
         
@@ -802,19 +807,19 @@ def fill_holes_3d(array):
 
     # Process XY plane
     for z in range(inv_array.shape[0]):
-        array_xy[z] = process_slice(inv_array[z])
+        array_xy[z] = process_slice(inv_array[z], fill_borders = fill_borders)
 
-    if array.shape[0] > 3: #only use these dimensions for sufficiently large zstacks
+    if (array.shape[0] > 3) and not head_on: #only use these dimensions for sufficiently large zstacks
         
         # Process XZ plane    
         for y in range(inv_array.shape[1]):
             slice_xz = inv_array[:, y, :]
-            array_xz[:, y, :] = process_slice(slice_xz)
+            array_xz[:, y, :] = process_slice(slice_xz, fill_borders = fill_borders)
             
         # Process YZ plane
         for x in range(inv_array.shape[2]):
             slice_yz = inv_array[:, :, x]
-            array_yz[:, :, x] = process_slice(slice_yz)
+            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
@@ -857,23 +862,48 @@ def _rescale(array, original_shape, xy_scale, z_scale):
     return array
 
 
-def remove_trunk(edges):
+def remove_trunk(edges, num_iterations=1):
     """
-    Internal method used to remove the edge trunk. Essentially removes the largest object from
-    a binary array.
+    Removes the largest connected objects from a 3D binary array in-place.
+    
+    Parameters:
+    -----------
+    edges : ndarray
+        3D binary array containing objects to process.
+        Will be modified in-place.
+    num_iterations : int, optional
+        Number of largest objects to remove, default is 1.
+        
+    Returns:
+    --------
+    ndarray
+        Reference to the modified input array.
     """
-     # Label connected components in the binary array
-    labeled_array = measure.label(edges)
-
-    # Get unique labels and their counts
-    unique_labels, label_counts = np.unique(labeled_array, return_counts=True)
-
-    # Find the label corresponding to the largest object
-    largest_label = unique_labels[np.argmax(label_counts[1:]) + 1]
-
-    # Set indices of the largest object to 0
-    edges[labeled_array == largest_label] = 0
-
+    # Label connected components
+    labeled_array, num_features = measure.label(edges, background=0, return_num=True)
+    
+    # If there are fewer objects than requested iterations, adjust
+    iterations = min(num_iterations, num_features)
+    
+    if iterations == 0 or num_features == 0:
+        return edges
+    
+    # Count occurrences of each label
+    label_counts = np.bincount(labeled_array.ravel())
+    
+    # Skip background (label 0)
+    label_counts = label_counts[1:]
+    
+    # Find indices of largest objects (argsort returns ascending order, so we reverse it)
+    largest_indices = np.argsort(label_counts)[::-1][:iterations]
+    
+    # Convert back to actual labels (add 1 because we skipped background)
+    largest_labels = largest_indices + 1
+    
+    # Modify the input array in-place
+    for label in largest_labels:
+        edges[labeled_array == label] = 0
+    
     return edges
 
 def hash_inners(search_region, inner_edges, GPU = True):
@@ -907,10 +937,155 @@ def dilate_2D(array, search, scaling = 1):
 
     return inv
 
+def erode_2D(array, search, scaling=1):
+    """
+    Erode a 2D array using distance transform method.
+    
+    Parameters:
+    array -- Input 2D binary array
+    search -- Distance within which to erode
+    scaling -- Scaling factor (default: 1)
+    
+    Returns:
+    Eroded 2D array
+    """
+    # For erosion, we work directly with the foreground
+    # No need to invert the array
+    
+    # Compute distance transform on the foreground
+    dt = smart_dilate.compute_distance_transform_distance(array)
+    
+    # Apply scaling
+    dt = dt * scaling
+    
+    # Threshold to keep only points that are at least 'search' distance from the boundary
+    eroded = dt >= search
+    
+    return eroded
+
+def dilate_3D_dt(array, search_distance, xy_scaling=1.0, z_scaling=1.0):
+    """
+    Dilate a 3D array using distance transform method. Dt dilation produces perfect results but only works in euclidean geometry and lags in big arrays.
+    
+    Parameters:
+    array -- Input 3D binary array
+    search_distance -- Distance within which to dilate
+    xy_scaling -- Scaling factor for x and y dimensions (default: 1.0)
+    z_scaling -- Scaling factor for z dimension (default: 1.0)
+    
+    Returns:
+    Dilated 3D array
+    """
+
+    if array.shape[0] == 1:
+
+        return dilate_2D(array, search_distance, scaling = xy_scaling) #Use the 2d method in psueod-3d cases
+
+
+    # Invert the array (find background)
+    inv = array < 1
+
+    del array
+
+    # Determine which dimension needs resampling
+    if (z_scaling > xy_scaling):
+        # Z dimension needs to be stretched
+        zoom_factor = [z_scaling/xy_scaling, 1, 1]  # Scale factor for [z, y, x]
+        rev_factor = [xy_scaling/z_scaling, 1, 1] 
+        cardinal = xy_scaling
+    elif (xy_scaling > z_scaling):
+        # XY dimensions need to be stretched
+        zoom_factor = [1, xy_scaling/z_scaling, xy_scaling/z_scaling]  # Scale factor for [z, y, x]
+        rev_factor = [1, z_scaling/xy_scaling, z_scaling/xy_scaling]  # Scale factor for [z, y, x]
+        cardinal = z_scaling
+    else:
+        # Already uniform scaling, no need to resample
+        zoom_factor = None
+        rev_factor = None
+        cardinal = xy_scaling
+
+    # Resample the mask if needed
+    if zoom_factor:
+        inv = ndimage.zoom(inv, zoom_factor, order=0)  # Use order=0 for binary masks
+    
+    # Compute distance transform (Euclidean)
+    inv = smart_dilate.compute_distance_transform_distance(inv)
+
+    inv = inv * cardinal
+    
+    # Threshold the distance transform to get dilated result
+    inv = inv <= search_distance
+
+    if rev_factor:
+        inv = ndimage.zoom(inv, rev_factor, order=0)  # Use order=0 for binary masks
+    
+    return inv.astype(np.uint8)
+
+def erode_3D_dt(array, search_distance, xy_scaling=1.0, z_scaling=1.0):
+    """
+    Erode a 3D array using distance transform method. DT erosion produces perfect results 
+    with Euclidean geometry, but may be slower for large arrays.
+    
+    Parameters:
+    array -- Input 3D binary array
+    search_distance -- Distance within which to erode
+    xy_scaling -- Scaling factor for x and y dimensions (default: 1.0)
+    z_scaling -- Scaling factor for z dimension (default: 1.0)
+    GPU -- Whether to use GPU acceleration if available (default: False)
+    
+    Returns:
+    Eroded 3D array
+    """
+    
+    if array.shape[0] == 1:
+        # Handle 2D case
+        return erode_2D(array, search_distance, scaling=xy_scaling)
+    
+    # For erosion, we work directly with the foreground (no inversion needed)
+    
+    # Determine which dimension needs resampling
+    if (z_scaling > xy_scaling):
+        # Z dimension needs to be stretched
+        zoom_factor = [z_scaling/xy_scaling, 1, 1]  # Scale factor for [z, y, x]
+        rev_factor = [xy_scaling/z_scaling, 1, 1] 
+        cardinal = xy_scaling
+    elif (xy_scaling > z_scaling):
+        # XY dimensions need to be stretched
+        zoom_factor = [1, xy_scaling/z_scaling, xy_scaling/z_scaling]  # Scale factor for [z, y, x]
+        rev_factor = [1, z_scaling/xy_scaling, z_scaling/xy_scaling]  # Scale factor for [z, y, x]
+        cardinal = z_scaling
+    else:
+        # Already uniform scaling, no need to resample
+        zoom_factor = None
+        rev_factor = None
+        cardinal = xy_scaling
+    
+    # Resample the mask if needed
+    if zoom_factor:
+        array = ndimage.zoom(array, zoom_factor, order=0)  # Use order=0 for binary masks
+    
+    print("Computing a distance transform for a perfect erosion...")
+
+    array = smart_dilate.compute_distance_transform_distance(array)
+    
+    # Apply scaling factor
+    array = array * cardinal
+    
+    # Threshold the distance transform to get eroded result
+    # For erosion, we keep only the points that are at least search_distance from the boundary
+    array = array >= search_distance
+    
+    # Resample back to original dimensions if needed
+    if rev_factor:
+        array = ndimage.zoom(array, rev_factor, order=0)  # Use order=0 for binary masks
+    
+    return array.astype(np.uint8)
+
 
 def dilate_3D(tiff_array, dilated_x, dilated_y, dilated_z):
     """Internal method to dilate an array in 3D. Dilation 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 dilation amounts in X, Y, Z."""
+    Arguments are an array,  and the desired pixel dilation amounts in X, Y, Z. Uses psuedo-3D kernels (imagine a 3D + sign rather than a cube) to approximate 3D neighborhoods but will miss diagonally located things with larger kernels, if those are needed use the distance transform version.
+    """
 
     if tiff_array.shape[0] == 1:
         return dilate_2D(tiff_array, ((dilated_x - 1) / 2))
@@ -1036,118 +1211,41 @@ 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.
+def dilate_3D_old(tiff_array, dilated_x=3, dilated_y=3, dilated_z=3):
+    """
+    Dilate a 3D array using scipy.ndimage.binary_dilation with a 3x3x3 cubic kernel.
     
-    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
+    Arguments:
+    tiff_array -- Input 3D binary array
+    dilated_x -- Fixed at 3 for X dimension
+    dilated_y -- Fixed at 3 for Y dimension
+    dilated_z -- Fixed at 3 for Z dimension
     
-    Each dilation parameter represents (n-1)/2 steps outward from the object.
+    Returns:
+    Dilated 3D array
     """
+    
+    # Handle special case for 2D arrays
     if tiff_array.shape[0] == 1:
-        return dilate_2D(tiff_array, ((dilated_x - 1) / 2))
-    # Calculate the smallest dimension of the array
-    min_dim = min(tiff_array.shape)
+        # Call 2D dilation function if needed
+        return dilate_2D(tiff_array, 1)  # For a 3x3 kernel, radius is 1
     
-    # 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(tiff_array, dilated_x, dilated_y, dilated_z)
-    elif dilated_x == 1 and dilated_y == 1 and dilated_z == 1: #Also if there is only a single dilation don't do it
-        return dilate_3D(tiff_array, dilated_x, dilated_y, dilated_z)
+    # Create a simple 3x3x3 cubic kernel (all ones)
+    kernel = np.ones((3, 3, 3), dtype=bool)
     
-    # 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))
+    # Perform binary dilation
+    dilated_array = ndimage.binary_dilation(tiff_array.astype(bool), structure=kernel)
     
-    # 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
+    return dilated_array.astype(np.uint8)
 
-        # 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."""
+
+    if tiff_array.shape[0] == 1:
+        return erode_2D(tiff_array, ((eroded_x - 1) / 2))
+
     def create_circular_kernel(diameter):
         """Create a 2D circular kernel with a given radius.
         Parameters:
@@ -1242,43 +1340,6 @@ def erode_3D(tiff_array, eroded_x, eroded_y, eroded_z):
     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.
-    Arguments are an array,  and the desired pixel dilation amounts in X, Y, Z."""
-
-    # Create empty arrays to store the dilated results for the XY and XZ planes
-    dilated_xy = np.zeros_like(tiff_array, dtype=np.uint8)
-    dilated_xz = np.zeros_like(tiff_array, dtype=np.uint8)
-
-    # Perform 2D dilation in the XY plane
-    for z in range(tiff_array.shape[0]):
-        kernel_x = int(dilated_x)
-        kernel_y = int(dilated_y)
-        kernel = np.ones((kernel_y, kernel_x), dtype=np.uint8)
-
-        # Convert the slice to the appropriate data type
-        tiff_slice = tiff_array[z].astype(np.uint8)
-
-        dilated_slice = cv2.dilate(tiff_slice, kernel, iterations=1)
-        dilated_xy[z] = dilated_slice
-
-    # Perform 2D dilation in the XZ plane
-    for y in range(tiff_array.shape[1]):
-        kernel_x = int(dilated_x)
-        kernel_z = int(dilated_z)
-        kernel = np.ones((kernel_z, kernel_x), dtype=np.uint8)
-
-        # Convert the slice to the appropriate data type
-        tiff_slice = tiff_array[:, y, :].astype(np.uint8)
-
-        dilated_slice = cv2.dilate(tiff_slice, kernel, iterations=1)
-        dilated_xz[:, y, :] = dilated_slice
-
-    # Overlay the results
-    final_result = dilated_xy | dilated_xz
-
-    return final_result
-
 def dilation_length_to_pixels(xy_scaling, z_scaling, micronx, micronz):
     """Internal method to find XY and Z dilation parameters based on voxel micron scaling"""
     dilate_xy = 2 * int(round(micronx/xy_scaling))
@@ -1478,7 +1539,7 @@ def binarize(arrayimage, directory = None):
 
     return arrayimage
 
-def dilate(arrayimage, amount, xy_scale = 1, z_scale = 1, directory = None, fast_dil = False, recursive = False):
+def dilate(arrayimage, amount, xy_scale = 1, z_scale = 1, directory = None, fast_dil = False, recursive = False, dilate_xy = None, dilate_z = None):
     """
     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.
@@ -1498,20 +1559,16 @@ def dilate(arrayimage, amount, xy_scale = 1, z_scale = 1, directory = None, fast
     else:
         image = None
 
-    dilate_xy, dilate_z = dilation_length_to_pixels(xy_scale, z_scale, amount, amount)
+    if not dilate_xy:
+        dilate_xy, dilate_z = dilation_length_to_pixels(xy_scale, z_scale, amount, amount)
 
     if len(np.unique(arrayimage)) > 2: #binarize
         arrayimage = binarize(arrayimage)
 
-    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
-    elif not recursive:
-        arrayimage = (dilate_3D_old(arrayimage, dilate_xy, dilate_xy, dilate_z)) * 255
+    if fast_dil:
+        arrayimage = (dilate_3D(arrayimage, dilate_xy, dilate_xy, dilate_z))
     else:
-        arrayimage = (dilate_3D_recursive(arrayimage, dilate_xy, dilate_xy, dilate_z)) * 255
-
+        arrayimage = (dilate_3D_dt(arrayimage, amount, xy_scale, z_scale))
 
 
     if type(image) == str:
@@ -1525,15 +1582,16 @@ 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):
+def erode(arrayimage, amount, xy_scale = 1, z_scale = 1, mode = 0):
     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)
+    if mode == 0:
+        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)
 
-    arrayimage = (erode_3D(arrayimage, erode_xy, erode_xy, erode_z)) * 255
     if np.max(arrayimage) == 1:
         arrayimage = arrayimage * 255
 
@@ -1688,7 +1746,7 @@ def fix_branches(array, G, communities, fix_val = None):
 
 
 
-def label_vertices(array, peaks = 0, branch_removal = 0, comp_dil = 0, max_vol = 0, down_factor = 0, directory = None, return_skele = False, order = 0):
+def label_vertices(array, peaks = 0, branch_removal = 0, comp_dil = 0, max_vol = 0, down_factor = 0, directory = None, return_skele = False, order = 0, fastdil = True):
     """
     Can be used to label vertices (where multiple branches connect) 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.
     Note that this can be used in tandem with an edge segmentation to create an image containing 'pseudo-nodes', meaning we can make a network out of just a single edge file.
@@ -1754,19 +1812,19 @@ def label_vertices(array, peaks = 0, branch_removal = 0, comp_dil = 0, max_vol =
     if peaks > 0:
         image_copy = filter_size_by_peaks(image_copy, peaks)
         if comp_dil > 0:
-            image_copy = dilate(image_copy, comp_dil)
+            image_copy = dilate(image_copy, comp_dil, fast_dil = fastdil)
 
         labeled_image, num_labels = label_objects(image_copy)
     elif max_vol > 0:
         image_copy = filter_size_by_vol(image_copy, max_vol)
         if comp_dil > 0:
-            image_copy = dilate(image_copy, comp_dil)
+            image_copy = dilate(image_copy, comp_dil, fast_dil = fastdil)
 
         labeled_image, num_labels = label_objects(image_copy)
     else:
 
         if comp_dil > 0:
-            image_copy = dilate(image_copy, comp_dil)
+            image_copy = dilate(image_copy, comp_dil, fast_dil = fastdil)
         labeled_image, num_labels = label_objects(image_copy)
 
     #if down_factor > 0:
@@ -3005,7 +3063,7 @@ class Network_3D:
         print(f"Assembling Network_3D object from files stored in directory: {directory}")
         self.load_nodes(directory, node_path)
         self.load_edges(directory, edge_path)
-        self.load_search_region(directory, search_region_path)
+        #self.load_search_region(directory, search_region_path)
         self.load_network(directory, network_path)
         self.load_node_centroids(directory, node_centroids_path)
         self.load_node_identities(directory, node_identities_path)
@@ -3063,7 +3121,7 @@ class Network_3D:
 
         self._edge_centroids = edge_centroids
 
-    def calculate_search_region(self, search_region_size, GPU = True, fast_dil = False, GPU_downsample = None):
+    def calculate_search_region(self, search_region_size, GPU = True, fast_dil = True, GPU_downsample = None):
 
         """
         Method to obtain the search region that will be used to assign connectivity between nodes. May be skipped if nodes do not want to search and only want to look for their 
@@ -3082,7 +3140,7 @@ class Network_3D:
 
         if search_region_size != 0:
 
-            self._search_region = smart_dilate.smart_dilate(self._nodes, dilate_xy, dilate_z, GPU = GPU, fast_dil = fast_dil, predownsample = GPU_downsample) #Call the smart dilate function which essentially is a fast way to enlarge nodes into a 'search region' while keeping their unique IDs.
+            self._search_region = smart_dilate.smart_dilate(self._nodes, dilate_xy, dilate_z, GPU = GPU, fast_dil = fast_dil, predownsample = GPU_downsample, use_dt_dil_amount = search_region_size) #Call the smart dilate function which essentially is a fast way to enlarge nodes into a 'search region' while keeping their unique IDs.
 
         else:
 
@@ -3116,14 +3174,15 @@ class Network_3D:
         if skeletonized:
             binary_edges = skeletonize(binary_edges)
 
-        if search is not None and hasattr(self, '_nodes') and self._nodes is not None:
+
+
+        if search is not None and hasattr(self, '_nodes') and self._nodes is not None and self._search_region is None:
             search_region = binarize(self._nodes)
             dilate_xy, dilate_z = dilation_length_to_pixels(self._xy_scale, self._z_scale, search, search)
-            if not fast_dil:
+            if fast_dil:
                 search_region = dilate_3D(search_region, dilate_xy, dilate_xy, dilate_z)
             else:
-                search_region = dilate_3D_old(search_region, dilate_xy, dilate_xy, dilate_z)
-
+                search_region = dilate_3D_dt(search_region, diledge, self._xy_scale, self._z_scale)
         else:
             search_region = binarize(self._search_region)
 
@@ -3133,19 +3192,20 @@ class Network_3D:
             del binary_edges
 
         if remove_edgetrunk > 0:
-            for i in range(remove_edgetrunk):
-                print(f"Snipping trunk {i + 1}...")
-                outer_edges = remove_trunk(outer_edges)
+            print(f"Snipping trunks...")
+            outer_edges = remove_trunk(outer_edges, remove_edgetrunk)
 
         if diledge is not None:
             dilate_xy, dilate_z = dilation_length_to_pixels(self._xy_scale, self._z_scale, diledge, diledge)
-            if not fast_dil and dilate_xy > 3 and dilate_z > 3:
+
+            if dilate_xy <= 3 and dilate_z <= 3:
+                outer_edges = dilate_3D_old(outer_edges, dilate_xy, dilate_xy, dilate_z)
+            elif fast_dil:
                 outer_edges = dilate_3D(outer_edges, dilate_xy, dilate_xy, dilate_z)
             else:
-                outer_edges = dilate_3D_old(outer_edges, dilate_xy, dilate_xy, dilate_z)
-
+                outer_edges = dilate_3D_dt(outer_edges, diledge, self._xy_scale, self._z_scale)
         else:
-            outer_edges = dilate_3D_old(outer_edges, 3, 3, 3)
+            outer_edges = dilate_3D_old(outer_edges)
 
         labelled_edges, num_edge = label_objects(outer_edges)
 
@@ -3277,7 +3337,7 @@ class Network_3D:
             self._network_lists = network_analysis.read_excel_to_lists(df)
             self._network, net_weights = network_analysis.weighted_network(df)
 
-    def calculate_all(self, nodes, edges, xy_scale = 1, z_scale = 1, down_factor = None, search = None, diledge = None, inners = True, hash_inners = True, remove_trunk = 0, ignore_search_region = False, other_nodes = None, label_nodes = True, directory = None, GPU = True, fast_dil = False, skeletonize = False, GPU_downsample = None):
+    def calculate_all(self, nodes, edges, xy_scale = 1, z_scale = 1, down_factor = None, search = None, diledge = None, inners = True, hash_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.
         :param nodes: (Mandatory; String or ndarray). Filepath to segmented nodes mask or a numpy array containing the same.
@@ -3299,7 +3359,7 @@ class Network_3D:
         :param label_nodes: (Optional - Val = True; boolean). If True, all discrete objects in the node param (and all those contained in the optional other_nodes param) will be assigned a label. If files a prelabelled, set this to False to avoid labelling.
         :param directory: (Optional - Val = None; string). Path to a directory to save to hard mem all Network_3D properties. If not set, these values will be saved to the active directory.
         :param GPU: (Optional - Val = True; boolean). Will use GPU if avaialble for calculating the search_region step (including necessary downsampling for GPU RAM). Set to False to use CPU with no downsample. Note this only affects the search_region step.
-        :param fast_dil: (Optional - Val = False, boolean) - A boolean that when True will utilize faster cube dilation but when false will use slower spheroid dilation.
+        :param fast_dil: (Optional - Val = False, boolean) - A boolean that when True will utilize faster psuedo3d kernel dilation but when false will use slower dt-based dilation.
         :param skeletonize: (Optional - Val = False, boolean) - A boolean of whether to skeletonize the edges when using them.
         """
 
@@ -4021,48 +4081,10 @@ class Network_3D:
         return isolated nodes, isolated edges, and isolated network in that order). IF gen_images == False (Will return just the network).
         """
 
-        if gen_images:
-
-            if not hasattr(self, '_edges') or self._edges is None:
-
-                connected_component, isonodes, _ = community_extractor.isolate_connected_component(self._nodes, self._network, key=key, directory = directory)
-
-                nodea = []
-                nodeb = []
-                edgec = []
-                nodesa = self._network_lists[0]
-                nodesb = self._network_lists[1]
-                edgesc = self._network_lists[2]
-                for i in range(len(nodesa)):
-                    if (nodesa[i], nodesb[i]) in connected_component:
-                        nodea.append(nodesa[i])
-                        nodeb.append(nodesb[i])
-                        edgec.append(edgesc[i])
-                network_lists = [nodea, nodeb, edgec]
-                network, weights = network_analysis.weighted_network(network_lists)
+        #Removed depricated gen_images functions
 
-                return isonodes, network
-
-            else:
-                if full_edges is not None:
-                    connected_component, isonodes, isoedges, searchers = community_extractor.isolate_connected_component(self._nodes, self._network, key=key, edge_file = self._edges, search_region = self.search_region, netlists = self._network_lists, directory = directory)
-
-                else:
-                    connected_component, isonodes, isoedges, searchers = community_extractor.isolate_connected_component(self._nodes, self._network, key=key, edge_file = self._edges, netlists = self._network_lists, directory = directory)
-
-                df = create_and_save_dataframe(connected_component)
-                network_lists = network_analysis.read_excel_to_lists(df)
-                network, net_weights = network_analysis.weighted_network(df)
-
-                if full_edges is not None:
-                    full_edges = tifffile.imread(full_edges)
-                    community_extractor.isolate_full_edges(searchers, full_edges, directory = directory)
-
-                return isonodes, isoedges, network
-
-        else:
-            G = community_extractor._isolate_connected(self._network, key = key)
-            return G
+        G = community_extractor._isolate_connected(self._network, key = key)
+        return G
 
 
     def isolate_mothers(self, directory = None, down_factor = 1, louvain = True, ret_nodes = False, called = False):
@@ -4320,7 +4342,7 @@ class Network_3D:
         return stats
 
 
-    def neighborhood_identities(self, root, directory = None, mode = 0, search = 0):
+    def neighborhood_identities(self, root, directory = None, mode = 0, search = 0, fastdil = False):
 
 
 
@@ -4358,7 +4380,7 @@ class Network_3D:
 
 
         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)
+            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, fastdil = fastdil)
             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'
 
@@ -4405,19 +4427,23 @@ class Network_3D:
 
 
 
-    def interactions(self, search = 0, cores = 0, resize = None, save = False, skele = False):
+    def interactions(self, search = 0, cores = 0, resize = None, save = False, skele = False, 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)
 
 
+    def morph_proximity(self, search = 0, targets = None, fastdil = False):
 
-    def morph_proximity(self, search = 0, targets = None):
+        if type(search) == list:
+            search_x, search_z = search #Suppose we just want to directly pass these params
+        else:
+            search_x, search_z = dilation_length_to_pixels(self._xy_scale, self._z_scale, search, search)
 
-        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, targets = targets)
+        my_dict = proximity.create_node_dictionary(self._nodes, num_nodes, search_x, search_z, targets = targets, fastdil = fastdil, xy_scale = self._xy_scale, z_scale = self._z_scale, search = search)
 
         my_dict = proximity.find_shared_value_pairs(my_dict)
 
@@ -4490,6 +4516,8 @@ class Network_3D:
 
         self._network_lists = network_analysis.read_excel_to_lists(network)
 
+        #self._network is a networkx graph that stores the connections
+
         self.remove_edge_weights()
 
         return array