nettracer3d 0.5.2__tar.gz → 0.5.3__tar.gz

{nettracer3d-0.5.2/src/nettracer3d.egg-info → nettracer3d-0.5.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: nettracer3d
-Version: 0.5.2
+Version: 0.5.3
 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
@@ -26,6 +26,7 @@ Requires-Dist: tifffile==2023.7.18
 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
 Provides-Extra: cuda11
 Requires-Dist: cupy-cuda11x; extra == "cuda11"
 Provides-Extra: cuda12
@@ -42,3 +43,10 @@ for a video tutorial on using the GUI.
 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).
 
 NetTracer3D was developed by Liam McLaughlin while working under Dr. Sanjay Jain at Washington University School of Medicine.
+
+-- Version 0.5.3 updates --
+
+1. Improved calculate volumes method. Previous method used np.argwhere() to count voxels of labeled objects in parallel which was quite strenuous in large arrays with many objects. New method uses np.bincount() which uses optimized numpy C libraries to do the same.
+2. scipy.ndimage.find_objects() method was replaced as the method to find bounding boxes for objects when searching for object neighborhoods for the morphological proximity network and the edge < > node interaction quantification. This new version should be substantially faster in big arrays with many labels. (Depending on how well this improves performance, I may reimplement the secondary network search algorithm, as a side-option, which uses the same parallel-search within subarray strategies, as opposed to the primary network search algorithm that uses distance transforms).
+3. Image viewer window can now load in .nii format images, as well as .jpeg, .jpg, and .png. The nibabel library was added to the dependencies to enable .nii loading, although this is currently all it is used for (and the gui will still run without nibabel).
+4. Fixed bug regarding deleting edge objects. 

{nettracer3d-0.5.2 → nettracer3d-0.5.3}/README.md

@@ -6,4 +6,11 @@ for a video tutorial on using the GUI.
 
 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).
 
-NetTracer3D was developed by Liam McLaughlin while working under Dr. Sanjay Jain at Washington University School of Medicine.
+NetTracer3D was developed by Liam McLaughlin while working under Dr. Sanjay Jain at Washington University School of Medicine.
+
+-- Version 0.5.3 updates --
+
+1. Improved calculate volumes method. Previous method used np.argwhere() to count voxels of labeled objects in parallel which was quite strenuous in large arrays with many objects. New method uses np.bincount() which uses optimized numpy C libraries to do the same.
+2. scipy.ndimage.find_objects() method was replaced as the method to find bounding boxes for objects when searching for object neighborhoods for the morphological proximity network and the edge < > node interaction quantification. This new version should be substantially faster in big arrays with many labels. (Depending on how well this improves performance, I may reimplement the secondary network search algorithm, as a side-option, which uses the same parallel-search within subarray strategies, as opposed to the primary network search algorithm that uses distance transforms).
+3. Image viewer window can now load in .nii format images, as well as .jpeg, .jpg, and .png. The nibabel library was added to the dependencies to enable .nii loading, although this is currently all it is used for (and the gui will still run without nibabel).
+4. Fixed bug regarding deleting edge objects. 

