nettracer3d 1.2.5__py3-none-any.whl → 1.3.1__py3-none-any.whl

nettracer3d/nettracer.py

@@ -90,6 +90,7 @@ def reslice_3d_array(args):
 def _get_node_edge_dict(label_array, edge_array, label, dilate_xy, dilate_z):
     """Internal method used for the secondary algorithm to find which nodes interact with which edges."""
     
+    import tifffile
     # Create a boolean mask where elements with the specified label are True
     label_array = label_array == label
     label_array = dilate_3D(label_array, dilate_xy, dilate_xy, dilate_z) #Dilate the label to see where the dilated label overlaps
@@ -104,7 +105,7 @@ def _get_node_edge_dict(label_array, edge_array, label, dilate_xy, dilate_z):
 def process_label(args):
     """Modified to use pre-computed bounding boxes instead of argwhere"""
     nodes, edges, label, dilate_xy, dilate_z, array_shape, bounding_boxes = args
-    print(f"Processing node {label}")
+    #print(f"Processing node {label}")
     
     # Get the pre-computed bounding box for this label
     slice_obj = bounding_boxes[int(label)-1]  # -1 because label numbers start at 1
@@ -122,6 +123,7 @@ def process_label(args):
 
 def create_node_dictionary(nodes, edges, num_nodes, dilate_xy, dilate_z):
     """Modified to pre-compute all bounding boxes using find_objects"""
+    print("Calculating network...")
     node_dict = {}
     array_shape = nodes.shape
     
@@ -783,6 +785,147 @@ def get_surface_areas(labeled, xy_scale=1, z_scale=1):
     result = {int(label): float(surface_areas[label]) for label in labels}
     return result
 
