nettracer3d 1.2.4__py3-none-any.whl → 1.2.7__py3-none-any.whl

nettracer3d/smart_dilate.py

@@ -3,12 +3,15 @@ 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
+from concurrent.futures import ThreadPoolExecutor, as_completed, ProcessPoolExecutor
+from skimage.segmentation import watershed
 import cv2
 import os
+import edt
 import math
 import re
 from . import nettracer
+from multiprocessing import shared_memory
 import multiprocessing as mp
 try:
     import cupy as cp
@@ -177,6 +180,7 @@ def dilate_3D_old(tiff_array, dilated_x=3, dilated_y=3, dilated_z=3):
     
     return dilated_array.astype(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.
@@ -286,74 +290,30 @@ 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 = True, predownsample = None, use_dt_dil_amount = None, xy_scale = 1, z_scale = 1):
-
-    original_shape = nodes.shape
-
+def smart_dilate(nodes, dilate_xy = 0, dilate_z = 0, directory = None, GPU = True, fast_dil = True, predownsample = None, use_dt_dil_amount = None, xy_scale = 1, z_scale = 1):
 
-    #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)
+        dilated = nettracer.dilate_3D_dt(nodes, use_dt_dil_amount, xy_scale, z_scale, fast_dil = True)
+        return smart_label_watershed(dilated, nodes, directory = None, remove_template = False)
+
     else:
-        dilated_binary_nodes, nearest_label_indices, nodes = dilate_3D_dt(nodes, use_dt_dil_amount, GPU = GPU, xy_scaling = xy_scale, z_scaling = z_scale)
-        binary_nodes = binarize(nodes)
+        return smart_dilate_short(nodes, use_dt_dil_amount, directory, xy_scale, z_scale)
 
-    # 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...")
 
-    if fast_dil:
 
-        try:
+def smart_dilate_short(nodes, amount = None, directory = None, xy_scale = 1, z_scale = 1):
 
-            if GPU == True and cp.cuda.runtime.getDeviceCount() > 0:
-                print("GPU detected. Using CuPy for distance transform.")
-
-                try:
-
-                    if predownsample is None:
-
-                        # Step 4: Find the nearest label for each voxel in the ring
-                        nearest_label_indices = compute_distance_transform_GPU(invert_array(nodes))
-
-                    else:
-                        gotoexcept = 1/0
-
-                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
-
-                    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))
+    original_shape = nodes.shape
+
+    print("Performing distance transform for smart search...")
 
+    dilated_binary_nodes, nearest_label_indices, nodes = dilate_3D_dt(nodes, amount, xy_scaling = xy_scale, z_scaling = z_scale)
+    binary_nodes = binarize(nodes)
+    ring_mask = dilated_binary_nodes & (~binary_nodes)
+    del dilated_binary_nodes
+    del binary_nodes
 
     # Step 5: Process in parallel chunks using ThreadPoolExecutor
     num_cores = mp.cpu_count()  # Use all available CPU cores
