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

nettracer3d/smart_dilate.py

@@ -2,6 +2,7 @@ import tifffile
 import numpy as np
 from scipy.ndimage import binary_dilation, distance_transform_edt
 from scipy.ndimage import gaussian_filter
+from scipy import ndimage
 from concurrent.futures import ThreadPoolExecutor, as_completed
 import cv2
 import os
@@ -145,45 +146,99 @@ def dilate_3D(tiff_array, dilated_x, dilated_y, dilated_z):
     return final_result
 
 
-def dilate_3D_old(tiff_array, dilated_x, dilated_y, dilated_z):
-    """Dilate an array in 3D. Consider replacing with scipy dilation method.
-    Arguments are an array,  and the desired pixel dilation amounts in X, Y, Z."""
+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.
+    
+    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
+    
+    Returns:
+    Dilated 3D array
+    """
+    import numpy as np
+    from scipy import ndimage
+    
+    # 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)
+    
+    # Perform binary dilation
+    dilated_array = ndimage.binary_dilation(tiff_array.astype(bool), structure=kernel)
+    
+    return dilated_array.astype(np.uint8)
 
-    # 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)
+def dilate_3D_dt(array, search_distance, xy_scaling=1.0, z_scaling=1.0, GPU = 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.
+    
+    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 nettracer.dilate_2D(array, search_distance, scaling = xy_scaling)
+
+    # 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
 
-    # 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)
 
+    # Resample the mask if needed
+    if zoom_factor:
+        array = ndimage.zoom(array, zoom_factor, order=0)  # Use order=0 for binary masks
 
-        # 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
+    # Invert the array (find background)
+    inv = array < 1
+    
+    if GPU:
+        try:
+            print("Attempting on GPU...")
+            inv, indices = compute_distance_transform_GPU(inv, return_dists = True)
+        except:
+            print("Failed, attempting on CPU...")
+            #Who would have seen this coming?:
+            inv, indices = compute_distance_transform(inv, return_dists = True)
+    else:
+        inv, indices = compute_distance_transform(inv, return_dists = True)
 
-    # 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)
 
+    inv = inv * cardinal
+    
+    # Threshold the distance transform to get dilated result
+    inv = inv <= search_distance
 
-        # 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
+    return inv.astype(np.uint8), indices, array, rev_factor
 
-    # Overlay the results (you can use logical OR operation or another method)
-    final_result = dilated_xy | dilated_xz
 
 
-    return final_result
 
 def binarize(image):
     """Convert an array from numerical values to boolean mask"""
@@ -209,71 +264,73 @@ def process_chunk(start_idx, end_idx, nodes, ring_mask, nearest_label_indices):
     
     return dilated_nodes_with_labels_chunk
 
-def smart_dilate(nodes, dilate_xy, dilate_z, directory = None, GPU = True, fast_dil = False, predownsample = None):
+def smart_dilate(nodes, dilate_xy, dilate_z, directory = None, GPU = True, fast_dil = True, predownsample = None, use_dt_dil_amount = None, xy_scale = 1, z_scale = 1):
 
     original_shape = nodes.shape
 
-    # Step 1: Binarize the labeled array
-    binary_nodes = binarize(nodes)
 
-    # Step 2: Dilate the binarized array
-    if not fast_dil:
+    #Dilate the binarized array
+    if fast_dil:
+        # Step : Binarize the labeled array
+        binary_nodes = binarize(nodes)
         dilated_binary_nodes = dilate_3D(binary_nodes, dilate_xy, dilate_xy, dilate_z)
     else:
-        dilated_binary_nodes = dilate_3D_old(binary_nodes, dilate_xy, dilate_xy, dilate_z)
-
+        dilated_binary_nodes, nearest_label_indices, nodes, rev_factor = dilate_3D_dt(nodes, use_dt_dil_amount, GPU = GPU, xy_scaling = xy_scale, z_scaling = z_scale)
+        binary_nodes = binarize(nodes)
 
     # Step 3: Isolate the ring (binary dilated mask minus original binary mask)
     ring_mask = dilated_binary_nodes & invert_array(binary_nodes)
 
+    del binary_nodes
+
     print("Preforming distance transform for smart search... this step may take some time if computed on CPU...")
 
-    try:
+    if fast_dil:
 
-        if GPU == True and cp.cuda.runtime.getDeviceCount() > 0:
-            print("GPU detected. Using CuPy for distance transform.")
+        try:
 
-            try:
+            if GPU == True and cp.cuda.runtime.getDeviceCount() > 0:
+                print("GPU detected. Using CuPy for distance transform.")
 
-                if predownsample is None:
+                try:
 
-                    # Step 4: Find the nearest label for each voxel in the ring
-                    nearest_label_indices = compute_distance_transform_GPU(invert_array(nodes))
+                    if predownsample is None:
 
-                else:
-                    gotoexcept = 1/0
+                        # Step 4: Find the nearest label for each voxel in the ring
+                        nearest_label_indices = compute_distance_transform_GPU(invert_array(nodes))
 
-            except (cp.cuda.memory.OutOfMemoryError, ZeroDivisionError) as e:
-                if predownsample is None:
-                    down_factor = catch_memory(e) #Obtain downsample amount based on memory missing
-                else:
-                    down_factor = (predownsample)**3
+                    else:
+                        gotoexcept = 1/0
 
-                while True:
-                    downsample_needed = down_factor**(1./3.)
-                    small_nodes = nettracer.downsample(nodes, downsample_needed) #Apply downsample
-                    try:
-                        nearest_label_indices = compute_distance_transform_GPU(invert_array(small_nodes)) #Retry dt on downsample
-                        print(f"Using {down_factor} downsample ({downsample_needed} in each dim - Largest possible with this GPU unless user specified downsample)")
-                        break
-                    except cp.cuda.memory.OutOfMemoryError:
-                        down_factor += 1
-                binary_nodes = binarize(small_nodes) #Recompute variables for downsample
-                dilated_mask = dilated_binary_nodes #Need this for later to stamp out the correct output
-                if not fast_dil:
+                except (cp.cuda.memory.OutOfMemoryError, ZeroDivisionError) as e:
+                    if predownsample is None:
+                        down_factor = catch_memory(e) #Obtain downsample amount based on memory missing
+                    else:
+                        down_factor = (predownsample)**3
+
+                    while True:
+                        downsample_needed = down_factor**(1./3.)
+                        small_nodes = nettracer.downsample(nodes, downsample_needed) #Apply downsample
+                        try:
+                            nearest_label_indices = compute_distance_transform_GPU(invert_array(small_nodes)) #Retry dt on downsample
+                            print(f"Using {down_factor} downsample ({downsample_needed} in each dim - Largest possible with this GPU unless user specified downsample)")
+                            break
+                        except cp.cuda.memory.OutOfMemoryError:
+                            down_factor += 1
+                    binary_nodes = binarize(small_nodes) #Recompute variables for downsample
+                    dilated_mask = dilated_binary_nodes #Need this for later to stamp out the correct output
                     dilated_binary_nodes = dilate_3D(binary_nodes, 2 + round_to_odd(dilate_xy/downsample_needed), 2 + round_to_odd(dilate_xy/downsample_needed), 2 + round_to_odd(dilate_z/downsample_needed)) #Mod dilation to recompute variables for downsample while also over dilatiing
-                else:
-                    dilated_binary_nodes = dilate_3D_old(binary_nodes, 2 + round_to_odd(dilate_xy/downsample_needed), 2 + round_to_odd(dilate_xy/downsample_needed), 2 + round_to_odd(dilate_z/downsample_needed)) 
-                ring_mask = dilated_binary_nodes & invert_array(binary_nodes)
-                nodes = small_nodes
-                del small_nodes
-        else:
-            goto_except = 1/0
-    except Exception as e:
-        print("GPU dt failed or did not detect GPU (cupy must be installed with a CUDA toolkit setup...). Computing CPU distance transform instead.")
-        if GPU:
-            print(f"Error message: {str(e)}")
-        nearest_label_indices = compute_distance_transform(invert_array(nodes))
+
+                    ring_mask = dilated_binary_nodes & invert_array(binary_nodes)
+                    nodes = small_nodes
+                    del small_nodes
+            else:
+                goto_except = 1/0
+        except Exception as e:
+            print("GPU dt failed or did not detect GPU (cupy must be installed with a CUDA toolkit setup...). Computing CPU distance transform instead.")
+            if GPU:
+                print(f"Error message: {str(e)}")
+            nearest_label_indices = compute_distance_transform(invert_array(nodes))
 
 
     # Step 5: Process in parallel chunks using ThreadPoolExecutor
@@ -284,12 +341,19 @@ def smart_dilate(nodes, dilate_xy, dilate_z, directory = None, GPU = True, fast_
         args_list = [(i * chunk_size, (i + 1) * chunk_size if i != num_cores - 1 else nodes.shape[0], nodes, ring_mask, nearest_label_indices) for i in range(num_cores)]
         results = list(executor.map(lambda args: process_chunk(*args), args_list))
 
+    del ring_mask
+    del nodes
+    del nearest_label_indices
+
     # Combine results from chunks
     dilated_nodes_with_labels = np.concatenate(results, axis=0)
 
-    if nodes.shape[1] < original_shape[1]: #If downsample was used, upsample output
+
+    if (dilated_nodes_with_labels.shape[1] < original_shape[1]) and fast_dil: #If downsample was used, upsample output
         dilated_nodes_with_labels = nettracer.upsample_with_padding(dilated_nodes_with_labels, downsample_needed, original_shape)
         dilated_nodes_with_labels = dilated_nodes_with_labels * dilated_mask
+    elif (dilated_nodes_with_labels.shape[1] != original_shape[1]) and not fast_dil:
+        dilated_nodes_with_labels = ndimage.zoom(dilated_nodes_with_labels, rev_factor, order=0)
 
     if directory is not None:
         try:
@@ -364,7 +428,7 @@ def smart_label(binary_array, label_array, directory = None, GPU = True, predown
                 binary_core = binarize(small_array)
                 label_array = small_array
                 binary_array = nettracer.downsample(binary_array, downsample_needed)
-                binary_array = nettracer.dilate_3D(binary_array, 3, 3, 3)
+                binary_array = nettracer.dilate_3D_old(binary_array)
                 ring_mask = binary_array & invert_array(binary_core)
 
         else:
@@ -408,7 +472,7 @@ def smart_label(binary_array, label_array, directory = None, GPU = True, predown
 
     return dilated_nodes_with_labels
 
-def compute_distance_transform_GPU(nodes):
+def compute_distance_transform_GPU(nodes, return_dists = False):
     is_pseudo_3d = nodes.shape[0] == 1
     if is_pseudo_3d:
         nodes = np.squeeze(nodes)  # Convert to 2D for processing
@@ -417,7 +481,7 @@ def compute_distance_transform_GPU(nodes):
     nodes_cp = cp.asarray(nodes)
     
     # Compute the distance transform on the GPU
-    _, nearest_label_indices = cpx.distance_transform_edt(nodes_cp, return_indices=True)
+    dists, nearest_label_indices = cpx.distance_transform_edt(nodes_cp, return_indices=True)
     
     # Convert results back to numpy arrays
     nearest_label_indices_np = cp.asnumpy(nearest_label_indices)
@@ -430,18 +494,22 @@ def compute_distance_transform_GPU(nodes):
         # indices_4d[0] stays 0 for all Z coordinates
         nearest_label_indices_np = indices_4d
 
-    
+    if not return_dists:
 
+        return nearest_label_indices_np
+
+    else:
+        dists = cp.asnumpy(dists)
 
-    return nearest_label_indices_np
+        return dists, nearest_label_indices_np
 
 
-def compute_distance_transform(nodes):
+def compute_distance_transform(nodes, return_dists = False):
     is_pseudo_3d = nodes.shape[0] == 1
     if is_pseudo_3d:
         nodes = np.squeeze(nodes)  # Convert to 2D for processing
 
-    distance, nearest_label_indices = distance_transform_edt(nodes, return_indices=True)
+    dists, nearest_label_indices = distance_transform_edt(nodes, return_indices=True)
 
     if is_pseudo_3d:
         # For 2D input, we get (2, H, W) but need (3, 1, H, W)
@@ -451,7 +519,13 @@ def compute_distance_transform(nodes):
         # indices_4d[0] stays 0 for all Z coordinates
         nearest_label_indices = indices_4d
 
-    return nearest_label_indices
+    if not return_dists:
+
+        return nearest_label_indices
+
+    else:
+
+        return dists, nearest_label_indices
 
 
 

{nettracer3d-0.6.5.dist-info → nettracer3d-0.6.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nettracer3d
-Version: 0.6.5
+Version: 0.6.7
 Summary: Scripts for intializing and analyzing networks from segmentations of three dimensional images.
 Author-email: Liam McLaughlin <mclaughlinliam99@gmail.com>
 Project-URL: User_Tutorial, https://www.youtube.com/watch?v=cRatn5VTWDY
@@ -46,12 +46,12 @@ NetTracer3D is free to use/fork for academic/nonprofit use so long as citation i
 
 NetTracer3D was developed by Liam McLaughlin while working under Dr. Sanjay Jain at Washington University School of Medicine.
 
--- Version 0.6.5 updates --
+-- Version 0.6.7 updates --
 
-1. Added new method for obtaining radii of labeled objects (analyze -> stats -> calculate radii)
+1. Updated all methods to use dilation to allow the user to select between perfect distance transform based dilation (which can be slower but allows for perfect searching - and is designed to account for scaling differences), or the current pseudo-3d kernel method.
 
-2. Updated functionality of split nontouching labels function to handle situations where said label is touching other labeled objects in space.
+1.5. The dt dilator accounts for scaling by stretching (upsampling) images to equivalent scales before dilating with the distance transform. It will not attempt to downsample. This admittedly will ask for greater memory and some more processing. To give the user the option to use the dt dilator without dealing with this, I added two new options to the resize method. You can now have it upsample your image until its equivalently scaled, or, if you don't need the fidelity, downsample your image until it's equivalently scaled. When the scaling is equivalent, the dt dilator will always just use the regular distance transform without attempting to resize the array.
 
-3. Image -> Select Objects will now navigate to the first selected object in the array for user, allowing it to be used to also find whatever labeled object.
+2. Fixed radius finding method to also account for scaling correctly. Previous method scaled wrong. New method predictably accounts for differing scaling in xy vs z dims as well.
 
-4. Minor bug fixes/improvements.
+3. Bug fixes.

nettracer3d-0.6.7.dist-info/RECORD

@@ -0,0 +1,20 @@
+nettracer3d/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nettracer3d/community_extractor.py,sha256=5v9SCCLX3P1RX0fjPVKH5NHMFkMolZ5BTe0bR_a67xg,24479
+nettracer3d/modularity.py,sha256=V1f3s_vGd8EuVz27mzq6ycIGr0BWIpH7c7NU4QjgAHU,30247
+nettracer3d/morphology.py,sha256=P7hH9qpDBs0JtMSd95NmrvqoyD8BVq3AjAYv-MWoS_Y,19498
+nettracer3d/nettracer.py,sha256=HDU7z9UOpc2rK1tp-gV7vum27NBNVe8CmfZEeJ7lDBc,209469
+nettracer3d/nettracer_gui.py,sha256=ba_Kx84iu6qfdYKLjhwrS7cXvQQL0_YxrxM9PdIp6kk,401549
+nettracer3d/network_analysis.py,sha256=q1q7lxtA3lebxitfC_jfiT9cnpYXJw4q0Oy2_-Aj8qE,48068
+nettracer3d/network_draw.py,sha256=F7fw6Pcf4qWOhdKwLmhwqWdschbDlHzwCVolQC9imeU,14117
+nettracer3d/node_draw.py,sha256=k3sCTfUCJs3aH1C1q1gTNxDz9EAQbBd1hsUIJajxRx8,9823
+nettracer3d/proximity.py,sha256=mHgU24GZy5GGrR6RETB7QACfOURxgiyUze2dxMfs_3o,10917
+nettracer3d/run.py,sha256=xYeaAc8FCx8MuzTGyL3NR3mK7WZzffAYAH23bNRZYO4,127
+nettracer3d/segmenter.py,sha256=NcNeLSfg3ox-CfnUajT1E2iDqDkv5H6zSJOK_L5N4YI,85020
+nettracer3d/simple_network.py,sha256=fP1gkDdtQcHruEZpUdasKdZeVacoLOxKhR3bY0L1CAQ,15426
+nettracer3d/smart_dilate.py,sha256=ISZR6v52zf-MwhGx-JTfTOP8uo7pNGt-GJj7ydeuMAo,25587
+nettracer3d-0.6.7.dist-info/licenses/LICENSE,sha256=gM207DhJjWrxLuEWXl0Qz5ISbtWDmADfjHp3yC2XISs,888
+nettracer3d-0.6.7.dist-info/METADATA,sha256=jAjlCQhz-wFDiHbqF-nbVpEKu95n77H8CZNLP2cRnGI,4172
+nettracer3d-0.6.7.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+nettracer3d-0.6.7.dist-info/entry_points.txt,sha256=Nx1rr_0QhJXDBHAQg2vcqCzLMKBzSHfwy3xwGkueVyc,53
+nettracer3d-0.6.7.dist-info/top_level.txt,sha256=zsYy9rZwirfCEOubolhee4TyzqBAL5gSUeFMzhFTX8c,12
+nettracer3d-0.6.7.dist-info/RECORD,,

nettracer3d-0.6.5.dist-info/RECORD

@@ -1,20 +0,0 @@
-nettracer3d/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nettracer3d/community_extractor.py,sha256=Zq8ZM595CTzeR6zLEZ4I6KvhkNfCPUReWvAKxTlaVfk,33495
-nettracer3d/modularity.py,sha256=V1f3s_vGd8EuVz27mzq6ycIGr0BWIpH7c7NU4QjgAHU,30247
-nettracer3d/morphology.py,sha256=yncUj04Noj_mcdJze4qMfYw-21AbebwiIcu1bDWGgCM,17778
-nettracer3d/nettracer.py,sha256=vsEDFlsz7WtWdkaK_uJXjbA_QzJRYW9pAQgLiAZOJKc,209987
-nettracer3d/nettracer_gui.py,sha256=492wQV_3nIAPPJRClXA-NssaCvx9H6GDMg6yaiL-BeM,393682
-nettracer3d/network_analysis.py,sha256=q1q7lxtA3lebxitfC_jfiT9cnpYXJw4q0Oy2_-Aj8qE,48068
-nettracer3d/network_draw.py,sha256=F7fw6Pcf4qWOhdKwLmhwqWdschbDlHzwCVolQC9imeU,14117
-nettracer3d/node_draw.py,sha256=k3sCTfUCJs3aH1C1q1gTNxDz9EAQbBd1hsUIJajxRx8,9823
-nettracer3d/proximity.py,sha256=FnIiI_AzfXd22HwCIFIyQRZxKYJ8YscIDdPnIv-wsO4,10560
-nettracer3d/run.py,sha256=xYeaAc8FCx8MuzTGyL3NR3mK7WZzffAYAH23bNRZYO4,127
-nettracer3d/segmenter.py,sha256=oKQEKQpo3o6cqfN6Z_IAgx8V-HXpegQNjfWFz3Bdu04,83449
-nettracer3d/simple_network.py,sha256=fP1gkDdtQcHruEZpUdasKdZeVacoLOxKhR3bY0L1CAQ,15426
-nettracer3d/smart_dilate.py,sha256=vnBj2soDGVBioKaNQi-bcyAtg0nuWcNGmlrzUNFFYQE,23191
-nettracer3d-0.6.5.dist-info/licenses/LICENSE,sha256=gM207DhJjWrxLuEWXl0Qz5ISbtWDmADfjHp3yC2XISs,888
-nettracer3d-0.6.5.dist-info/METADATA,sha256=q1Qp-eXkzhqVVG1A1OkPQeOVqMLbHwx7GdpI1fm_6NA,3476
-nettracer3d-0.6.5.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-nettracer3d-0.6.5.dist-info/entry_points.txt,sha256=Nx1rr_0QhJXDBHAQg2vcqCzLMKBzSHfwy3xwGkueVyc,53
-nettracer3d-0.6.5.dist-info/top_level.txt,sha256=zsYy9rZwirfCEOubolhee4TyzqBAL5gSUeFMzhFTX8c,12
-nettracer3d-0.6.5.dist-info/RECORD,,