nettracer3d 0.6.3__tar.gz → 0.6.5__tar.gz

{nettracer3d-0.6.3/src/nettracer3d.egg-info → nettracer3d-0.6.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nettracer3d
-Version: 0.6.3
+Version: 0.6.5
 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,10 +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.3 updates --
+-- Version 0.6.5 updates --
 
-1. Fixed bug with the active channel indicator on the GUI not always updating when the active channel was changed by internal loading.
+1. Added new method for obtaining radii of labeled objects (analyze -> stats -> calculate radii)
 
-2. Updated ram_lock mode in the segmenter to garbage collect better... again.
+2. Updated functionality of split nontouching labels function to handle situations where said label is touching other labeled objects in space.
 
-3. Added new function (Label neighborhoods). Find it in process -> image -> label neighborhoods. Allows a 3d labeled array to act as a kernel and extend its labels along a secondary binary array. This can be useful in evaluating nearest neighbors en-masse. The method behind this (smart label) was previously used internally for some methods (ie watershedding) but I thought I'd include it as an actual function since it has some more general uses.
+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.
+
+4. Minor bug fixes/improvements.

{nettracer3d-0.6.3 → nettracer3d-0.6.5}/README.md

@@ -8,10 +8,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.3 updates --
+-- Version 0.6.5 updates --
 
-1. Fixed bug with the active channel indicator on the GUI not always updating when the active channel was changed by internal loading.
+1. Added new method for obtaining radii of labeled objects (analyze -> stats -> calculate radii)
 
-2. Updated ram_lock mode in the segmenter to garbage collect better... again.
+2. Updated functionality of split nontouching labels function to handle situations where said label is touching other labeled objects in space.
 
-3. Added new function (Label neighborhoods). Find it in process -> image -> label neighborhoods. Allows a 3d labeled array to act as a kernel and extend its labels along a secondary binary array. This can be useful in evaluating nearest neighbors en-masse. The method behind this (smart label) was previously used internally for some methods (ie watershedding) but I thought I'd include it as an actual function since it has some more general uses.
+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.
+
+4. Minor bug fixes/improvements.

{nettracer3d-0.6.3 → nettracer3d-0.6.5}/pyproject.toml

@@ -1,10 +1,11 @@
 [project]
 name = "nettracer3d"
-version = "0.6.3"
+version = "0.6.5"
 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.3 → nettracer3d-0.6.5}/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.3 → nettracer3d-0.6.5}/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"""
 
@@ -751,6 +788,8 @@ def fill_holes_3d(array):
         
         return holes_mask
 
+    print("Filling Holes...")
+    
     array = binarize(array)
     inv_array = invert_array(array)
 
@@ -3270,7 +3309,10 @@ class Network_3D:
         self._xy_scale = xy_scale
         self._z_scale = z_scale
 
-        self.save_scaling(directory)
+        try:
+            self.save_scaling(directory)
+        except:
+            pass
 
         if search is None and ignore_search_region == False:
             search = 0
@@ -3286,29 +3328,51 @@ class Network_3D:
         if other_nodes is not None:
             self.merge_nodes(other_nodes, label_nodes)
 
-        self.save_nodes(directory)
-        self.save_node_identities(directory)
+        try:
+            self.save_nodes(directory)
+        except:
+            pass
+        try:
+            self.save_node_identities(directory)
+        except:
+            pass
 
         if not ignore_search_region:
             self.calculate_search_region(search, GPU = GPU, fast_dil = fast_dil, GPU_downsample = GPU_downsample)
-            self._nodes = None
+            #self._nodes = None # I originally put this here to micromanage RAM a little bit (it writes it to disk so I wanted to purge it from mem briefly but now idt thats necessary and I'd rather give it flexibility when lacking write permissions)
             search = None
-            self.save_search_region(directory)
+            try:
+                self.save_search_region(directory)
+            except:
+                pass
 
         self.calculate_edges(edges, diledge = diledge, inners = inners, hash_inner_edges = hash_inners, search = search, remove_edgetrunk = remove_trunk, GPU = GPU, fast_dil = fast_dil, skeletonized = skeletonize)
         del edges
-        self.save_edges(directory)
+        try:
+            self.save_edges(directory)
+        except:
+            pass
 
         self.calculate_network(search = search, ignore_search_region = ignore_search_region)
-        self.save_network(directory)
+
+        try:
+            self.save_network(directory)
+        except:
+            pass
 
         if self._nodes is None:
             self.load_nodes(directory)
 
         self.calculate_node_centroids(down_factor)
-        self.save_node_centroids(directory)
+        try:
+            self.save_node_centroids(directory)
+        except:
+            pass
         self.calculate_edge_centroids(down_factor)
-        self.save_edge_centroids(directory)
+        try:
+            self.save_edge_centroids(directory)
+        except:
+            pass
 
 
     def draw_network(self, directory = None, down_factor = None, GPU = False):
@@ -3557,15 +3621,21 @@ class Network_3D:
         list1 = self._network_lists[0] #Get network lists to change
         list2 = self._network_lists[1]
         list3 = self._network_lists[2]
+        return1 = []
+        return2 = []
+        return3 = []
 
         for i in range(len(list1)):
             list1[i] = self.communities[list1[i]] #Set node at network list spot to its community instead
             list2[i] = self.communities[list2[i]]
-            if list1[i] == list2[i]: #If the  edge corresponding there joins different communities, it will not be set to 0
-                list3[i] = 0
+            if list1[i] != list2[i]: #Avoid self - self connections
+                return1.append(list1[i])
+                return2.append(list2[i])
+                return3.append(list3[i])
+
 
 
-        self.network_lists = [list1, list2, list3]
+        self.network_lists = [return1, return2, return3]
 
         if self._nodes is not None:
             self._nodes = update_array(self._nodes, inverted, targets = targets) #Set the array to match the new network