@@ -370,11 +330,6 @@ def smart_dilate(nodes, dilate_xy, dilate_z, directory = None, GPU = True, fast_
     # Combine results from chunks
     dilated_nodes_with_labels = np.concatenate(results, axis=1)
 
-
-    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
-
     if directory is not None:
         try:
             tifffile.imwrite(f"{directory}/search_region.tif", dilated_nodes_with_labels)
@@ -393,7 +348,63 @@ def round_to_odd(number):
             rounded -= 1
     return rounded
 
-def smart_label(binary_array, label_array, directory = None, GPU = True, predownsample = None, remove_template = False):
+def smart_label_watershed(binary_array, label_array, directory = None, remove_template = False):
+    """
+    Watershed-based version - much lower memory footprint
+    """
+    original_shape = binary_array.shape
+    
+    if type(binary_array) == str or type(label_array) == str:
+        string_bool = True
+    else:
+        string_bool = None
+    if type(binary_array) == str:
+        binary_array = tifffile.imread(binary_array)
+    if type(label_array) == str:
+        label_array = tifffile.imread(label_array)
+    
+    # Binarize
+    binary_array = binarize(binary_array)
+    
+    print("Performing watershed label propagation...")
+    
+    # Watershed approach: propagate existing labels into the dilated region
+    # The labels themselves are the "markers" (seeds)
+    # We use the binary mask to define where labels can spread
+    
+    # Simple elevation map: distance from edges (lower = closer to labeled regions)
+    # This makes watershed flow from labeled regions outward
+    elevation = binary_array.astype(np.float32)
+    
+    # Apply watershed - labels propagate into binary_array region
+    dilated_nodes_with_labels = watershed(
+        elevation,           # Elevation map (flat works fine)
+        markers=label_array, # Seed labels
+        mask=binary_array,   # Where to propagate
+        compactness=0        # Pure distance-based (not shape-based)
+    )
+    
+    if remove_template:
+        dilated_nodes_with_labels *= binary_array
+    
+    if string_bool:
+        if directory is not None:
+            try:
+                tifffile.imwrite(f"{directory}/smart_labelled_array.tif", dilated_nodes_with_labels)
+            except Exception as e:
+                print(f"Could not save search region file to {directory}")
+        else:
+            try:
+                tifffile.imwrite("smart_labelled_array.tif", dilated_nodes_with_labels)
+            except Exception as e:
+                print(f"Could not save search region file to active directory")
+    
+    return dilated_nodes_with_labels
+
+def smart_label(binary_array, label_array, directory = None, GPU = True, predownsample = None, remove_template = False, mode = 0):
+
+    if mode == 1:
+        return smart_label_watershed(binary_array, label_array, directory, remove_template)
 
     original_shape = binary_array.shape
 
@@ -406,79 +417,93 @@ def smart_label(binary_array, label_array, directory = None, GPU = True, predown
     if type(label_array) == str:
         label_array = tifffile.imread(label_array)
 
-    # Step 1: Binarize the labeled array
-    binary_core = binarize(label_array)
+    # Binarize inputs
     binary_array = binarize(binary_array)
+    
+    print("Performing distance transform for smart label...")
 
-    # Step 3: Isolate the ring (binary dilated mask minus original binary mask)
-    ring_mask = binary_array & invert_array(binary_core)
-
-
+    downsample_needed = None  # Track if we downsampled
+    
     try:
-
         if GPU == True and cp.cuda.runtime.getDeviceCount() > 0:
             print("GPU detected. Using CuPy for distance transform.")
 
             try:
-
                 if predownsample is None:
-
-                    # Step 4: Find the nearest label for each voxel in the ring
+                    # Compute binary_core only when needed
+                    binary_core = binarize(label_array)
                     nearest_label_indices = compute_distance_transform_GPU(invert_array(binary_core))
-
+                    del binary_core  # Free immediately after use
                 else:
-                    gotoexcept = 1/0
+                    raise ZeroDivisionError  # Force downsample path
 
             except (cp.cuda.memory.OutOfMemoryError, ZeroDivisionError) as e:
                 if predownsample is None:
-                    down_factor = catch_memory(e) #Obtain downsample amount based on memory missing
+                    down_factor = catch_memory(e)
                 else:
                     down_factor = (predownsample)**3
 
                 while True:
                     downsample_needed = down_factor**(1./3.)
-                    small_array = nettracer.downsample(label_array, downsample_needed) #Apply downsample
+                    small_array = nettracer.downsample(label_array, downsample_needed)
                     try:
-                        nearest_label_indices = compute_distance_transform_GPU(invert_array(small_array)) #Retry dt on downsample
-                        print(f"Using {down_factor} downsample ({downsample_needed} in each dim - Largest possible with this GPU unless user specified downsample)")
+                        binary_core = binarize(small_array)
+                        nearest_label_indices = compute_distance_transform_GPU(invert_array(binary_core))
+                        print(f"Using {down_factor} downsample ({downsample_needed} in each dim)")
+                        del small_array  # Don't need small_array anymore
                         break
                     except cp.cuda.memory.OutOfMemoryError:
+                        del small_array, binary_core  # Clean up before retry
                         down_factor += 1
-                binary_core = binarize(small_array)
-                label_array = small_array
+                
+                # Update label_array for later use
+                label_array = nettracer.downsample(label_array, downsample_needed)
                 binary_small = nettracer.downsample(binary_array, downsample_needed)
                 binary_small = nettracer.dilate_3D_old(binary_small)
                 ring_mask = binary_small & invert_array(binary_core)
-
+                del binary_small, binary_core  # Free after creating ring_mask
         else:
-            goto_except = 1/0
+            raise Exception("GPU not available")
+            
     except Exception as e:
         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("GPU dt failed or did not detect GPU. Computing CPU distance transform instead.")
             print(f"Error message: {str(e)}")
             import traceback
             print(traceback.format_exc())
-        nearest_label_indices = compute_distance_transform(invert_array(label_array))
+        binary_core = binarize(label_array)
+        nearest_label_indices = compute_distance_transform(invert_array(binary_core))
+        del binary_core
 
-    print("Preforming distance transform for smart label...")
-
-    # Step 5: Process in parallel chunks using ThreadPoolExecutor
-    num_cores = mp.cpu_count()  # Use all available CPU cores
-    chunk_size = label_array.shape[1] // num_cores  # Divide the array into chunks along the z-axis
+    # Compute ring_mask only if not already computed in downsample path
+    if 'ring_mask' not in locals():
+        binary_core = binarize(label_array)
+        ring_mask = binary_array & invert_array(binary_core)
+        del binary_core
 
+    # Step 5: Process in parallel chunks
+    num_cores = mp.cpu_count()
+    chunk_size = label_array.shape[1] // num_cores
 
     with ThreadPoolExecutor(max_workers=num_cores) as executor:
-        args_list = [(i * chunk_size, (i + 1) * chunk_size if i != num_cores - 1 else label_array.shape[1], label_array, ring_mask, nearest_label_indices) for i in range(num_cores)]
+        args_list = [(i * chunk_size, (i + 1) * chunk_size if i != num_cores - 1 else label_array.shape[1], 
+                     label_array, ring_mask, nearest_label_indices) for i in range(num_cores)]
         results = list(executor.map(lambda args: process_chunk(*args), args_list))
 
-    # Combine results from chunks
+    # Free large arrays no longer needed
+    del label_array, ring_mask, nearest_label_indices
+
+    # Combine results
     dilated_nodes_with_labels = np.concatenate(results, axis=1)
+    del results  # Free the list of chunks
 
-    if label_array.shape[1] < original_shape[1]: #If downsample was used, upsample output
+    if downsample_needed is not None:  # If downsample was used
         dilated_nodes_with_labels = nettracer.upsample_with_padding(dilated_nodes_with_labels, downsample_needed, original_shape)
-        dilated_nodes_with_labels = dilated_nodes_with_labels * binary_array
+        dilated_nodes_with_labels *= binary_array  # In-place multiply if possible
     elif remove_template:
-        dilated_nodes_with_labels = dilated_nodes_with_labels * binary_array
+        dilated_nodes_with_labels *= binary_array  # In-place multiply if possible
+
+    del binary_array  # Done with this
 
     if string_bool:
         if directory is not None:
@@ -492,7 +517,6 @@ def smart_label(binary_array, label_array, directory = None, GPU = True, predown
             except Exception as e:
                 print(f"Could not save search region file to active directory")
 
-
     return dilated_nodes_with_labels
 
 def smart_label_single(binary_array, label_array):
@@ -613,24 +637,93 @@ def compute_distance_transform_distance_GPU(nodes, sampling = [1, 1, 1]):
     return distance    
 
 
-def compute_distance_transform_distance(nodes, sampling = [1, 1, 1]):
-
-    #print("(Now doing distance transform...)")
+def _run_edt_in_process_shm(input_shm_name, output_shm_name, shape, dtype_str, sampling_tuple):
+    """Helper function to run edt in a separate process using shared memory."""
+    import edt  # Import here to ensure it's available in child process
+    
+    input_shm = shared_memory.SharedMemory(name=input_shm_name)
+    output_shm = shared_memory.SharedMemory(name=output_shm_name)
+    
+    try:
+        nodes_arr = np.ndarray(shape, dtype=dtype_str, buffer=input_shm.buf)
+        
+        n_cores = mp.cpu_count()
+        result = edt.edt(
+            nodes_arr.astype(bool),
+            anisotropy=sampling_tuple,
+            parallel=n_cores
+        )
+        
+        result_array = np.ndarray(result.shape, dtype=result.dtype, buffer=output_shm.buf)
+        np.copyto(result_array, result)
+        
+        return result.shape, str(result.dtype)
+    finally:
+        input_shm.close()
+        output_shm.close()
 
+def compute_distance_transform_distance(nodes, sampling=[1, 1, 1], fast_dil=False):
+    """
+    Compute distance transform with automatic parallelization when available.
+    
+    Args:
+        nodes: Binary array (True/1 for objects)
+        sampling: Voxel spacing [z, y, x] for anisotropic data
+    
+    Returns:
+        Distance transform array
+    """
     is_pseudo_3d = nodes.shape[0] == 1
+    
     if is_pseudo_3d:
-        nodes = np.squeeze(nodes)  # Convert to 2D for processing
+        nodes = np.squeeze(nodes)
         sampling = [sampling[1], sampling[2]]
-
-    # Fallback to CPU if there's an issue with GPU computation
-    distance = distance_transform_edt(nodes, sampling = sampling)
+    
+    if fast_dil:
+        try:
+            # Use shared memory for all array sizes
+            input_shm = shared_memory.SharedMemory(create=True, size=nodes.nbytes)
+            output_size = nodes.size * np.dtype(np.float64).itemsize
+            output_shm = shared_memory.SharedMemory(create=True, size=output_size)
+            
+            try:
+                shm_array = np.ndarray(nodes.shape, dtype=nodes.dtype, buffer=input_shm.buf)
+                np.copyto(shm_array, nodes)
+                
+                with ProcessPoolExecutor(max_workers=1) as executor:
+                    future = executor.submit(
+                        _run_edt_in_process_shm,
+                        input_shm.name,
+                        output_shm.name,
+                        nodes.shape,
+                        str(nodes.dtype),
+                        tuple(sampling)
+                    )
+                    result_shape, result_dtype = future.result(timeout=300)  # Add timeout
+                
+                distance = np.ndarray(result_shape, dtype=result_dtype, buffer=output_shm.buf).copy()
+                
+            finally:
+                input_shm.close()
+                input_shm.unlink()
+                output_shm.close()
+                output_shm.unlink()
+                
+        except Exception as e:
+            print(f"Parallel distance transform failed ({e}), falling back to scipy")
+            import traceback
+            traceback.print_exc()  # See the full error
+            distance = distance_transform_edt(nodes, sampling=sampling)
+    else:
+        distance = distance_transform_edt(nodes, sampling=sampling)
+    
     if is_pseudo_3d:
-        distance = np.expand_dims(distance, axis = 0)
+        distance = np.expand_dims(distance, axis=0)
+    
     return distance
 
 
 
-
 def gaussian(search_region, GPU = True):
     try:
         if GPU == True and cp.cuda.runtime.getDeviceCount() > 0:

nettracer3d/tutorial.py

@@ -1098,8 +1098,6 @@ def setup_start_tutorial(window):
         )
 
 
-
-    
     
     # Step 9: Close dialog and finish
     def close_dialog():
@@ -1111,7 +1109,6 @@ def setup_start_tutorial(window):
         None,
         "That's it for the Intro tutorial! Select the Basic Interface Tour next to see how to use the main GUI elements.",
         message_position="bottom",
-        pre_action=MenuHelper.create_widget_interaction(tutorial, 'properties_dialog', 'xy_scale', 'close()'),
         action=close_dialog
     )
 
@@ -1646,33 +1643,13 @@ def setup_connectivity_tutorial(window):
         action=MenuHelper.create_widget_interaction(tutorial, 'con_dialog', 'down_factor', 'setText("")')
     )
 