+def get_background_surface_areas(labeled, xy_scale=1, z_scale=1):
+    """Calculate surface area exposed to background (value 0) for each object."""
+    labels = np.unique(labeled)
+    labels = labels[labels > 0]
+    max_label = int(np.max(labeled))
+    
+    surface_areas = np.zeros(max_label + 1, dtype=np.float64)
+    
+    for axis in range(3):
+        if axis == 2:
+            face_area = xy_scale * xy_scale
+        else:
+            face_area = xy_scale * z_scale
+        
+        for direction in [-1, 1]:
+            # Pad with zeros only on the axis we're checking
+            pad_width = [(1, 1) if i == axis else (0, 0) for i in range(3)]
+            padded = np.pad(labeled, pad_width, mode='constant', constant_values=0)
+            
+            # Roll the padded array
+            shifted = np.roll(padded, direction, axis=axis)
+            
+            # Extract the center region (original size) from shifted
+            slices = [slice(1, -1) if i == axis else slice(None) for i in range(3)]
+            shifted_cropped = shifted[tuple(slices)]
+            
+            # Find faces exposed to background (neighbor is 0)
+            exposed_faces = (shifted_cropped == 0) & (labeled > 0)
+            
+            face_counts = np.bincount(labeled[exposed_faces], 
+                                     minlength=max_label + 1)
+            surface_areas += face_counts * face_area
+    
+    result = {int(label): float(surface_areas[label]) for label in labels}
+    return result
+
+
+def get_background_proportion(labeled, xy_scale=1, z_scale=1):
+    """Calculate proportion of surface area exposed to background for each object."""
+    total_areas = get_surface_areas(labeled, xy_scale, z_scale)
+    background_areas = get_background_surface_areas(labeled, xy_scale, z_scale)
+    
+    proportions = {}
+    for label in total_areas:
+        if total_areas[label] > 0:
+            proportions[label] = background_areas[label] / total_areas[label]
+        else:
+            proportions[label] = 0.0
+    
+    return proportions
+
+def get_perimeters(labeled, xy_scale=1):
+    """Calculate total perimeter for each object in a 2D array (pseudo-3D with z=1)."""
+    # Squeeze to 2D without modifying the original array reference
+    labeled_2d = np.squeeze(labeled)
+    
+    labels = np.unique(labeled_2d)
+    labels = labels[labels > 0]
+    max_label = int(np.max(labeled_2d))
+    
+    perimeters = np.zeros(max_label + 1, dtype=np.float64)
+    
+    # Only check 2 axes for 2D
+    for axis in range(2):
+        edge_length = xy_scale
+        
+        for direction in [-1, 1]:
+            # Pad with zeros only on the axis we're checking
+            pad_width = [(1, 1) if i == axis else (0, 0) for i in range(2)]
+            padded = np.pad(labeled_2d, pad_width, mode='constant', constant_values=0)
+            
+            # Roll the padded array
+            shifted = np.roll(padded, direction, axis=axis)
+            
+            # Extract the center region (original size) from shifted
+            slices = [slice(1, -1) if i == axis else slice(None) for i in range(2)]
+            shifted_cropped = shifted[tuple(slices)]
+            
+            # Find exposed edges
+            exposed_edges = (labeled_2d != shifted_cropped) & (labeled_2d > 0)
+            
+            edge_counts = np.bincount(labeled_2d[exposed_edges], 
+                                     minlength=max_label + 1)
+            perimeters += edge_counts * edge_length
+    
+    result = {int(label): float(perimeters[label]) for label in labels}
+    return result
+
+
+def get_background_perimeters(labeled, xy_scale=1):
+    """Calculate perimeter exposed to background (value 0) for each object in a 2D array."""
+    # Squeeze to 2D without modifying the original array reference
+    labeled_2d = np.squeeze(labeled)
+    
+    labels = np.unique(labeled_2d)
+    labels = labels[labels > 0]
+    max_label = int(np.max(labeled_2d))
+    
+    perimeters = np.zeros(max_label + 1, dtype=np.float64)
+    
+    # Only check 2 axes for 2D
+    for axis in range(2):
+        edge_length = xy_scale
+        
+        for direction in [-1, 1]:
+            # Pad with zeros only on the axis we're checking
+            pad_width = [(1, 1) if i == axis else (0, 0) for i in range(2)]
+            padded = np.pad(labeled_2d, pad_width, mode='constant', constant_values=0)
+            
+            # Roll the padded array
+            shifted = np.roll(padded, direction, axis=axis)
+            
+            # Extract the center region (original size) from shifted
+            slices = [slice(1, -1) if i == axis else slice(None) for i in range(2)]
+            shifted_cropped = shifted[tuple(slices)]
+            
+            # Find edges exposed to background (neighbor is 0)
+            exposed_edges = (shifted_cropped == 0) & (labeled_2d > 0)
+            
+            edge_counts = np.bincount(labeled_2d[exposed_edges], 
+                                     minlength=max_label + 1)
+            perimeters += edge_counts * edge_length
+    
+    result = {int(label): float(perimeters[label]) for label in labels}
+    return result
+
+
+def get_background_perimeter_proportion(labeled, xy_scale=1):
+    """Calculate proportion of perimeter exposed to background for each object in a 2D array."""
+    total_perimeters = get_perimeters(labeled, xy_scale)
+    background_perimeters = get_background_perimeters(labeled, xy_scale)
+    
+    proportions = {}
+    for label in total_perimeters:
+        if total_perimeters[label] > 0:
+            proportions[label] = background_perimeters[label] / total_perimeters[label]
+        else:
+            proportions[label] = 0.0
+    
+    return proportions
+
 def break_and_label_skeleton(skeleton, peaks = 1, branch_removal = 0, comp_dil = 0, max_vol = 0, directory = None, return_skele = False, nodes = None, compute = True, unify = False, xy_scale = 1, z_scale = 1):
     """Internal method to break open a skeleton at its branchpoints and label the remaining components, for an 8bit binary array"""
 
@@ -1520,7 +1663,7 @@ def dilate_2D(array, search, scaling = 1):
     return inv
 
 
