nettracer3d 0.6.4__tar.gz → 0.6.6__tar.gz

{nettracer3d-0.6.4/src/nettracer3d.egg-info → nettracer3d-0.6.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nettracer3d
-Version: 0.6.4
+Version: 0.6.6
 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
@@ -27,6 +27,7 @@ Requires-Dist: qtrangeslider==0.1.5
 Requires-Dist: PyQt6==6.8.0
 Requires-Dist: scikit-learn==1.6.1
 Requires-Dist: nibabel==5.2.0
+Requires-Dist: setuptools>=65.0.0
 Provides-Extra: cuda11
 Requires-Dist: cupy-cuda11x; extra == "cuda11"
 Provides-Extra: cuda12
@@ -45,15 +46,8 @@ 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.4 updates --
+-- Version 0.6.6 updates --
 
-1. Fixed bug with tabulated data in top right having a right click window corresponding to the bottom left.
+1. Updated flexibility of the fill holes method for user with varying use cases.
 
-2. Fixed bug when converting communities to nodes that let the same community connect to itself in the new network.
-
-3. Removed attempted trendline fitting from degree distribution
-
-4. Added new feature to skeletonization (and corresponding branch labeler/gennodes)
-	Now you can have the program attempt to auto-correct 3D skeletonization loop artifacts through a method that just runs the 3d fill holes algo and then attempts to reskeletonize the output. This worked well in my own testing. 
-
-5. Other minor fixes/improvements
+2. Greatly improved memory efficiency of segmenter. Now works comfortably with 3.5 GB array on my machine for example (my machine has 64 GB RAM and this occupied around 20% of it I would say). Removed the non-memory efficient option (now always prioritizes mem - the former wasn't even that much faster anyway), removed GPU option (would need an entire cupy-centric build, does not make sense to be sharing a script with the CPU version). 

{nettracer3d-0.6.4 → nettracer3d-0.6.6}/README.md

@@ -8,15 +8,8 @@ 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.4 updates --
+-- Version 0.6.6 updates --
 
-1. Fixed bug with tabulated data in top right having a right click window corresponding to the bottom left.
+1. Updated flexibility of the fill holes method for user with varying use cases.
 
-2. Fixed bug when converting communities to nodes that let the same community connect to itself in the new network.
-
-3. Removed attempted trendline fitting from degree distribution
-
-4. Added new feature to skeletonization (and corresponding branch labeler/gennodes)
-	Now you can have the program attempt to auto-correct 3D skeletonization loop artifacts through a method that just runs the 3d fill holes algo and then attempts to reskeletonize the output. This worked well in my own testing. 
-
-5. Other minor fixes/improvements
+2. Greatly improved memory efficiency of segmenter. Now works comfortably with 3.5 GB array on my machine for example (my machine has 64 GB RAM and this occupied around 20% of it I would say). Removed the non-memory efficient option (now always prioritizes mem - the former wasn't even that much faster anyway), removed GPU option (would need an entire cupy-centric build, does not make sense to be sharing a script with the CPU version). 

{nettracer3d-0.6.4 → nettracer3d-0.6.6}/pyproject.toml

@@ -1,10 +1,11 @@
 [project]
 name = "nettracer3d"
-version = "0.6.4"
+version = "0.6.6"
 authors = [
   { name="Liam McLaughlin", email="mclaughlinliam99@gmail.com" },
 ]
 description = "Scripts for intializing and analyzing networks from segmentations of three dimensional images."
+
 dependencies = [
     "numpy == 1.26.4",
     "scipy == 1.14.1",
@@ -21,7 +22,8 @@ dependencies = [
     "qtrangeslider == 0.1.5",
     "PyQt6 == 6.8.0",
     "scikit-learn == 1.6.1",
-    "nibabel == 5.2.0"
+    "nibabel == 5.2.0",
+    "setuptools >= 65.0.0"
 ]
 
 readme = "README.md"

{nettracer3d-0.6.4 → nettracer3d-0.6.6}/src/nettracer3d/morphology.py

@@ -6,8 +6,17 @@ import multiprocessing as mp
 from concurrent.futures import ThreadPoolExecutor, as_completed
 import tifffile
 from functools import partial
-import pandas as pd
+import concurrent.futures
+from functools import partial
 from scipy import ndimage
+import pandas as pd
+# Import CuPy conditionally for GPU support
+try:
+    import cupy as cp
+    import cupyx.scipy.ndimage as cpx
+    HAS_CUPY = True
+except ImportError:
+    HAS_CUPY = False
 
 def get_reslice_indices(slice_obj, dilate_xy, dilate_z, array_shape):
     """Convert slice object to padded indices accounting for dilation and boundaries"""
@@ -279,9 +288,6 @@ def search_neighbor_ids(nodes, targets, id_dict, neighborhood_dict, totals, sear
 
 
 
-
-
-
 def get_search_space_dilate(target, centroids, id_dict, search, scaling = 1):
 
     ymax = np.max(centroids[:, 0])
@@ -308,4 +314,200 @@ def get_search_space_dilate(target, centroids, id_dict, search, scaling = 1):
 
 
 
-    return array
+    return array
+
+
+# Methods pertaining to getting radii:
+
+def process_object_cpu(label, objects, labeled_array):
+    """
+    Process a single labeled object to estimate its radius (CPU version).
+    This function is designed to be called in parallel.
+    
+    Parameters:
+    -----------
+    label : int
+        The label ID to process
+    objects : list
+        List of slice objects from ndimage.find_objects
+    labeled_array : numpy.ndarray
+        The full 3D labeled array
+        
+    Returns:
+    --------
+    tuple: (label, radius, mask_volume, dimensions)
+    """
+    # Get the slice object (bounding box) for this label
+    # Index is label-1 because find_objects returns 0-indexed results
+    obj_slice = objects[label-1]
+    
+    if obj_slice is None:
+        return label, 0, 0, np.array([0, 0, 0])
+    
+    # Extract subarray containing just this object (plus padding)
+    # Create padded slices to ensure there's background around the object
+    padded_slices = []
+    for dim_idx, dim_slice in enumerate(obj_slice):
+        start = max(0, dim_slice.start - 1)
+        stop = min(labeled_array.shape[dim_idx], dim_slice.stop + 1)
+        padded_slices.append(slice(start, stop))
+    
+    # Extract the subarray
+    subarray = labeled_array[tuple(padded_slices)]
+    
+    # Create binary mask for this object within the subarray
+    mask = (subarray == label)
+    
+    # Compute distance transform on the smaller mask
+    dist_transform = compute_distance_transform_distance(mask)
+    
+    # Filter out small values near the edge to focus on more central regions
+    radius = np.max(dist_transform)
+    
+    # Calculate basic shape metrics
+    volume = np.sum(mask)
+    
+    # Calculate bounding box dimensions
+    x_len = obj_slice[0].stop - obj_slice[0].start
+    y_len = obj_slice[1].stop - obj_slice[1].start
+    z_len = obj_slice[2].stop - obj_slice[2].start
+    dimensions = np.array([x_len, y_len, z_len])
+    
+    return label, radius, volume, dimensions
+
+def estimate_object_radii_cpu(labeled_array, n_jobs=None):
+    """
+    Estimate the radii of labeled objects in a 3D numpy array using distance transform.
+    CPU parallel implementation.
+    
+    Parameters:
+    -----------
+    labeled_array : numpy.ndarray
+        3D array where each object has a unique integer label (0 is background)
+    n_jobs : int or None
+        Number of parallel jobs. If None, uses all available cores.
+    
+    Returns:
+    --------
+    dict: Dictionary mapping object labels to estimated radii
+    dict: (optional) Dictionary of shape statistics for each label
+    """
+    # Find bounding box for each labeled object
+    objects = ndimage.find_objects(labeled_array)
+    
+    unique_labels = np.unique(labeled_array)
+    unique_labels = unique_labels[unique_labels != 0]  # Remove background
+    
+    # Create a partial function for parallel processing
+    process_func = partial(process_object_cpu, objects=objects, labeled_array=labeled_array)
+    
+    # Process objects in parallel
+    results = []
+    with concurrent.futures.ThreadPoolExecutor(max_workers=n_jobs) as executor:
+        # Submit all jobs
+        future_to_label = {executor.submit(process_func, label): label for label in unique_labels}
+        
+        # Collect results as they complete
+        for future in concurrent.futures.as_completed(future_to_label):
+            results.append(future.result())
+    
+    # Organize results
+    radii = {}
+    
+    for label, radius, volume, dimensions in results:
+        radii[label] = radius
+    
+    return radii
+
+def estimate_object_radii_gpu(labeled_array):
+    """
+    Estimate the radii of labeled objects in a 3D numpy array using distance transform.
+    GPU implementation using CuPy.
+    
+    Parameters:
+    -----------
+    labeled_array : numpy.ndarray
+        3D array where each object has a unique integer label (0 is background)
+    
+    Returns:
+    --------
+    dict: Dictionary mapping object labels to estimated radii
+    dict: (optional) Dictionary of shape statistics for each label
+    """
+
+    try:
+        if not HAS_CUPY:
+            raise ImportError("CuPy is required for GPU acceleration")
+
+        # Find bounding box for each labeled object (on CPU)
+        objects = ndimage.find_objects(labeled_array)
+        
+        # Transfer entire labeled array to GPU once
+        labeled_array_gpu = cp.asarray(labeled_array)
+        
+        unique_labels = cp.unique(labeled_array_gpu)
+        unique_labels = cp.asnumpy(unique_labels)
+        unique_labels = unique_labels[unique_labels != 0]  # Remove background
+        
+        radii = {}
+        
+        for label in unique_labels:
+            # Get the slice object (bounding box) for this label
+            obj_slice = objects[label-1]
+            
+            if obj_slice is None:
+                continue
+                
+            # Extract subarray from GPU array
+            padded_slices = []
+            for dim_idx, dim_slice in enumerate(obj_slice):
+                start = max(0, dim_slice.start - 1)
+                stop = min(labeled_array.shape[dim_idx], dim_slice.stop + 1)
+                padded_slices.append(slice(start, stop))
+            
+            # Create binary mask for this object (directly on GPU)
+            mask_gpu = (labeled_array_gpu[tuple(padded_slices)] == label)
+            
+            # Compute distance transform on GPU
+            dist_transform_gpu = compute_distance_transform_distance_GPU(mask_gpu)
+            
+            radius = float(cp.max(dist_transform_gpu).get())
+            
+            # Store the radius
+            radii[label] = radius
+        
+        # Clean up GPU memory
+        del labeled_array_gpu
+            
+        return radii
+
+    except Exception as e:
+        print(f"GPU calculation failed, trying CPU instead -> {e}")
+        return estimate_object_radii_cpu(labeled_array)
+
+def compute_distance_transform_distance_GPU(nodes):
+
+    is_pseudo_3d = nodes.shape[0] == 1
+    if is_pseudo_3d:
+        nodes = cp.squeeze(nodes)  # Convert to 2D for processing
+    
+    # Compute the distance transform on the GPU
+    distance = cpx.distance_transform_edt(nodes)
+
+    if is_pseudo_3d:
+        cp.expand_dims(distance, axis = 0)
+    
+    return distance    
+
+
+def compute_distance_transform_distance(nodes):
+
+    is_pseudo_3d = nodes.shape[0] == 1
+    if is_pseudo_3d:
+        nodes = np.squeeze(nodes)  # Convert to 2D for processing
+
+    # Fallback to CPU if there's an issue with GPU computation
+    distance = ndimage.distance_transform_edt(nodes)
+    if is_pseudo_3d:
+        np.expand_dims(distance, axis = 0)
+    return distance

{nettracer3d-0.6.4 → nettracer3d-0.6.6}/src/nettracer3d/nettracer.py

@@ -547,6 +547,43 @@ def remove_branches(skeleton, length):
     return image_copy
 
 
+def estimate_object_radii(labeled_array, gpu=False, n_jobs=None):
+    """
+    Estimate the radii of labeled objects in a 3D numpy array.
+    Dispatches to appropriate implementation based on parameters.
+    
+    Parameters:
+    -----------
+    labeled_array : numpy.ndarray
+        3D array where each object has a unique integer label (0 is background)
+    gpu : bool
+        Whether to use GPU acceleration via CuPy (if available)
+    n_jobs : int or None
+        Number of parallel jobs for CPU version. If None, uses all available cores.
+    
+    Returns:
+    --------
+    dict: Dictionary mapping object labels to estimated radii
+    dict: (optional) Dictionary of shape statistics for each label
+    """
+    # Check if GPU is requested but not available
+    try:
+        import cupy as cp
+        import cupyx.scipy.ndimage as cpx
+        HAS_CUPY = True
+    except ImportError:
+        HAS_CUPY = False
+
+    if gpu and not HAS_CUPY:
+        print("Warning: GPU acceleration requested but CuPy not available. Falling back to CPU.")
+        gpu = False
+    
+    if gpu:
+        return morphology.estimate_object_radii_gpu(labeled_array)
+    else:
+        return morphology.estimate_object_radii_cpu(labeled_array, n_jobs)
+
+
 def break_and_label_skeleton(skeleton, peaks = 1, branch_removal = 0, comp_dil = 0, max_vol = 0, directory = None, return_skele = False, nodes = None):
     """Internal method to break open a skeleton at its branchpoints and label the remaining components, for an 8bit binary array"""
 
@@ -707,9 +744,9 @@ def z_project(array3d, method='max'):
     else:
         raise ValueError("Method must be one of: 'max', 'mean', 'min', 'sum', 'std'")
 
-def fill_holes_3d(array):
+def fill_holes_3d(array, head_on = False, fill_borders = True):
 
-    def process_slice(slice_2d, border_threshold=0.08):
+    def process_slice(slice_2d, border_threshold=0.08, fill_borders = True):
         """
         Process a 2D slice, considering components that touch less than border_threshold
         of any border length as potential holes.
@@ -720,6 +757,9 @@ def fill_holes_3d(array):
         """
         slice_2d = slice_2d.astype(np.uint8)
         labels, num_features = ndimage.label(slice_2d)
+
+        if not fill_borders:
+            border_threshold = 0 #Testing
         
         if num_features == 0:
             return np.zeros_like(slice_2d)
@@ -744,8 +784,10 @@ def fill_holes_3d(array):
         
         # Create mask of components that either don't touch borders
         # or touch less than the threshold proportion
+
         background_labels = {label for label, prop in border_proportions.items() 
                             if prop > border_threshold}
+
         
         holes_mask = ~np.isin(labels, list(background_labels))
         
@@ -765,19 +807,19 @@ def fill_holes_3d(array):
 
     # Process XY plane
     for z in range(inv_array.shape[0]):
-        array_xy[z] = process_slice(inv_array[z])
+        array_xy[z] = process_slice(inv_array[z], fill_borders = fill_borders)
 
-    if array.shape[0] > 3: #only use these dimensions for sufficiently large zstacks
+    if (array.shape[0] > 3) and not head_on: #only use these dimensions for sufficiently large zstacks
         
         # Process XZ plane    
         for y in range(inv_array.shape[1]):
             slice_xz = inv_array[:, y, :]
-            array_xz[:, y, :] = process_slice(slice_xz)
+            array_xz[:, y, :] = process_slice(slice_xz, fill_borders = fill_borders)
             
         # Process YZ plane
         for x in range(inv_array.shape[2]):
             slice_yz = inv_array[:, :, x]
-            array_yz[:, :, x] = process_slice(slice_yz)
+            array_yz[:, :, x] = process_slice(slice_yz, fill_borders = fill_borders)
         
         # Combine results from all three planes
         filled = (array_xy | array_xz | array_yz) * 255