-    """ # <-- so I am trying out removing these because their use cases are confusing
-
-    tutorial.add_step(
-        MenuHelper.create_widget_getter(tutorial, 'con_dialog', 'GPU_downsample'),
-        "If you want to try and use the GPU, you can likewise enter an arbitrary integer downsample factor here to speed it up. Note the GPU calculation can be greedy with VRAM and will automatically try to downsample itself in a lot of cases."
-        highlight_type=None,
-        message_position="beside",
-        pre_action=MenuHelper.create_widget_interaction(tutorial, 'con_dialog', 'GPU_downsample', 'setText("INTEGER!")'),
-        action=MenuHelper.create_widget_interaction(tutorial, 'con_dialog', 'GPU_downsample', 'setText("")')
-    )
-
-    tutorial.add_step(
-        MenuHelper.create_widget_getter(tutorial, 'con_dialog', 'GPU'),
-        "Enable this to have your system attempt to use the GPU. You will need a CUDA toolkit and a corresponding cupy package installed. Note that I consider this function somewhat experimental. In short, the cupy implementation uses a distance transform calculation that can be very greedy with VRAM. If it overflows, it will attempt to iteratively downsample itself until the calculation works (specifically containing to calculating the 'node search' volume). Note this risks kicking out small nodes from your image. Furthermore, it is only really applicable of 'fast dilation' is enabled. Therefore, generally skip using this option. However, it can be a way to rapidly assess the general network structure of a large image.",
-        highlight_type=None,
-        message_position="beside",
-        pre_action=MenuHelper.create_widget_interaction(tutorial, 'con_dialog', 'GPU', 'click()'),
-        action = MenuHelper.create_widget_interaction(tutorial, 'con_dialog', 'GPU', 'toggle()'))
-
     tutorial.add_step(
         MenuHelper.create_widget_getter(tutorial, 'con_dialog', 'fastdil'),
-        "Enable this to have the algorithm use fast dilation. Fast dilation "
-        highlight_type=None,
+        "Enable the fast search button to use a slightly alternate algorithm for the node search step that is faster. This algorithm uses a parallelized distance transform to create a binary search region which is a lot faster if you have a lot of CPU cores. It then uses flooding to label the binary search region, which leads to slightly rough labeling where two search regions meet. When disabled, a non-parallel distance transform is used, which can be slower but always has exact labels where two search regions meet. I recommend enabling this for larger images and disabling it for smaller ones.",        highlight_type=None,
         message_position="beside",
         pre_action=MenuHelper.create_widget_interaction(tutorial, 'con_dialog', 'fastdil', 'click()'),
-        action = MenuHelper.create_widget_interaction(tutorial, 'con_dialog', 'fastdil', 'toggle()'))
-    """
+        action=MenuHelper.create_widget_interaction(tutorial, 'con_dialog', 'fastdil', 'toggle()')
+    )
 
     tutorial.add_step(
         MenuHelper.create_widget_getter(tutorial, 'con_dialog', 'overlays'),
@@ -1765,35 +1742,6 @@ def setup_branch_tutorial(window):
         pre_action=open_dialog
     )
 