-def dilate_3D_dt(array, search_distance, xy_scaling=1.0, z_scaling=1.0):
+def dilate_3D_dt(array, search_distance, xy_scaling=1.0, z_scaling=1.0, fast_dil = False):
     """
     Dilate a 3D array using distance transform method. Dt dilation produces perfect results but only works in euclidean geometry and lags in big arrays.
     
@@ -1568,7 +1711,7 @@ def dilate_3D_dt(array, search_distance, xy_scaling=1.0, z_scaling=1.0):
     """
 
     # Compute distance transform (Euclidean)
-    inv = smart_dilate.compute_distance_transform_distance(inv, sampling = [z_scaling, xy_scaling, xy_scaling])
+    inv = smart_dilate.compute_distance_transform_distance(inv, sampling = [z_scaling, xy_scaling, xy_scaling], fast_dil = fast_dil)
 
     #inv = inv * cardinal
     
@@ -1615,7 +1758,7 @@ def erode_2D(array, search, scaling=1, preserve_labels = False):
     
     return array
 
-def erode_3D_dt(array, search_distance, xy_scaling=1.0, z_scaling=1.0, preserve_labels = False):
+def erode_3D_dt(array, search_distance, xy_scaling=1.0, z_scaling=1.0, fast_dil = False, preserve_labels = False):
     """
     Erode a 3D array using distance transform method. DT erosion produces perfect results 
     with Euclidean geometry, but may be slower for large arrays.
@@ -1643,34 +1786,30 @@ def erode_3D_dt(array, search_distance, xy_scaling=1.0, z_scaling=1.0, preserve_
 
         borders = find_boundaries(array, mode='thick')
         mask = array * invert_array(borders)
-        mask = smart_dilate.compute_distance_transform_distance(mask, sampling = [z_scaling, xy_scaling, xy_scaling])
+        mask = smart_dilate.compute_distance_transform_distance(mask, sampling = [z_scaling, xy_scaling, xy_scaling], fast_dil = fast_dil)
         mask = mask >= search_distance
         array = mask * array
     else:
-        array = smart_dilate.compute_distance_transform_distance(array, sampling = [z_scaling, xy_scaling, xy_scaling])
+        array = smart_dilate.compute_distance_transform_distance(array, sampling = [z_scaling, xy_scaling, xy_scaling], fast_dil = fast_dil)
         # 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.
+    """Internal method to dilate an array in 3D. Dilation this way is much faster than using a distance transform although the latter is more accurate.
     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))
-
     if dilated_x == 3 and dilated_y == 3  and dilated_z == 3:
 
         return dilate_3D_old(tiff_array, dilated_x, dilated_y, dilated_z)
 
+    if tiff_array.shape[0] == 1:
+        return dilate_2D(tiff_array, ((dilated_x - 1) / 2))
+
     def create_circular_kernel(diameter):
         """Create a 2D circular kernel with a given radius.
 
@@ -1802,11 +1941,6 @@ def dilate_3D_old(tiff_array, dilated_x=3, dilated_y=3, dilated_z=3):
     Dilated 3D array
     """
     
-    # Handle special case for 2D arrays
-    if tiff_array.shape[0] == 1:
-        # Call 2D dilation function if needed
-        return dilate_2D(tiff_array, 1)  # For a 3x3 kernel, radius is 1
-    
     # Create a simple 3x3x3 cubic kernel (all ones)
     kernel = np.ones((3, 3, 3), dtype=bool)
     
@@ -1816,107 +1950,6 @@ def dilate_3D_old(tiff_array, dilated_x=3, dilated_y=3, dilated_z=3):
     return dilated_array.astype(np.uint8)
 
 