{nettracer3d-0.5.2 → nettracer3d-0.5.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "nettracer3d"
-version = "0.5.2"
+version = "0.5.3"
 authors = [
   { name="Liam McLaughlin", email="mclaughlinliam99@gmail.com" },
 ]
@@ -20,7 +20,8 @@ dependencies = [
     "tifffile == 2023.7.18",
     "qtrangeslider == 0.1.5",
     "PyQt6 == 6.8.0",
-    "scikit-learn == 1.6.1"
+    "scikit-learn == 1.6.1",
+    "nibabel == 5.2.0"
 ]
 
 readme = "README.md"

{nettracer3d-0.5.2 → nettracer3d-0.5.3}/src/nettracer3d/morphology.py

@@ -7,46 +7,37 @@ from concurrent.futures import ThreadPoolExecutor, as_completed
 import tifffile
 from functools import partial
 import pandas as pd
+from scipy import ndimage
 
-def get_reslice_indices(args):
-    """Internal method used for the secondary algorithm that finds dimensions for subarrays around nodes"""
-
-    indices, dilate_xy, dilate_z, array_shape = args
-    try:
-        max_indices = np.amax(indices, axis = 0) #Get the max/min of each index.
-    except ValueError: #Return Nones if this error is encountered
+def get_reslice_indices(slice_obj, dilate_xy, dilate_z, array_shape):
+    """Convert slice object to padded indices accounting for dilation and boundaries"""
+    if slice_obj is None:
         return None, None, None
-    min_indices = np.amin(indices, axis = 0)
-
-    z_max, y_max, x_max = max_indices[0], max_indices[1], max_indices[2]
-
-    z_min, y_min, x_min = min_indices[0], min_indices[1], min_indices[2]
-
-    y_max = y_max + ((dilate_xy-1)/2) + 1 #Establish dimensions of intended subarray, expanding the max/min indices to include
-    y_min = y_min - ((dilate_xy-1)/2) - 1 #the future dilation space (by adding/subtracting half the dilation kernel for each axis)
-    x_max = x_max + ((dilate_xy-1)/2) + 1 #an additional index is added in each direction to make sure nothing is discluded.
+        
+    z_slice, y_slice, x_slice = slice_obj
+    
+    # Extract min/max from slices
+    z_min, z_max = z_slice.start, z_slice.stop - 1
+    y_min, y_max = y_slice.start, y_slice.stop - 1
+    x_min, x_max = x_slice.start, x_slice.stop - 1
+
+    # Add dilation padding
+    y_max = y_max + ((dilate_xy-1)/2) + 1
+    y_min = y_min - ((dilate_xy-1)/2) - 1
+    x_max = x_max + ((dilate_xy-1)/2) + 1
     x_min = x_min - ((dilate_xy-1)/2) - 1
     z_max = z_max + ((dilate_z-1)/2) + 1
     z_min = z_min - ((dilate_z-1)/2) - 1
 
-    if y_max > (array_shape[1] - 1): #Some if statements to make sure the subarray will not cause an indexerror
-        y_max = (array_shape[1] - 1)
-    if x_max > (array_shape[2] - 1):
-        x_max = (array_shape[2] - 1)
-    if z_max > (array_shape[0] - 1):
-        z_max = (array_shape[0] - 1)
-    if y_min < 0:
-        y_min = 0
-    if x_min < 0:
-        x_min = 0
-    if z_min < 0:
-        z_min = 0
-
-    y_vals = [y_min, y_max] #Return the subarray dimensions as lists
-    x_vals = [x_min, x_max]
-    z_vals = [z_min, z_max]
-
-    return z_vals, y_vals, x_vals
+    # Boundary checks
+    y_max = min(y_max, array_shape[1] - 1)
+    x_max = min(x_max, array_shape[2] - 1)
+    z_max = min(z_max, array_shape[0] - 1)
+    y_min = max(y_min, 0)
+    x_min = max(x_min, 0)
+    z_min = max(z_min, 0)
+
+    return [z_min, z_max], [y_min, y_max], [x_min, x_max]
 
 def reslice_3d_array(args):
     """Internal method used for the secondary algorithm to reslice subarrays around nodes."""
@@ -97,39 +88,46 @@ def _get_node_edge_dict(label_array, edge_array, label, dilate_xy, dilate_z, cor
     return args
 
 def process_label(args):
-    """Internal method used for the secondary algorithm to process a particular node."""
-    nodes, edges, label, dilate_xy, dilate_z, array_shape = args
+    """Modified to use pre-computed bounding boxes instead of argwhere"""
+    nodes, edges, label, dilate_xy, dilate_z, array_shape, bounding_boxes = args
     print(f"Processing node {label}")
-    indices = np.argwhere(nodes == label)
-    if len(indices) == 0:
+    
+    # Get the pre-computed bounding box for this label
+    slice_obj = bounding_boxes[label-1]  # -1 because label numbers start at 1
+    if slice_obj is None:
         return None, None, None
-    z_vals, y_vals, x_vals = get_reslice_indices((indices, dilate_xy, dilate_z, array_shape))
-    if z_vals is None: #If get_reslice_indices ran into a ValueError, nothing is returned.
+        
+    z_vals, y_vals, x_vals = get_reslice_indices(slice_obj, dilate_xy, dilate_z, array_shape)
+    if z_vals is None:
         return None, None, None
+        
     sub_nodes = reslice_3d_array((nodes, z_vals, y_vals, x_vals))
     sub_edges = reslice_3d_array((edges, z_vals, y_vals, x_vals))
     return label, sub_nodes, sub_edges
 
 
-def create_node_dictionary(nodes, edges, num_nodes, dilate_xy, dilate_z, cores = 0):
-    """Internal method used for the secondary algorithm to process nodes in parallel."""
-    # Initialize the dictionary to be returned
-    node_dict = {}
 
+def create_node_dictionary(nodes, edges, num_nodes, dilate_xy, dilate_z, cores=0):
+    """Modified to pre-compute all bounding boxes using find_objects"""
+    node_dict = {}
     array_shape = nodes.shape
-
+    
+    # Get all bounding boxes at once
+    bounding_boxes = ndimage.find_objects(nodes)
+    
     # Use ThreadPoolExecutor for parallel execution
     with ThreadPoolExecutor(max_workers=mp.cpu_count()) as executor:
-        # First parallel section to process labels
-        # List of arguments for each parallel task
-        args_list = [(nodes, edges, i, dilate_xy, dilate_z, array_shape) for i in range(1, num_nodes + 1)]
+        # Create args list with bounding_boxes included
+        args_list = [(nodes, edges, i, dilate_xy, dilate_z, array_shape, bounding_boxes) 
+                    for i in range(1, num_nodes + 1)]
 
         # Execute parallel tasks to process labels
         results = executor.map(process_label, args_list)
 
-        # Second parallel section to create dictionary entries
+        # Process results in parallel
         for label, sub_nodes, sub_edges in results:
-            executor.submit(create_dict_entry, node_dict, label, sub_nodes, sub_edges, dilate_xy, dilate_z, cores)
+            executor.submit(create_dict_entry, node_dict, label, sub_nodes, sub_edges, 
+                          dilate_xy, dilate_z, cores)
 
     return node_dict
 
@@ -193,10 +191,10 @@ def quantify_edge_node(nodes, edges, search = 0, xy_scale = 1, z_scale = 1, core
         return edge_quants
 
 
+
 def calculate_voxel_volumes(array, xy_scale=1, z_scale=1):
     """
-    Calculate voxel volumes for each uniquely labelled object in a 3D numpy array
-    using parallel processing.
+    Calculate voxel volumes for each uniquely labelled object in a 3D numpy array.
     
     Args:
         array: 3D numpy array where different objects are marked with different integer labels
@@ -207,69 +205,25 @@ def calculate_voxel_volumes(array, xy_scale=1, z_scale=1):
         Dictionary mapping object labels to their voxel volumes
     """
 
-    def process_volume_chunk(chunk_data, labels, xy_scale, z_scale):
-        """
-        Calculate volumes for a chunk of the array.
-        
-        Args:
-            chunk_data: 3D numpy array chunk
-            labels: Array of unique labels to process
-            xy_scale: Scale factor for x and y dimensions
-            z_scale: Scale factor for z dimension
-            
-        Returns:
-            Dictionary of label: volume pairs for this chunk
-        """
-        chunk_volumes = {}
-        for label in labels:
-            volume = np.count_nonzero(chunk_data == label) * (xy_scale**2) * z_scale
-            if volume > 0:  # Only include if object exists in this chunk
-                chunk_volumes[label] = volume
-        return chunk_volumes
-
-    # Get unique labels (excluding 0 which typically represents background)
     labels = np.unique(array)
     if len(labels) == 2:
         array, _ = nettracer.label_objects(array)
-        labels = np.unique(array)
-    labels = labels[labels != 0]  # Remove background label if present
-    
-    if len(labels) == 0:
-        return {}
-        
-    # Get number of CPU cores
-    num_cores = mp.cpu_count()
-    
-    # Calculate chunk size along y-axis
-    chunk_size = array.shape[1] // num_cores
-    if chunk_size < 1:
-        chunk_size = 1
-    
-    # Create chunks along y-axis
-    chunks = []
-    for i in range(0, array.shape[1], chunk_size):
-        end = min(i + chunk_size, array.shape[1])
-        chunks.append(array[:, i:end, :])
+
+    del labels
     
-    # Process chunks in parallel
-    process_func = partial(process_volume_chunk, 
-                         labels=labels, 
-                         xy_scale=xy_scale, 
-                         z_scale=z_scale)
+    # Get volumes using bincount
+    if 0 in array:
+        volumes = np.bincount(array.ravel())[1:]
+    else:
+        volumes = np.bincount(array.ravel())
+
     
-    volumes = {}
-    with ThreadPoolExecutor(max_workers=num_cores) as executor:
-        chunk_results = list(executor.map(process_func, chunks))
-        
-        # Combine results from all chunks
-        for chunk_volumes in chunk_results:
-            for label, volume in chunk_volumes.items():
-                if label in volumes:
-                    volumes[label] += volume
-                else:
-                    volumes[label] = volume
+    # Apply scaling
+    volumes = volumes * (xy_scale**2) * z_scale
     
-    return volumes
+    # Create dictionary with label:volume pairs
+    return {label: volume for label, volume in enumerate(volumes, start=1) if volume > 0}
+
 
 
 def search_neighbor_ids(nodes, targets, id_dict, neighborhood_dict, totals, search, xy_scale, z_scale, root):

{nettracer3d-0.5.2 → nettracer3d-0.5.3}/src/nettracer3d/nettracer.py

@@ -5,6 +5,7 @@ from scipy import ndimage
 from skimage import measure
 import cv2
 import concurrent.futures
+from concurrent.futures import ThreadPoolExecutor, as_completed
 from scipy.ndimage import zoom
 import multiprocessing as mp
 import os
@@ -23,7 +24,6 @@ except:
 from . import node_draw
 from . import network_draw
 from skimage import morphology as mpg
-from concurrent.futures import ThreadPoolExecutor, as_completed
 from . import smart_dilate
 from . import modularity
 from . import simple_network
@@ -37,45 +37,35 @@ from . import proximity
 #These next several methods relate to searching with 3D objects by dilating each one in a subarray around their neighborhood although I don't explicitly use this anywhere... can call them deprecated although I may want to use them later again so I have them still written out here.
 
 
-def get_reslice_indices(args):
-    """Internal method used for the secondary algorithm that finds dimensions for subarrays around nodes"""
-
-    indices, dilate_xy, dilate_z, array_shape = args
-    try:
-        max_indices = np.amax(indices, axis = 0) #Get the max/min of each index.
-    except ValueError: #Return Nones if this error is encountered
+def get_reslice_indices(slice_obj, dilate_xy, dilate_z, array_shape):
+    """Convert slice object to padded indices accounting for dilation and boundaries"""
+    if slice_obj is None:
         return None, None, None
-    min_indices = np.amin(indices, axis = 0)
-
-    z_max, y_max, x_max = max_indices[0], max_indices[1], max_indices[2]
-
-    z_min, y_min, x_min = min_indices[0], min_indices[1], min_indices[2]
-
-    y_max = y_max + ((dilate_xy-1)/2) + 1 #Establish dimensions of intended subarray, expanding the max/min indices to include
-    y_min = y_min - ((dilate_xy-1)/2) - 1 #the future dilation space (by adding/subtracting half the dilation kernel for each axis)
-    x_max = x_max + ((dilate_xy-1)/2) + 1 #an additional index is added in each direction to make sure nothing is discluded.
+        
+    z_slice, y_slice, x_slice = slice_obj
+    
+    # Extract min/max from slices
+    z_min, z_max = z_slice.start, z_slice.stop - 1
+    y_min, y_max = y_slice.start, y_slice.stop - 1
+    x_min, x_max = x_slice.start, x_slice.stop - 1
+
+    # Add dilation padding
+    y_max = y_max + ((dilate_xy-1)/2) + 1
+    y_min = y_min - ((dilate_xy-1)/2) - 1
+    x_max = x_max + ((dilate_xy-1)/2) + 1
     x_min = x_min - ((dilate_xy-1)/2) - 1
     z_max = z_max + ((dilate_z-1)/2) + 1
     z_min = z_min - ((dilate_z-1)/2) - 1
 
-    if y_max > (array_shape[1] - 1): #Some if statements to make sure the subarray will not cause an indexerror
-        y_max = (array_shape[1] - 1)
-    if x_max > (array_shape[2] - 1):
-        x_max = (array_shape[2] - 1)
-    if z_max > (array_shape[0] - 1):
-        z_max = (array_shape[0] - 1)
-    if y_min < 0:
-        y_min = 0
-    if x_min < 0:
-        x_min = 0
-    if z_min < 0:
-        z_min = 0
-
-    y_vals = [y_min, y_max] #Return the subarray dimensions as lists
-    x_vals = [x_min, x_max]
-    z_vals = [z_min, z_max]
-
-    return z_vals, y_vals, x_vals
+    # Boundary checks
+    y_max = min(y_max, array_shape[1] - 1)
+    x_max = min(x_max, array_shape[2] - 1)
+    z_max = min(z_max, array_shape[0] - 1)
+    y_min = max(y_min, 0)
+    x_min = max(x_min, 0)
+    z_min = max(z_min, 0)
+
+    return [z_min, z_max], [y_min, y_max], [x_min, x_max]
 
 def reslice_3d_array(args):
     """Internal method used for the secondary algorithm to reslice subarrays around nodes."""
@@ -110,37 +100,45 @@ def _get_node_edge_dict(label_array, edge_array, label, dilate_xy, dilate_z):
     return edge_array
 
 def process_label(args):
-    """Internal method used for the secondary algorithm to process a particular node."""
-    nodes, edges, label, dilate_xy, dilate_z, array_shape = args
+    """Modified to use pre-computed bounding boxes instead of argwhere"""
+    nodes, edges, label, dilate_xy, dilate_z, array_shape, bounding_boxes = args
     print(f"Processing node {label}")
-    indices = np.argwhere(nodes == label)
-    z_vals, y_vals, x_vals = get_reslice_indices((indices, dilate_xy, dilate_z, array_shape))
-    if z_vals is None: #If get_reslice_indices ran into a ValueError, nothing is returned.
+    
+    # Get the pre-computed bounding box for this label
+    slice_obj = bounding_boxes[label-1]  # -1 because label numbers start at 1
+    if slice_obj is None:
         return None, None, None
+        
+    z_vals, y_vals, x_vals = get_reslice_indices(slice_obj, dilate_xy, dilate_z, array_shape)
+    if z_vals is None:
+        return None, None, None
+        
     sub_nodes = reslice_3d_array((nodes, z_vals, y_vals, x_vals))
     sub_edges = reslice_3d_array((edges, z_vals, y_vals, x_vals))
     return label, sub_nodes, sub_edges
 
 
 def create_node_dictionary(nodes, edges, num_nodes, dilate_xy, dilate_z):
-    """Internal method used for the secondary algorithm to process nodes in parallel."""
-    # Initialize the dictionary to be returned
+    """Modified to pre-compute all bounding boxes using find_objects"""
     node_dict = {}
-
     array_shape = nodes.shape
-
+    
+    # Get all bounding boxes at once
+    bounding_boxes = ndimage.find_objects(nodes)
+    
     # Use ThreadPoolExecutor for parallel execution
     with ThreadPoolExecutor(max_workers=mp.cpu_count()) as executor:
-        # First parallel section to process labels
-        # List of arguments for each parallel task
-        args_list = [(nodes, edges, i, dilate_xy, dilate_z, array_shape) for i in range(1, num_nodes + 1)]
+        # Create args list with bounding_boxes included
+        args_list = [(nodes, edges, i, dilate_xy, dilate_z, array_shape, bounding_boxes) 
+                    for i in range(1, num_nodes + 1)]
 
         # Execute parallel tasks to process labels
         results = executor.map(process_label, args_list)
 
-        # Second parallel section to create dictionary entries
+        # Process results in parallel
         for label, sub_nodes, sub_edges in results:
-            executor.submit(create_dict_entry, node_dict, label, sub_nodes, sub_edges, dilate_xy, dilate_z)
+            executor.submit(create_dict_entry, node_dict, label, sub_nodes, sub_edges, 
+                          dilate_xy, dilate_z)
 
     return node_dict
 

{nettracer3d-0.5.2 → nettracer3d-0.5.3}/src/nettracer3d/nettracer_gui.py

@@ -1286,7 +1286,7 @@ class ImageViewerWindow(QMainWindow):
                 self.load_channel(1, my_network.edges, True)
             self.highlight_overlay = None
             self.update_display()
-            print("Network is not updated automatically, please recompute if necesarry. Identities are not automatically updated.")
+            print("Network is not updated automatically, please recompute if necessary. Identities are not automatically updated.")
             self.show_centroid_dialog()
 
         except Exception as e:
@@ -1315,7 +1315,7 @@ class ImageViewerWindow(QMainWindow):
 
 
             if len(self.clicked_values['edges']) > 0:
-                self.create_highlight_overlay(node_indices = self.clicked_values['edges'])
+                self.create_highlight_overlay(edge_indices = self.clicked_values['edges'])
                 mask = self.highlight_overlay == 0
                 my_network.edges = my_network.edges * mask
                 self.load_channel(1, my_network.edges, True)
@@ -2954,14 +2954,46 @@ class ImageViewerWindow(QMainWindow):
 
         try:
             if not data:  # For solo loading
-                import tifffile
                 filename, _ = QFileDialog.getOpenFileName(
                     self,
                     f"Load Channel {channel_index + 1}",
                     "",
-                    "TIFF Files (*.tif *.tiff)"
+                    "Image Files (*.tif *.tiff *.nii *.jpg *.jpeg *.png)"
                 )
-                self.channel_data[channel_index] = tifffile.imread(filename)
+                
+                if not filename:
+                    return
+                    
+                file_extension = filename.lower().split('.')[-1]
+                
+                try:
+                    if file_extension in ['tif', 'tiff']:
+                        import tifffile
+                        self.channel_data[channel_index] = tifffile.imread(filename)
+                        
+                    elif file_extension == 'nii':
+                        import nibabel as nib
+                        nii_img = nib.load(filename)
+                        # Get data and transpose to match TIFF orientation
+                        # If X needs to become Z, we move axis 2 (X) to position 0 (Z)
+                        data = nii_img.get_fdata()
+                        self.channel_data[channel_index] = np.transpose(data, (2, 1, 0))
+                        
+                    elif file_extension in ['jpg', 'jpeg', 'png']:
+                        from PIL import Image
+                        
+                        with Image.open(filename) as img:
+                            # Convert directly to numpy array, keeping color if present
+                            self.channel_data[channel_index] = np.array(img)
+                            
+                            # Debug info to check shape
+                            print(f"Loaded image shape: {self.channel_data[channel_index].shape}")
+                            
+                except ImportError as e:
+                    QMessageBox.critical(self, "Error", f"Required library not installed: {str(e)}")
+                except Exception as e:
+                    QMessageBox.critical(self, "Error", f"Error loading image: {str(e)}")
+
 
                 if len(self.channel_data[channel_index].shape) == 2:  # handle 2d data
                     self.channel_data[channel_index] = np.expand_dims(self.channel_data[channel_index], axis=0)
@@ -2983,10 +3015,13 @@ class ImageViewerWindow(QMainWindow):
             for i in range(4): #Try to ensure users don't load in different sized arrays
                 if self.channel_data[i] is None or i == channel_index or data:
                     if self.highlight_overlay is not None: #Make sure highlight overlay is always the same shape as new images
-                        if self.channel_data[i].shape[:3] != self.highlight_overlay.shape:
-                            self.resizing = True
-                            reset_resize = True
-                            self.highlight_overlay = None
+                        try:
+                            if self.channel_data[i].shape[:3] != self.highlight_overlay.shape:
+                                self.resizing = True
+                                reset_resize = True
+                                self.highlight_overlay = None
+                        except:
+                            pass
                     continue
                 else:
                     old_shape = self.channel_data[i].shape[:3] #Ask user to resize images that are shaped differently
@@ -3061,6 +3096,8 @@ class ImageViewerWindow(QMainWindow):
 
                 
         except Exception as e:
+            import traceback
+            print(traceback.format_exc())
             if not data:
                 from PyQt6.QtWidgets import QMessageBox
                 QMessageBox.critical(
@@ -6916,11 +6953,16 @@ class WatershedDialog(QDialog):
         self.directory.setPlaceholderText("Leave empty for None")
         layout.addRow("Output Directory:", self.directory)
 
-        active_shape = self.parent().channel_data[self.parent().active_channel].shape[0]
+        try:
 
-        if active_shape == 1:
-            self.default = 0.2
-        else:
+            active_shape = self.parent().channel_data[self.parent().active_channel].shape[0]
+
+            if active_shape == 1:
+                self.default = 0.2
+            else:
+                self.default = 0.05
+
+        except:
             self.default = 0.05
 
         
@@ -6949,6 +6991,9 @@ class WatershedDialog(QDialog):
         self.predownsample2.setPlaceholderText("Leave empty for None")
         layout.addRow("Smart Label GPU Downsample:", self.predownsample2)
         
+        layout.addRow("Note:", QLabel(f"If the optimal proportion watershed output is still labeling spatially seperated objects with the same label, try right placing the result in nodes or edges\nthen right click the image and choose 'select all', followed by right clicking and 'selection' -> 'split non-touching labels'."))
+
+
         # Add Run button
         run_button = QPushButton("Run Watershed")
         run_button.clicked.connect(self.run_watershed)

{nettracer3d-0.5.2 → nettracer3d-0.5.3}/src/nettracer3d/proximity.py

@@ -3,6 +3,7 @@ from . import nettracer
 import multiprocessing as mp
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from scipy.spatial import KDTree
+from scipy import ndimage
 import concurrent.futures
 import multiprocessing as mp
 import pandas as pd
@@ -11,41 +12,35 @@ from typing import Dict, Union, Tuple, List, Optional
 
 # Related to morphological border searching:
 
-def get_reslice_indices(args):
-    """Internal method used for the secondary algorithm that finds dimensions for subarrays around nodes"""
-
-    indices, dilate_xy, dilate_z, array_shape = args
-    try:
-        max_indices = np.amax(indices, axis = 0) #Get the max/min of each index.
-    except ValueError: #Return Nones if this error is encountered
+def get_reslice_indices(slice_obj, dilate_xy, dilate_z, array_shape):
+    """Convert slice object to padded indices accounting for dilation and boundaries"""
+    if slice_obj is None:
         return None, None, None
-    min_indices = np.amin(indices, axis = 0)
-
-    z_max, y_max, x_max = max_indices[0], max_indices[1], max_indices[2]
-
-    z_min, y_min, x_min = min_indices[0], min_indices[1], min_indices[2]
-
-    y_max = y_max + ((dilate_xy-1)/2) + 1 #Establish dimensions of intended subarray, expanding the max/min indices to include
-    y_min = y_min - ((dilate_xy-1)/2) - 1 #the future dilation space (by adding/subtracting half the dilation kernel for each axis)
-    x_max = x_max + ((dilate_xy-1)/2) + 1 #an additional index is added in each direction to make sure nothing is discluded.
+        
+    z_slice, y_slice, x_slice = slice_obj
+    
+    # Extract min/max from slices
+    z_min, z_max = z_slice.start, z_slice.stop - 1
+    y_min, y_max = y_slice.start, y_slice.stop - 1
+    x_min, x_max = x_slice.start, x_slice.stop - 1
+
+    # Add dilation padding
+    y_max = y_max + ((dilate_xy-1)/2) + 1
+    y_min = y_min - ((dilate_xy-1)/2) - 1
+    x_max = x_max + ((dilate_xy-1)/2) + 1
     x_min = x_min - ((dilate_xy-1)/2) - 1
     z_max = z_max + ((dilate_z-1)/2) + 1
     z_min = z_min - ((dilate_z-1)/2) - 1
 
-    if y_max > (array_shape[1] - 1): #Some if statements to make sure the subarray will not cause an indexerror
-        y_max = (array_shape[1] - 1)
-    if x_max > (array_shape[2] - 1):
-        x_max = (array_shape[2] - 1)
-    if z_max > (array_shape[0] - 1):
-        z_max = (array_shape[0] - 1)
-    if y_min < 0:
-        y_min = 0
-    if x_min < 0:
-        x_min = 0
-    if z_min < 0:
-        z_min = 0
-
-    y_vals = [y_min, y_max] #Return the subarray dimensions as lists
+    # Boundary checks
+    y_max = min(y_max, array_shape[1] - 1)
+    x_max = min(x_max, array_shape[2] - 1)
+    z_max = min(z_max, array_shape[0] - 1)
+    y_min = max(y_min, 0)
+    x_min = max(x_min, 0)
+    z_min = max(z_min, 0)
+
+    y_vals = [y_min, y_max]
     x_vals = [x_min, x_max]
     z_vals = [z_min, z_max]
 
@@ -85,40 +80,43 @@ def _get_node_node_dict(label_array, label, dilate_xy, dilate_z):
     return label_array
 
 def process_label(args):
-    """Internal method used for the secondary algorithm to process a particular node."""
-    nodes, label, dilate_xy, dilate_z, array_shape = args
+    """Modified to use pre-computed bounding boxes instead of argwhere"""
+    nodes, label, dilate_xy, dilate_z, array_shape, bounding_boxes = args
     print(f"Processing node {label}")
-    indices = np.argwhere(nodes == label)
-    if len(indices) == 0:
+    
+    # Get the pre-computed bounding box for this label
+    slice_obj = bounding_boxes[label-1]  # -1 because label numbers start at 1
+    if slice_obj is None:
         return None, None
-    z_vals, y_vals, x_vals = get_reslice_indices((indices, dilate_xy, dilate_z, array_shape))
-    if z_vals is None: #If get_reslice_indices ran into a ValueError, nothing is returned.
+        
+    z_vals, y_vals, x_vals = get_reslice_indices(slice_obj, dilate_xy, dilate_z, array_shape)
+    if z_vals is None:
         return None, None
+        
     sub_nodes = reslice_3d_array((nodes, z_vals, y_vals, x_vals))
     return label, sub_nodes
 
 
-def create_node_dictionary(nodes, num_nodes, dilate_xy, dilate_z, targets = None):
-    """Internal method used for the secondary algorithm to process nodes in parallel."""
-    # Initialize the dictionary to be returned
+def create_node_dictionary(nodes, num_nodes, dilate_xy, dilate_z, targets=None):
+    """Modified to pre-compute all bounding boxes using find_objects"""
     node_dict = {}
-
     array_shape = nodes.shape
-
-
+    
+    # Get all bounding boxes at once
+    bounding_boxes = ndimage.find_objects(nodes)
+    
     # Use ThreadPoolExecutor for parallel execution
     with ThreadPoolExecutor(max_workers=mp.cpu_count()) as executor:
-        # First parallel section to process labels
-        # List of arguments for each parallel task
-        args_list = [(nodes, i, dilate_xy, dilate_z, array_shape) for i in range(1, num_nodes + 1)]
+        # Create args list with bounding_boxes included
+        args_list = [(nodes, i, dilate_xy, dilate_z, array_shape, bounding_boxes) 
+                    for i in range(1, num_nodes + 1)]
 
         if targets is not None:
             args_list = [tup for tup in args_list if tup[1] in targets]
 
         results = executor.map(process_label, args_list)
 
-
-        # Second parallel section to create dictionary entries
+        # Process results in parallel
         for label, sub_nodes in results:
             executor.submit(create_dict_entry, node_dict, label, sub_nodes, dilate_xy, dilate_z)
 

{nettracer3d-0.5.2 → nettracer3d-0.5.3/src/nettracer3d.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: nettracer3d
-Version: 0.5.2
+Version: 0.5.3
 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
@@ -26,6 +26,7 @@ Requires-Dist: tifffile==2023.7.18
 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
 Provides-Extra: cuda11
 Requires-Dist: cupy-cuda11x; extra == "cuda11"
 Provides-Extra: cuda12
@@ -42,3 +43,10 @@ for a video tutorial on using the GUI.
 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).
 
 NetTracer3D was developed by Liam McLaughlin while working under Dr. Sanjay Jain at Washington University School of Medicine.
+
+-- Version 0.5.3 updates --
+
+1. Improved calculate volumes method. Previous method used np.argwhere() to count voxels of labeled objects in parallel which was quite strenuous in large arrays with many objects. New method uses np.bincount() which uses optimized numpy C libraries to do the same.
+2. scipy.ndimage.find_objects() method was replaced as the method to find bounding boxes for objects when searching for object neighborhoods for the morphological proximity network and the edge < > node interaction quantification. This new version should be substantially faster in big arrays with many labels. (Depending on how well this improves performance, I may reimplement the secondary network search algorithm, as a side-option, which uses the same parallel-search within subarray strategies, as opposed to the primary network search algorithm that uses distance transforms).
+3. Image viewer window can now load in .nii format images, as well as .jpeg, .jpg, and .png. The nibabel library was added to the dependencies to enable .nii loading, although this is currently all it is used for (and the gui will still run without nibabel).
+4. Fixed bug regarding deleting edge objects. 

{nettracer3d-0.5.2 → nettracer3d-0.5.3}/src/nettracer3d.egg-info/requires.txt

@@ -13,6 +13,7 @@ tifffile==2023.7.18
 qtrangeslider==0.1.5
 PyQt6==6.8.0
 scikit-learn==1.6.1
+nibabel==5.2.0
 
 [CUDA11]
 cupy-cuda11x