-    """
-    tutorial.add_step(
-        MenuHelper.create_widget_getter(tutorial, 'branch_dialog', 'fix'),
-        "This first auto-correction option is designed if you feel like the branch labels are generally too busy. Selecting this will have the program attempt to collapse overly-dense regions of branches into a single label. Note that this behavior is somewhat tricky to predict so I generally don't use it but feel free to give it a shot and see how it looks.",
-        highlight_type=None,
-        message_position="beside",
-        pre_action=MenuHelper.create_widget_interaction(tutorial, 'branch_dialog', 'fix', 'click()'),
-        action=MenuHelper.create_widget_interaction(tutorial, 'branch_dialog', 'fix', 'toggle()')
-    )
-    
-    tutorial.add_step(
-        MenuHelper.create_widget_getter(tutorial, 'branch_dialog', 'fix_val'),
-        "This integer value tells the above parameter (if enabled) what degree of branch-busyness should get merged. In short, a lower value is more aggressive with merging while a higher value only merges very busy regions. By default it is set to 4.",
-        highlight_type=None,
-        message_position="beside",
-        pre_action=MenuHelper.create_widget_interaction(tutorial, 'branch_dialog', 'fix_val', 'selectAll()'),
-        action=MenuHelper.create_widget_interaction(tutorial, 'branch_dialog', 'fix_val', 'deselect()')
-    )
-
-    tutorial.add_step(
-        MenuHelper.create_widget_getter(tutorial, 'branch_dialog', 'seed'),
-        "The random seed for grouping branches above can be changed here with an integer value, if the behavior of the above option is desired to be tweaked somewhat. It will use 42 by default.",
-        highlight_type=None,
-        message_position="beside",
-        pre_action=MenuHelper.create_widget_interaction(tutorial, 'branch_dialog', 'seed', 'setText("INTEGER!")'),
-        action=MenuHelper.create_widget_interaction(tutorial, 'branch_dialog', 'seed', 'setText("")')
-    )
-
-    """
 
     tutorial.add_step(
         MenuHelper.create_widget_getter(tutorial, 'branch_dialog', 'fix2'),
@@ -1838,6 +1786,15 @@ def setup_branch_tutorial(window):
         action=MenuHelper.create_widget_interaction(tutorial, 'branch_dialog', 'down_factor', 'deselect()')
     )
 