-def erode_3D(tiff_array, eroded_x, eroded_y, eroded_z):
-    """Internal method to erode an array in 3D. Erosion this way is 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:
-        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 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))
@@ -2321,12 +2354,13 @@ def dilate(arrayimage, amount, xy_scale = 1, z_scale = 1, directory = None, fast
 def erode(arrayimage, amount, xy_scale = 1, z_scale = 1, mode = 0, preserve_labels = False):
     if not preserve_labels and len(np.unique(arrayimage)) > 2: #binarize
         arrayimage = binarize(arrayimage)
-    erode_xy, erode_z = dilation_length_to_pixels(xy_scale, z_scale, amount, amount)
 
-    if mode == 2:
-        arrayimage = (erode_3D(arrayimage, erode_xy, erode_xy, erode_z)) * 255
+    if mode == 0 or mode == 2:
+        fast_dil = True
     else:
-        arrayimage = erode_3D_dt(arrayimage, amount, xy_scaling=xy_scale, z_scaling=z_scale, preserve_labels = preserve_labels)
+        fast_dil = False
+
+    arrayimage = erode_3D_dt(arrayimage, amount, xy_scaling=xy_scale, z_scaling=z_scale, fast_dil = fast_dil, preserve_labels = preserve_labels)
 
     if np.max(arrayimage) == 1:
         arrayimage = arrayimage * 255
@@ -2378,7 +2412,7 @@ def skeletonize(arrayimage, directory = None):
 
     return arrayimage
 
-def label_branches(array, peaks = 0, branch_removal = 0, comp_dil = 0, max_vol = 0, down_factor = None, directory = None, nodes = None, bonus_array = None, GPU = True, arrayshape = None, compute = False, unify = False, union_val = 10, xy_scale = 1, z_scale = 1):
+def label_branches(array, peaks = 0, branch_removal = 0, comp_dil = 0, max_vol = 0, down_factor = None, directory = None, nodes = None, bonus_array = None, GPU = True, arrayshape = None, compute = False, unify = False, union_val = 10, mode = 0, xy_scale = 1, z_scale = 1):
     """
     Can be used to label branches a binary image. Labelled output will be saved to the active directory if none is specified. Note this works better on already thin filaments and may over-divide larger trunkish objects.
     :param array: (Mandatory, string or ndarray) - If string, a path to a tif file to label. Note that the ndarray alternative is for internal use mainly and will not save its output.
