nettracer3d 0.6.4__tar.gz → 0.6.5__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nettracer3d
-Version: 0.6.4
+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,15 +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.4 updates --
+-- Version 0.6.5 updates --
 
-1. Fixed bug with tabulated data in top right having a right click window corresponding to the bottom left.
+1. Added new method for obtaining radii of labeled objects (analyze -> stats -> calculate radii)
 
-2. Fixed bug when converting communities to nodes that let the same community connect to itself in the new network.
+2. Updated functionality of split nontouching labels function to handle situations where said label is touching other labeled objects in space.
 
-3. Removed attempted trendline fitting from degree distribution
+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. 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
+4. Minor bug fixes/improvements.

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

@@ -8,15 +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.4 updates --
+-- Version 0.6.5 updates --
 
-1. Fixed bug with tabulated data in top right having a right click window corresponding to the bottom left.
+1. Added new method for obtaining radii of labeled objects (analyze -> stats -> calculate radii)
 
-2. Fixed bug when converting communities to nodes that let the same community connect to itself in the new network.
+2. Updated functionality of split nontouching labels function to handle situations where said label is touching other labeled objects in space.
 
-3. Removed attempted trendline fitting from degree distribution
+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. 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
+4. Minor bug fixes/improvements.

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

@@ -1,10 +1,11 @@
 [project]
 name = "nettracer3d"