+    tutorial.add_step(
+        MenuHelper.create_widget_getter(tutorial, 'branch_dialog', 'mode'),
+        "The Algorithm Dropdown lets you choose between the standard algorithm, which provides more exact labels along branch borders, and the faster labeling algorithm, which uses flooding to label the binary branches, leading to slightly rough labeling where two branches meet. I recommend using the standard for smaller images and the fast for larger images where computation time becomes an issue.",
+        highlight_type=None,
+        message_position="beside",
+        pre_action=MenuHelper.create_widget_interaction(tutorial, 'branch_dialog', 'mode', 'showPopup()'),
+        action=MenuHelper.create_widget_interaction(tutorial, 'branch_dialog', 'mode', 'hidePopup()')
+    )
+
 
     tutorial.add_step(
         MenuHelper.create_widget_getter(tutorial, 'branch_dialog', 'compute'),
@@ -1881,16 +1838,6 @@ def setup_branch_tutorial(window):
         pre_action=open_dialog
     )
 
-    tutorial.add_step(
-        MenuHelper.create_widget_getter(tutorial, 'gen_dialog', 'down_factor'),
-        "This integer value can be used to temporarily downsample the image while creating branchpoints. Aside from speeding up the process, this may alter branch detection, possibly performing a cleaner branch appraisal of very thick branches but losing network identification of smaller branches (Much like in the prior menu - note that any value entered in the prior menu will be applied by default here for consistency, and you won't see this option). It is disabled by default. Larger values will downsample more aggressively.",
-        highlight_type=None,
-        message_position="beside",
-        pre_action=MenuHelper.create_widget_interaction(tutorial, 'gen_dialog', 'down_factor', 'selectAll()'),
-        action=MenuHelper.create_widget_interaction(tutorial, 'gen_dialog', 'down_factor', 'deselect()')
-    )
-
-
     tutorial.add_step(
         MenuHelper.create_widget_getter(tutorial, 'gen_dialog', 'branch_removal'),
         "IMPORTANT - This branch removal parameter (Skeleton voxel branch to remove...) is something I would consider entering a value for. This is the length of terminal branches that will be removed prior to any vertex/branch labeling. Any branch shorter than the value here will be removed, but only if it is a terminal branch. For more jagged segmentations, this may be a necessity to prevent branchpoints from arising from spine-like artifacts. More internal branches will not be removed, so as a test it is generally safe to enter a large value here, which will preserve the majority of the branch schema and just risk losing occasional terminal branches.",
@@ -1918,6 +1865,26 @@ def setup_branch_tutorial(window):
         action=MenuHelper.create_widget_interaction(tutorial, 'gen_dialog', 'comp_dil', 'setText("")')
     )
 