@@ -2419,24 +2453,25 @@ def label_branches(array, peaks = 0, branch_removal = 0, comp_dil = 0, max_vol =
         from . import branch_stitcher
         verts = dilate_3D_old(verts, 3, 3, 3,)
         verts, _ = label_objects(verts)
-        array = branch_stitcher.trace(bonus_array, array, verts, score_thresh = union_val)
+        print("Merging branches...")
+        array = branch_stitcher.trace(bonus_array, array, verts, score_thresh = union_val, xy_scale = xy_scale, z_scale = z_scale)
         verts = None
 
 
     if nodes is None:
 
-        array = smart_dilate.smart_label(array, other_array, GPU = GPU, remove_template = True)
+        array = smart_dilate.smart_label(array, other_array, GPU = GPU, remove_template = True, mode = mode)
         #distance = smart_dilate.compute_distance_transform_distance(array)
         #array = water(-distance, other_array, mask=array) #Tried out skimage watershed as shown and found it did not label branches as well as smart_label (esp combined combined with post-processing label splitting if needed)
 
     else:
         if down_factor is not None:
-            array = smart_dilate.smart_label(bonus_array, array, GPU = GPU, predownsample = down_factor, remove_template = True)
+            array = smart_dilate.smart_label(bonus_array, array, GPU = GPU, predownsample = down_factor, remove_template = True, mode = mode)
             #distance = smart_dilate.compute_distance_transform_distance(bonus_array)
             #array = water(-distance, array, mask=bonus_array)
         else:
 
-            array = smart_dilate.smart_label(bonus_array, array, GPU = GPU, remove_template = True)
+            array = smart_dilate.smart_label(bonus_array, array, GPU = GPU, remove_template = True, mode = mode)
             #distance = smart_dilate.compute_distance_transform_distance(bonus_array)
             #array = water(-distance, array, mask=bonus_array)
 
@@ -2498,7 +2533,7 @@ def fix_branches_network(array, G, communities, fix_val = None):
 
     return targs
 
-def fix_branches(array, G, max_val):
+def fix_branches(array, G, max_val, consider_prop = True):
     """
     Parameters:
     array: numpy array containing the labeled regions
@@ -2522,8 +2557,29 @@ def fix_branches(array, G, max_val):
     
     # Find all neighbors of not_safe nodes in one pass
     neighbors_of_not_safe = set()
-    for node in not_safe_initial:
-        neighbors_of_not_safe.update(adj[node])
+    if consider_prop:
+        if array.shape[0] != 1:
+            areas = get_background_proportion(array, xy_scale=1, z_scale=1)
+        else:
+            areas = get_background_perimeter_proportion(array, xy_scale=1)
+        valid_areas = {label: proportion for label, proportion in areas.items() if proportion < 0.4}
+        
+        for node in not_safe_initial:
+            # Filter neighbors based on whether they're in the valid areas dict
+            valid_neighbors = [neighbor for neighbor in adj[node] if neighbor in valid_areas]
+            
+            # If no valid neighbors, fall back to the one with lowest proportion
+            if not valid_neighbors:
+                node_neighbors = list(adj[node])
+                if node_neighbors:
+                    # Find neighbor with minimum background proportion
+                    min_neighbor = min(node_neighbors, key=lambda n: areas.get(n, float('inf')))
+                    valid_neighbors = [min_neighbor]
+            
+            neighbors_of_not_safe.update(valid_neighbors)
+    else:
+        for node in not_safe_initial:
+            neighbors_of_not_safe.update(adj[node])
     
     # Remove max_val if present
     neighbors_of_not_safe.discard(max_val)
@@ -2534,7 +2590,7 @@ def fix_branches(array, G, max_val):
     # Update sets
     not_safe = not_safe_initial | nodes_to_move
     
-    # The rest of the function - FIX STARTS HERE
+    # The rest of the function
     targs = np.array(list(not_safe))
     
     if len(targs) == 0:
@@ -2547,18 +2603,12 @@ def fix_branches(array, G, max_val):
     # Get the current maximum label in the array to avoid collisions
     current_max = np.max(array)
     
-    # Assign new unique labels to each connected component
-    for component_id in range(1, num_components + 1):
-        component_mask = labeled == component_id
-        array[component_mask] = current_max + component_id
+    # Vectorized relabeling - single operation instead of loop
+    array[mask] = labeled[mask] + current_max
     
     return array
 
 
-
-
-
-
 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.
@@ -2593,7 +2643,7 @@ def label_vertices(array, peaks = 0, branch_removal = 0, comp_dil = 0, max_vol =
         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)
+        array = remove_branches_new(array, branch_removal)
 
     array = np.pad(array, pad_width=1, mode='constant', constant_values=0)
 
@@ -2628,19 +2678,18 @@ 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, fast_dil = fastdil)
+            image_copy = dilate_3D_dt(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, fast_dil = fastdil)
+            image_copy = dilate_3D_dt(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, fast_dil = fastdil)
+            image_copy = dilate_3D_dt(image_copy, comp_dil, fast_dil = fastdil)
         labeled_image, num_labels = label_objects(image_copy)
 
     #if down_factor > 0:
@@ -2775,7 +2824,7 @@ def gray_watershed(image, min_distance = 1, threshold_abs = None):
     return image
 
 
-def watershed(image, directory = None, proportion = 0.1, GPU = True, smallest_rad = None, predownsample = None, predownsample2 = None):
+def watershed(image, directory = None, proportion = 0.1, GPU = True, smallest_rad = None, fast_dil = False, predownsample = None, predownsample2 = None):
     """
     Can be used to 3D watershed a binary image. Watershedding attempts to use an algorithm to split touching objects into seperate labelled components. Labelled output will be saved to the active directory if none is specified.
     This watershed algo essentially uses the distance transform to decide where peaks are and then after thresholding out the non-peaks, uses the peaks as labelling kernels for a smart label. It runs semi slow without GPU accel since it requires two dts to be computed.
@@ -2838,7 +2887,7 @@ def watershed(image, directory = None, proportion = 0.1, GPU = True, smallest_ra
         if GPU:
             print("GPU dt failed or did not detect GPU (cupy must be installed with a CUDA toolkit setup...). Computing CPU distance transform instead.")
             print(f"Error message: {str(e)}")
-        distance = smart_dilate.compute_distance_transform_distance(image)
+        distance = smart_dilate.compute_distance_transform_distance(image, fast_dil = fast_dil)
 
 
     distance = threshold(distance, proportion, custom_rad = smallest_rad)
@@ -4189,10 +4238,7 @@ class Network_3D:
         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 fast_dil:
-                search_region = dilate_3D(search_region, dilate_xy, dilate_xy, dilate_z)
-            else:
-                search_region = dilate_3D_dt(search_region, diledge, self._xy_scale, self._z_scale)
+            search_region = dilate_3D_dt(search_region, diledge, self._xy_scale, self._z_scale, fast_dil = fast_dil)
         else:
             search_region = binarize(self._search_region)
 
@@ -4210,10 +4256,8 @@ class Network_3D:
 
             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_dt(outer_edges, diledge, self._xy_scale, self._z_scale)
+                outer_edges = dilate_3D_dt(outer_edges, diledge, self._xy_scale, self._z_scale, fast_dil = fast_dil)
         else:
             outer_edges = dilate_3D_old(outer_edges)
 
@@ -4247,21 +4291,37 @@ class Network_3D:
         self._nodes, num_nodes = label_objects(nodes, structure_3d)
 
     def combine_nodes(self, root_nodes, other_nodes, other_ID, identity_dict, root_ID = None, centroids = False, down_factor = None):
-
         """Internal method to merge two labelled node arrays into one"""
-
         print("Combining node arrays")
-
+        
+        # Calculate the maximum value that will exist in the output
+        max_root = np.max(root_nodes)
+        max_other = np.max(other_nodes)
+        max_output = max_root + max_other  # Worst case: all other_nodes shifted by max_root
+        
+        # Determine the minimum dtype needed
+        if max_output <= 255:
+            target_dtype = np.uint8
+        elif max_output <= 65535:
+            target_dtype = np.uint16
+        else:
+            target_dtype = np.uint32
+                
+        # Convert arrays to appropriate dtype
+        root_nodes = root_nodes.astype(target_dtype)
+        other_nodes = other_nodes.astype(target_dtype)
+        
+        # Now perform the merge
         mask = (root_nodes == 0) & (other_nodes > 0)
         if np.any(mask):
-            max_val = np.max(root_nodes)
-            other_nodes[:] = np.where(mask, other_nodes + max_val, 0)
-        if centroids:
-            new_dict = network_analysis._find_centroids(other_nodes, down_factor = down_factor)
-            if down_factor is not None:
-                for item in new_dict:
-                    new_dict[item] = down_factor * new_dict[item]
-            self.node_centroids.update(new_dict)
+            other_nodes_shifted = np.where(other_nodes > 0, other_nodes + max_root, 0)
+            if centroids:
+                new_dict = network_analysis._find_centroids(other_nodes_shifted, down_factor = down_factor)
+                if down_factor is not None:
+                    for item in new_dict:
+                        new_dict[item] = down_factor * new_dict[item]
+                self.node_centroids.update(new_dict)
+            other_nodes = np.where(mask, other_nodes_shifted, 0)
 
         if root_ID is not None:
             rootIDs = list(np.unique(root_nodes)) #Sets up adding these vals to the identitiy dictionary. Gets skipped if this has already been done.
@@ -4300,7 +4360,7 @@ class Network_3D:
 
         return nodes, identity_dict
 
-    def merge_nodes(self, addn_nodes_name, label_nodes = True, root_id = "Root_Nodes", centroids = False, down_factor = None):
+    def merge_nodes(self, addn_nodes_name, label_nodes = True, root_id = "Root_Nodes", centroids = False, down_factor = None, is_array = False):
         """
         Merges the self._nodes attribute with alternate labelled node images. The alternate nodes can be inputted as a string for a filepath to a tif,
         or as a directory address containing only tif images, which will merge the _nodes attribute with all tifs in the folder. The _node_identities attribute
@@ -4327,7 +4387,11 @@ class Network_3D:
                     self.node_centroids[item] = down_factor * self.node_centroids[item]
 
         try: #Try presumes the input is a tif
-            addn_nodes = tifffile.imread(addn_nodes_name) #If not this will fail and activate the except block
+            if not is_array:
+                addn_nodes = tifffile.imread(addn_nodes_name) #If not this will fail and activate the except block
+            else:
+                addn_nodes = addn_nodes_name # Passing it an array directly
+                addn_nodes_name = "Node"
 
             if label_nodes is True:
                 addn_nodes, num_nodes2 = label_objects(addn_nodes) # Label the node objects. Note this presumes no overlap between node masks.
@@ -4339,7 +4403,6 @@ class Network_3D:
                 num_nodes = int(np.max(node_labels))
 
         except: #Exception presumes the input is a directory containing multiple tifs, to allow multi-node stackage.
-
             addn_nodes_list = directory_info(addn_nodes_name)
 
             for i, addn_nodes in enumerate(addn_nodes_list):
@@ -4539,9 +4602,6 @@ class Network_3D:
         self._nodes = nodes
         del nodes
 
-        if self._nodes.shape[0] == 1:
-            fast_dil = True #Set this to true because the 2D algo always uses the distance transform and doesnt need this special ver
-
         if label_nodes:
             self._nodes, num_nodes = label_objects(self._nodes)
         if other_nodes is not None:
@@ -4937,7 +4997,17 @@ class Network_3D:
         nodeb = []
         edgec = []
 
-        trunk = stats.mode(edgesc)
+        from collections import Counter
+        counts = Counter(edgesc)
+        if 0 not in edgesc:
+            trunk = stats.mode(edgesc)
+        else:
+            try:
+                sorted_edges = counts.most_common()
+                trunk = sorted_edges[1][0]
+            except:
+                return
+
         addtrunk = max(set(nodesa + nodesb)) + 1
 
         for i in range(len(nodesa)):
@@ -4955,7 +5025,10 @@ class Network_3D:
 
         self.network_lists = [nodea, nodeb, edgec]
 
-        self._node_centroids[addtrunk] = self._edge_centroids[trunk]
+        try:
+            self._node_centroids[addtrunk] = self._edge_centroids[trunk]
+        except:
+            pass
 
         if self._node_identities is None:
             self._node_identities = {}
@@ -4984,14 +5057,14 @@ class Network_3D:
 
 
 
-    def prune_samenode_connections(self):
+    def prune_samenode_connections(self, target = None):
         """
         If working with a network that has multiple node identities (from merging nodes or otherwise manipulating this property),
         this method will remove from the network and network_lists properties any connections that exist between the same node identity,
         in case we want to investigate only connections between differing objects.
         """
 
-        self._network_lists, self._node_identities = network_analysis.prune_samenode_connections(self._network_lists, self._node_identities)
+        self._network_lists, self._node_identities = network_analysis.prune_samenode_connections(self._network_lists, self._node_identities, target = target)
         self._network, num_weights = network_analysis.weighted_network(self._network_lists)
 
 
@@ -5193,7 +5266,7 @@ class Network_3D:
 
     #Methods related to visualizing the network using networkX and matplotlib
 
-    def show_network(self, geometric = False, directory = None):
+    def show_network(self, geometric = False, directory = None, show_labels = True):
         """
         Shows the network property as a simplistic graph, and some basic stats. Does not support viewing edge weights.
         :param geoemtric: (Optional - Val = False; boolean). If False, node placement in the graph will be random. If True, nodes
@@ -5204,19 +5277,19 @@ class Network_3D:
 
         if not geometric:
 
-            simple_network.show_simple_network(self._network_lists, directory = directory)
+            simple_network.show_simple_network(self._network_lists, directory = directory, show_labels = show_labels)
 
         else:
-            simple_network.show_simple_network(self._network_lists, geometric = True, geo_info = [self._node_centroids, self._nodes.shape], directory = directory)
+            simple_network.show_simple_network(self._network_lists, geometric = True, geo_info = [self._node_centroids, self._nodes.shape], directory = directory, show_labels = show_labels)
 
-    def show_communities_flex(self, geometric = False, directory = None, weighted = True, partition = False, style = 0):
+    def show_communities_flex(self, geometric = False, directory = None, weighted = True, partition = False, style = 0, show_labels = True):
 
 
-        self._communities, self.normalized_weights = modularity.show_communities_flex(self._network, self._network_lists, self.normalized_weights, geo_info = [self._node_centroids, self._nodes.shape], geometric = geometric, directory = directory, weighted = weighted, partition = partition, style = style)
+        self._communities, self.normalized_weights = modularity.show_communities_flex(self._network, self._network_lists, self.normalized_weights, geo_info = [self._node_centroids, self._nodes.shape], geometric = geometric, directory = directory, weighted = weighted, partition = partition, style = style, show_labels = show_labels)
 
 
 
-    def show_identity_network(self, geometric = False, directory = None):
+    def show_identity_network(self, geometric = False, directory = None, show_labels = True):
         """
         Shows the network property, and some basic stats, as a graph where nodes are labelled by colors representing the identity of the node as detailed in the node_identities property. Does not support viewing edge weights.
         :param geoemtric: (Optional - Val = False; boolean). If False, node placement in the graph will be random. If True, nodes
@@ -5225,9 +5298,9 @@ class Network_3D:
         :param directory: (Optional – Val = None; string). An optional string path to a directory to save the network plot image to. If not set, nothing will be saved.
         """
         if not geometric:
-            simple_network.show_identity_network(self._network_lists, self._node_identities, geometric = False, directory = directory)
+            simple_network.show_identity_network(self._network_lists, self._node_identities, geometric = False, directory = directory, show_labels = show_labels)
         else:
-            simple_network.show_identity_network(self._network_lists, self._node_identities, geometric = True, geo_info = [self._node_centroids, self._nodes.shape], directory = directory)
+            simple_network.show_identity_network(self._network_lists, self._node_identities, geometric = True, geo_info = [self._node_centroids, self._nodes.shape], directory = directory, show_labels = show_labels)
 
 
 
@@ -5710,7 +5783,7 @@ class Network_3D:
                 print(f"Using {volume} for the volume measurement (Volume of provided mask as scaled by xy and z scaling)")
                 
                 # Compute distance transform on padded array
-                legal = smart_dilate.compute_distance_transform_distance(legal, sampling = [self.z_scale, self.xy_scale, self.xy_scale])
+                legal = smart_dilate.compute_distance_transform_distance(legal, sampling = [self.z_scale, self.xy_scale, self.xy_scale], fast_dil = True)
                 
                 # Remove padding after distance transform
                 if dim == 2:
@@ -5804,7 +5877,6 @@ class Network_3D:
 
 
     def morph_proximity(self, search = 0, targets = None, fastdil = False):
-
         if type(search) == list:
             search_x, search_z = search #Suppose we just want to directly pass these params
         else:
@@ -5813,7 +5885,6 @@ class Network_3D:
         num_nodes = int(np.max(self._nodes))
 
         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)
 
         my_dict = create_and_save_dataframe(my_dict)