-version = "0.6.4"
+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.4 → 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.4 → 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"""
 

{nettracer3d-0.6.4 → nettracer3d-0.6.5}/src/nettracer3d/nettracer_gui.py

@@ -1399,55 +1399,128 @@ class ImageViewerWindow(QMainWindow):
             print(f"An error has occured: {e}")
 
     def handle_seperate(self):
-
+        print("Note: I search each selected label one at a time and then split it with the ndimage.label method which uses C but still has to search the entire array each time, I may be a very slow with big operations :)")
         try:
-
+            # Handle nodes
             if len(self.clicked_values['nodes']) > 0:
-                self.create_highlight_overlay(node_indices = self.clicked_values['nodes'])
-                max_val = np.max(my_network.nodes)
-                self.highlight_overlay, num = n3d.label_objects(self.highlight_overlay)
-
-                node_bools = self.highlight_overlay != 0
-                new_max = num + max_val
-                self.highlight_overlay = self.highlight_overlay + max_val
-                self.highlight_overlay = self.highlight_overlay * node_bools
-                if new_max < 256:
-                    dtype = np.uint8
-                elif new_max < 65536:
-                    dtype = np.uint16
-                else:
-                    dtype = np.uint32
-
-                self.highlight_overlay = self.highlight_overlay.astype(dtype)
-                my_network.nodes = my_network.nodes + self.highlight_overlay
+                self.create_highlight_overlay(node_indices=self.clicked_values['nodes'])
+                max_val = np.max(my_network.nodes) + 1
+                
+                # Create a boolean mask for highlighted values
+                self.highlight_overlay = self.highlight_overlay != 0
+                
+                # Create array with just the highlighted values
+                highlighted_nodes = self.highlight_overlay * my_network.nodes
+                
+                # Get unique values in the highlighted regions (excluding 0)
+                vals = list(np.unique(highlighted_nodes))
+                if vals[0] == 0:
+                    del vals[0]
+                    
+                # Process each value separately
+                for val in vals:
+                    # Create a mask for this value
+                    val_mask = my_network.nodes == val
+                    
+                    # Create an array without this value
+                    temp = my_network.nodes - (val_mask * val)
+                    
+                    # Label the connected components for this value
+                    labeled_mask, num_components = n3d.label_objects(val_mask)
+                    
+                    if num_components > 1:
+                        # Set appropriate dtype based on max value
+                        if max_val + num_components < 256:
+                            dtype = np.uint8
+                        elif max_val + num_components < 65536:
+                            dtype = np.uint16
+                            labeled_mask = labeled_mask.astype(dtype)
+                            temp = temp.astype(dtype)
+                        else:
+                            dtype = np.uint32
+                            labeled_mask = labeled_mask.astype(dtype)
+                            temp = temp.astype(dtype)
+                        
+                        # Add new labels to the temporary array
+                        mask_nonzero = labeled_mask != 0
+                        labeled_mask = labeled_mask + max_val - 1  # -1 because we'll restore the first component
+                        labeled_mask = labeled_mask * mask_nonzero
+                        
+                        # Restore original value for first component
+                        first_component = labeled_mask == max_val
+                        labeled_mask = labeled_mask - (first_component * (max_val - val))
+                        
+                        # Add labeled components back to the array
+                        my_network.nodes = temp + labeled_mask
+                        
+                        # Update max value for next iteration
+                        max_val += num_components - 1  # -1 because we kept one original label
+                
                 self.load_channel(0, my_network.nodes, True)
-
+            
+            # Handle edges
             if len(self.clicked_values['edges']) > 0:
-                self.create_highlight_overlay(edge_indices = self.clicked_values['edges'])
-                max_val = np.max(my_network.edges)
-                self.highlight_overlay, num = n3d.label_objects(self.highlight_overlay)
-                node_bools = self.highlight_overlay != 0
-                new_max = num + max_val
-
-                self.highlight_overlay = self.highlight_overlay + max_val
-                self.highlight_overlay = self.highlight_overlay * node_bools
-                if new_max < 256:
-                    dtype = np.uint8
-                elif new_max < 65536:
-                    dtype = np.uint16
-                else:
-                    dtype = np.uint32
-
-                self.highlight_overlay = self.highlight_overlay.astype(dtype)
-                my_network.edges = my_network.edges + self.highlight_overlay
+                self.create_highlight_overlay(edge_indices=self.clicked_values['edges'])
+                max_val = np.max(my_network.edges) + 1
+                
+                # Create a boolean mask for highlighted values
+                self.highlight_overlay = self.highlight_overlay != 0
+                
+                # Create array with just the highlighted values
+                highlighted_edges = self.highlight_overlay * my_network.edges
+                
+                # Get unique values in the highlighted regions (excluding 0)
+                vals = list(np.unique(highlighted_edges))
+                if vals[0] == 0:
+                    del vals[0]
+                    
+                # Process each value separately
+                for val in vals:
+                    # Create a mask for this value
+                    val_mask = my_network.edges == val
+                    
+                    # Create an array without this value
+                    temp = my_network.edges - (val_mask * val)
+                    
+                    # Label the connected components for this value
+                    labeled_mask, num_components = n3d.label_objects(val_mask)
+                    
+                    if num_components > 1:
+                        # Set appropriate dtype based on max value
+                        if max_val + num_components < 256:
+                            dtype = np.uint8
+                        elif max_val + num_components < 65536:
+                            dtype = np.uint16
+                            labeled_mask = labeled_mask.astype(dtype)
+                            temp = temp.astype(dtype)
+                        else:
+                            dtype = np.uint32
+                            labeled_mask = labeled_mask.astype(dtype)
+                            temp = temp.astype(dtype)
+                        
+                        # Add new labels to the temporary array
+                        mask_nonzero = labeled_mask != 0
+                        labeled_mask = labeled_mask + max_val - 1  # -1 because we'll restore the first component
+                        labeled_mask = labeled_mask * mask_nonzero
+                        
+                        # Restore original value for first component
+                        first_component = labeled_mask == max_val
+                        labeled_mask = labeled_mask - (first_component * (max_val - val))
+                        
+                        # Add labeled components back to the array
+                        my_network.edges = temp + labeled_mask
+                        
+                        # Update max value for next iteration
+                        max_val += num_components - 1  # -1 because we kept one original label
+                
                 self.load_channel(1, my_network.edges, True)
+                
             self.highlight_overlay = None
             self.update_display()
             print("Network is not updated automatically, please recompute if necessary. Identities are not automatically updated.")
             self.show_centroid_dialog()
-
         except Exception as e:
-            print(f"Error seperating: {e}")
+            print(f"Error separating: {e}")
 
 
 
@@ -2392,6 +2465,8 @@ class ImageViewerWindow(QMainWindow):
         random_action.triggered.connect(self.show_random_dialog)
         vol_action = stats_menu.addAction("Calculate Volumes")
         vol_action.triggered.connect(self.volumes)
+        rad_action = stats_menu.addAction("Calculate Radii")
+        rad_action.triggered.connect(self.show_rad_dialog)
         inter_action = stats_menu.addAction("Calculate Node < > Edge Interaction")
         inter_action.triggered.connect(self.show_interaction_dialog)
         overlay_menu = analysis_menu.addMenu("Data/Overlays")
@@ -3312,8 +3387,7 @@ class ImageViewerWindow(QMainWindow):
 
                 
         except Exception as e:
-            import traceback
-            print(traceback.format_exc())
+
             if not data:
                 from PyQt6.QtWidgets import QMessageBox
                 QMessageBox.critical(
@@ -3825,6 +3899,9 @@ class ImageViewerWindow(QMainWindow):
         dialog = RandomDialog(self)
         dialog.exec()
 
+    def show_rad_dialog(self):
+        dialog = RadDialog(self)
+        dialog.exec()
 
     def show_interaction_dialog(self):
         dialog = InteractionDialog(self)
@@ -4241,16 +4318,21 @@ class CustomTableView(QTableView):
                         self.parent.clicked_values['edges'] = []
                         self.parent.clicked_values['nodes'].append(value)
                         
-                        # Highlight the value in both tables if it exists
-                        self.highlight_value_in_table(self.parent.network_table, value, column)
-                        self.highlight_value_in_table(self.parent.selection_table, value, column)
+                        try:
+                            # Highlight the value in both tables if it exists
+                            self.highlight_value_in_table(self.parent.network_table, value, column)
+                            self.highlight_value_in_table(self.parent.selection_table, value, column)
+                        except:
+                            pass
                     else:
                         print(f"Node {value} not found in centroids dictionary")
                         
                 elif column == 2:  # Third column is edges
+                    if my_network.edge_centroids is None:
+                        self.parent.show_centroid_dialog()
+
                     if value in my_network.edge_centroids:
-                        if my_network.edge_centroids is None:
-                            self.parent.show_centroid_dialog()
+
                         # Get centroid coordinates (Z, Y, X)
                         centroid = my_network.edge_centroids[value]
                         # Set the active channel to edges (1)
@@ -4271,9 +4353,12 @@ class CustomTableView(QTableView):
                         self.parent.clicked_values['edges'] = []
                         self.parent.clicked_values['edges'].append(value)
 
-                        # Highlight the value in both tables if it exists
-                        self.highlight_value_in_table(self.parent.network_table, value, column)
-                        self.highlight_value_in_table(self.parent.selection_table, value, column)
+                        try:
+                            # Highlight the value in both tables if it exists
+                            self.highlight_value_in_table(self.parent.network_table, value, column)
+                            self.highlight_value_in_table(self.parent.selection_table, value, column)
+                        except:
+                            pass
                     else:
                         print(f"Edge {value} not found in centroids dictionary")
             else: #If highlighting paired elements
@@ -4905,6 +4990,52 @@ class ArbitraryDialog(QDialog):
                     continue
         
         return processed_values
+
+    def handle_find_action(self, mode, value):
+        """Handle the Find action."""
+                
+        # Determine if we're looking for a node or edge 
+        if mode == 0:
+
+            if my_network.node_centroids is None:
+                self.parent().show_centroid_dialog()
+
+            if value in my_network.node_centroids:
+                # Get centroid coordinates (Z, Y, X)
+                centroid = my_network.node_centroids[value]
+                # Set the active channel to nodes (0)
+                self.parent().set_active_channel(0)
+                # Toggle on the nodes channel if it's not already visible
+                if not self.parent().channel_visible[0]:
+                    self.parent().channel_buttons[0].setChecked(True)
+                    self.parent().toggle_channel(0)
+                # Navigate to the Z-slice
+                self.parent().slice_slider.setValue(int(centroid[0]))
+                print(f"Found node {value} at Z-slice {centroid[0]}")
+                
+            else:
+                print(f"Node {value} not found in centroids dictionary")
+                
+        else:  # edges
+            if my_network.edge_centroids is None:
+                self.parent().show_centroid_dialog()
+
+            if value in my_network.edge_centroids:
+
+                # Get centroid coordinates (Z, Y, X)
+                centroid = my_network.edge_centroids[value]
+                # Set the active channel to edges (1)
+                self.parent().set_active_channel(1)
+                # Toggle on the edges channel if it's not already visible
+                if not self.parent().channel_visible[1]:
+                    self.parent().channel_buttons[1].setChecked(True)
+                    self.parent().toggle_channel(1)
+                # Navigate to the Z-slice
+                self.parent().slice_slider.setValue(int(centroid[0]))
+                print(f"Found edge {value} at Z-slice {centroid[0]}")
+
+            else:
+                print(f"Edge {value} not found in centroids dictionary")
     
     def process_selections(self):
         """Process the selection and deselection inputs."""
@@ -4940,11 +5071,21 @@ class ArbitraryDialog(QDialog):
                 except:
                     pass #Forgive mistakes
 
-            for item in select_list:
-                try:
-                    self.parent().clicked_values[mode].append(item)
-                except:
-                    pass
+            select_list.reverse()
+
+            self.parent().clicked_values[mode].extend(select_list)
+
+            select_list.reverse()
+
+            try:
+                if mode == 'nodes':
+                    self.handle_find_action(0, select_list[0])
+                    self.parent().handle_info(sort = 'node')
+                elif mode == 'edges':
+                    self.handle_find_action(1, select_list[0])
+                    self.parent().handle_info(sort = 'edge')
+            except:
+                pass
 
             self.parent().clicked_values[mode] = list(set(self.parent().clicked_values[mode]))
 
@@ -4964,6 +5105,8 @@ class ArbitraryDialog(QDialog):
             
         except Exception as e:
             QMessageBox.critical(self, "Error", f"Error processing selections: {str(e)}")
+            import traceback
+            print(traceback.format_exc())
 
 class Show3dDialog(QDialog):
     def __init__(self, parent=None):
@@ -5257,8 +5400,10 @@ class ShuffleDialog(QDialog):
 
             try:
                 if accepted_mode == 4:
-
-                    self.parent().highlight_overlay = n3d.binarize(target_data)
+                    try:
+                        self.parent().highlight_overlay = n3d.binarize(target_data)
+                    except:
+                        self.parent().highlight_overay = None
                 else:
                     self.parent().load_channel(accepted_mode, channel_data = target_data, data = True)
             except:
@@ -5271,11 +5416,12 @@ class ShuffleDialog(QDialog):
                         self.parent().highlight_overlay = n3d.binarize(active_data)
                     except:
                         self.parent().highlight_overlay = None
+                else:
+                    self.parent().load_channel(accepted_target, channel_data = active_data, data = True)
             except:
                 pass
 
-            else:
-                self.parent().load_channel(accepted_target, channel_data = active_data, data = True)
+
 
 
             self.parent().update_display()
@@ -5604,6 +5750,50 @@ class RandomDialog(QDialog):
 
         self.accept()
 
+class RadDialog(QDialog):
+
+    def __init__(self, parent=None):
+
+        super().__init__(parent)
+        self.setWindowTitle("Obtain Radii of Active Image? (Returns Largest Radius for Each Labeled Object)")
+        self.setModal(True)
+
+        layout = QFormLayout(self)
+
+        # GPU checkbox (default False)
+        self.GPU = QPushButton("GPU")
+        self.GPU.setCheckable(True)
+        self.GPU.setChecked(False)
+        layout.addRow("Use GPU:", self.GPU)
+
+
+        # Add Run button
+        run_button = QPushButton("Calculate")
+        run_button.clicked.connect(self.rads)
+        layout.addWidget(run_button)
+
+    def rads(self):
+
+        try:
+            GPU = self.GPU.isChecked()
+
+            active_data = self.parent().channel_data[self.parent().active_channel]
+
+            radii = n3d.estimate_object_radii(active_data, gpu=GPU)
+
+            for key, val in radii.items():
+
+                radii[key] = [val, val * (my_network.xy_scale**2) * my_network.z_scale]
+
+            self.parent().format_for_upperright_table(radii, title = '~Radii of Objects', metric='ObjectID', value=['Largest Radius (Voxels)', 'Largest Radius (Scaled)'])
+
+            self.accept()
+
+        except Exception as e:
+            print(f"Error: {e}")
+
+
+
 
 
 class InteractionDialog(QDialog):
@@ -6318,7 +6508,7 @@ class SLabelDialog(QDialog):
         # GPU checkbox (default True)
         self.GPU = QPushButton("GPU")
         self.GPU.setCheckable(True)
-        self.GPU.setChecked(True)
+        self.GPU.setChecked(False)
         layout.addRow("Use GPU:", self.GPU)
 
         self.down_factor = QLineEdit("")
@@ -7387,7 +7577,7 @@ class SmartDilateDialog(QDialog):
         # GPU checkbox (default True)
         self.GPU = QPushButton("GPU")
         self.GPU.setCheckable(True)
-        self.GPU.setChecked(True)
+        self.GPU.setChecked(False)
         layout.addRow("Use GPU:", self.GPU)
 
         self.down_factor = QLineEdit("")
@@ -7889,7 +8079,7 @@ class WatershedDialog(QDialog):
         # GPU checkbox (default True)
         self.gpu = QPushButton("GPU")
         self.gpu.setCheckable(True)
-        self.gpu.setChecked(True)
+        self.gpu.setChecked(False)
         layout.addRow("Use GPU:", self.gpu)
         
         # Smallest radius (empty by default)
@@ -8758,15 +8948,23 @@ class CentroidDialog(QDialog):
                 my_network.save_edge_centroids(directory = directory)
 
             elif chan == 0:
-                my_network.calculate_node_centroids(
-                    down_factor = downsample
-                )
-                my_network.save_node_centroids(directory = directory)
+                try:
+                    my_network.calculate_node_centroids(
+                        down_factor = downsample
+                    )
+                    my_network.save_node_centroids(directory = directory)
+                except:
+                    pass
 
-                my_network.calculate_edge_centroids(
-                    down_factor = downsample
-                )
-                my_network.save_edge_centroids(directory = directory)
+                try:
+
+                    my_network.calculate_edge_centroids(
+                        down_factor = downsample
+                    )
+                    my_network.save_edge_centroids(directory = directory)
+
+                except:
+                    pass
 
             if hasattr(my_network, 'node_centroids') and my_network.node_centroids is not None:
                 try:

{nettracer3d-0.6.4 → nettracer3d-0.6.5}/src/nettracer3d/smart_dilate.py

@@ -9,11 +9,9 @@ import math
 import re
 from . import nettracer
 import multiprocessing as mp
-from skimage.feature import peak_local_max
 try:
     import cupy as cp
     import cupyx.scipy.ndimage as cpx
-    from cupyx.scipy.ndimage import maximum_filter
 except:
     pass
 
@@ -467,7 +465,7 @@ def compute_distance_transform_distance_GPU(nodes):
     nodes_cp = cp.asarray(nodes)
     
     # Compute the distance transform on the GPU
-    distance, _ = cpx.distance_transform_edt(nodes_cp, return_indices=True)
+    distance = cpx.distance_transform_edt(nodes_cp)
     
     # Convert results back to numpy arrays
     distance = cp.asnumpy(distance)
@@ -485,7 +483,7 @@ def compute_distance_transform_distance(nodes):
         nodes = np.squeeze(nodes)  # Convert to 2D for processing
 
     # Fallback to CPU if there's an issue with GPU computation
-    distance, _ = distance_transform_edt(nodes, return_indices=True)
+    distance = distance_transform_edt(nodes)
     if is_pseudo_3d:
         np.expand_dims(distance, axis = 0)
     return distance
@@ -519,33 +517,6 @@ def gaussian(search_region, GPU = True):
         blurred_search = gaussian_filter(search_region, sigma = 1)
         return blurred_search
 
-def get_local_maxima(distance, image):
-    try:
-        if cp.cuda.runtime.getDeviceCount() > 0:
-            print("GPU detected. Using CuPy for local maxima.")
-
-            distance = cp.asarray(distance)
-
-            # Perform a maximum filter to find local maxima
-            footprint = cp.ones((3, 3, 3))  # Define your footprint
-            filtered = maximum_filter(distance, footprint=footprint)
-
-            # Find local maxima by comparing with the original array
-            local_max = (distance == filtered)  # Peaks are where the filtered result matches the original
-
-            # Extract coordinates of local maxima
-            coords = cp.argwhere(local_max)
-            coords = cp.asnumpy(coords)
-
-            return coords
-        else:
-            print("No GPU detected. Using CPU for local maxima.")
-            coords = peak_local_max(distance, footprint=np.ones((3, 3, 3)), labels=image)
-            return coords
-    except Exception as e:
-        print("GPU operation failed or did not detect GPU (cupy must be installed with a CUDA toolkit set up...). Computing CPU local maxima instead.")
-        coords = peak_local_max(distance, footprint=np.ones((3, 3, 3)), labels=image)
-        return coords
 
 
 def catch_memory(e):

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nettracer3d
-Version: 0.6.4
+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,15 +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.4 updates --
+-- Version 0.6.5 updates --
 
-1. Fixed bug with tabulated data in top right having a right click window corresponding to the bottom left.
+1. Added new method for obtaining radii of labeled objects (analyze -> stats -> calculate radii)
 
-2. Fixed bug when converting communities to nodes that let the same community connect to itself in the new network.
+2. Updated functionality of split nontouching labels function to handle situations where said label is touching other labeled objects in space.
 
-3. Removed attempted trendline fitting from degree distribution
+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. 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
+4. Minor bug fixes/improvements.

{nettracer3d-0.6.4 → nettracer3d-0.6.5}/src/nettracer3d.egg-info/requires.txt

@@ -14,6 +14,7 @@ qtrangeslider==0.1.5
 PyQt6==6.8.0
 scikit-learn==1.6.1
 nibabel==5.2.0
+setuptools>=65.0.0
 
 [CUDA11]
 cupy-cuda11x