+    tutorial.add_step(
+        MenuHelper.create_widget_getter(tutorial, 'gen_dialog', 'fast_dil'),
+        "Enable fast dilation to use a parallelized distance transform to do 3D dilation which is a lot faster if you have a lot of CPU cores. Note that this only applies if you have chosen to merge your nodes.",        
+        highlight_type=None,
+        message_position="beside",
+        pre_action=MenuHelper.create_widget_interaction(tutorial, 'gen_dialog', 'fast_dil', 'click()'),
+        action=MenuHelper.create_widget_interaction(tutorial, 'gen_dialog', 'fast_dil', 'toggle()')
+    )
+
+    tutorial.add_step(
+        MenuHelper.create_widget_getter(tutorial, 'gen_dialog', 'down_factor'),
+        "This integer value can be used to temporarily downsample the image while creating branchpoints. Aside from speeding up the process, this may alter branch detection, possibly performing a cleaner branch appraisal of very thick branches but losing network identification of smaller branches (Much like in the prior menu - note that any value entered in the prior menu will be applied by default here for consistency, and you won't see this option). It is disabled by default. Larger values will downsample more aggressively.",
+        highlight_type=None,
+        message_position="beside",
+        pre_action=MenuHelper.create_widget_interaction(tutorial, 'gen_dialog', 'down_factor', 'selectAll()'),
+        action=MenuHelper.create_widget_interaction(tutorial, 'gen_dialog', 'down_factor', 'deselect()')
+    )
+
+
+
     def close_dialog():
         if hasattr(tutorial, 'gen_dialog') and tutorial.gen_dialog:
             tutorial.gen_dialog.close()

{nettracer3d-1.2.4.dist-info → nettracer3d-1.2.7.dist-info}/METADATA

@@ -1,10 +1,11 @@
 Metadata-Version: 2.4
 Name: nettracer3d
-Version: 1.2.4
+Version: 1.2.7
 Summary: Scripts for intializing and analyzing networks from segmentations of three dimensional images.
 Author-email: Liam McLaughlin <liamm@wustl.edu>
 Project-URL: Documentation, https://nettracer3d.readthedocs.io/en/latest/
-Project-URL: Reference_Citation_For_Use, https://doi.org/10.1101/2024.07.29.605633
+Project-URL: Youtube_Tutorial, https://www.youtube.com/watch?v=_4uDy0mzG94&list=PLsrhxiimzKJMZ3_gTWkfrcAdJQQobUhj7
+Project-URL: Downloadable_Version, https://doi.org/10.5281/zenodo.17873800
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: Other/Proprietary License
 Classifier: Operating System :: OS Independent
@@ -24,9 +25,9 @@ Requires-Dist: tifffile
 Requires-Dist: qtrangeslider
 Requires-Dist: PyQt6
 Requires-Dist: scikit-learn
-Requires-Dist: nibabel
 Requires-Dist: setuptools
 Requires-Dist: umap-learn
+Requires-Dist: edt
 Provides-Extra: cuda11
 Requires-Dist: cupy-cuda11x; extra == "cuda11"
 Provides-Extra: cuda12
@@ -44,13 +45,20 @@ Dynamic: license-file
 
 NetTracer3D is a python package developed for both 2D and 3D analysis of microscopic images in the .tif file format. It supports generation of 3D networks showing the relationships between objects (or nodes) in three dimensional space, either based on their own proximity or connectivity via connecting objects such as nerves or blood vessels. In addition to these functionalities are several advanced 3D data processing algorithms, such as labeling of branched structures or abstraction of branched structures into networks. Note that nettracer3d uses segmented data, which can be segmented from other softwares such as ImageJ and imported into NetTracer3D, although it does offer its own segmentation via intensity and volumetric thresholding, or random forest machine learning segmentation. NetTracer3D currently has a fully functional GUI. To use the GUI, after installing the nettracer3d package via pip, enter the command 'nettracer3d' in your command prompt:
 
+
 --- Documentation ---
 
 Please see: https://nettracer3d.readthedocs.io/en/latest/
 
+
+--- Video Tutorial ---
+
+Please see: https://www.youtube.com/watch?v=_4uDy0mzG94&list=PLsrhxiimzKJMZ3_gTWkfrcAdJQQobUhj7
+
+
 --- Installation ---
 
-To install nettracer3d, simply install Python and use this command in your command terminal:
+To install nettracer3d, simply install Python. Make sure the Python installation installs pip, and that both Python and pip are available on your PATH. Next, use this command in your command terminal:
 
 pip install nettracer3d
 
@@ -59,6 +67,10 @@ I recommend installing the program as an Anaconda package to ensure its modules
 
 https://www.anaconda.com/download?utm_source=anacondadocs&utm_medium=documentation&utm_campaign=download&utm_content=installwindows
 
+Alternatively, you can download a compiled .exe of version 1.2.7 here: https://doi.org/10.5281/zenodo.17873800 
+
+Unzip the folder, then double click the NetTracer3D executable to run the program. Note that this version will be missing a few features compared to the Python package, namely GPU segmentation support and the ability to print updates to the command window. It will also not be updated as often.
+
 Optional Packages
 ~~~~~~~~~~~~~~~~~~
 I recommend including Napari (Chi-Li Chiu, Nathan Clack, the napari community, napari: a Python Multi-Dimensional Image Viewer Platform for the Research Community, Microscopy and Microanalysis, Volume 28, Issue S1, 1 August 2022, Pages 1576–1577, https://doi.org/10.1017/S1431927622006328) in the download as well, which allows NetTracer3D to use 3D displays. The standard package only comes with its native 2D slice display window. 
@@ -100,16 +112,18 @@ While not related to NetTracer3D, if you want to use Cellpose3 (for which GPU-us
 This gui is built from the PyQt6 package and therefore may not function on dockers or virtual envs that are unable to support PyQt6 displays.
 
 
-NetTracer3D is free to use/fork for academic/nonprofit use so long as citation is provided, and is available for commercial use at a fee (see license file for information).
-The current citation is here: 
+NetTracer3D is freely available for academic and nonprofit use and can obtained from pip (pip install nettracer3d), provided that citation is included in any abstract, paper, or presentation utilizing NetTracer3D.
 
-McLaughlin, L., Zhang, B., Sharma, S. et al. Three dimensional multiscalar neurovascular nephron connectivity map of the human kidney across the lifespan. Nat Commun 16, 5161 (2025). https://doi.org/10.1038/s41467-025-60435-8
+(The official paper to cite is coming soon)
 
 NetTracer3D was developed by Liam McLaughlin while working under Dr. Sanjay Jain at Washington University School of Medicine.
 
--- Version 1.2.4 Updates --
+-- Version 1.2.7 Updates --
 
-	* Fixed bug for calculating surface area when the surface was on the edge of the image.
-	* Removed video tutorial from youtube for being outdated. May add new one later.
+	* Added a faster parallelized option for all distance transform calculations.
+	* Similarly, added flooding as a faster but slightly rougher option for propagating labels. This and the above can be combined to do much faster calculations for bigger images.
+	* Now depends on the 'edt' package (which does the above).
+	* Removed dependency on nibabel (which was just being used to open .nii files). .nii files can still be opened if nibabel is installed manually.
+	* Added option to not show numerical labels when displaying network graph.