nettracer3d 0.6.3__py3-none-any.whl → 0.6.5__py3-none-any.whl

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/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

nettracer3d/nettracer_gui.py

@@ -325,7 +325,7 @@ class ImageViewerWindow(QMainWindow):
         self.tabbed_data = TabbedDataWidget(self)
         right_layout.addWidget(self.tabbed_data)
         # Initialize data_table property to None - it will be set when tabs are added
-        self.data_table = None
+        self.data_table = []
         
         # Create table control panel
         table_control = QWidget()
@@ -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}")
 
 
 
@@ -1814,6 +1887,7 @@ class ImageViewerWindow(QMainWindow):
                 new_xlim = [xdata - x_range, xdata + x_range]
                 new_ylim = [ydata - y_range, ydata + y_range]
                 
+                
                 if (new_xlim[0] <= self.original_xlim[0] or 
                     new_xlim[1] >= self.original_xlim[1] or
                     new_ylim[0] <= self.original_ylim[0] or
@@ -2391,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")
@@ -3228,6 +3304,9 @@ class ImageViewerWindow(QMainWindow):
                                 self.highlight_overlay = None
                         except:
                             pass
+                    if not data:
+                        self.original_xlim = None
+                        self.original_ylim = None
                     continue
                 else:
                     old_shape = self.channel_data[i].shape[:3] #Ask user to resize images that are shaped differently
@@ -3308,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(
@@ -3821,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)
@@ -3987,7 +4068,7 @@ class CustomTableView(QTableView):
                     desc_action.triggered.connect(lambda checked, c=col: self.sort_table(c, ascending=False))
             
             # Different menus for top and bottom tables
-            if self == self.parent.data_table:  # Top table
+            if self in self.parent.data_table:  # Top table
                 save_menu = context_menu.addMenu("Save As")
                 save_csv = save_menu.addAction("CSV")
                 save_excel = save_menu.addAction("Excel")
@@ -4096,7 +4177,7 @@ class CustomTableView(QTableView):
         df = self.model()._data
         
         # Get table name for the file dialog title
-        if self == self.parent.data_table:
+        if self in self.parent.data_table:
             table_name = "Statistics"
         elif self == self.parent.network_table:
             table_name = "Network"
@@ -4105,7 +4186,7 @@ class CustomTableView(QTableView):
         
         # Get save file name
         file_filter = ("CSV Files (*.csv)" if file_type == 'csv' else 
-                      "Excel Files (*.xlsx)" if file_type == 'excel' else 
+                      "Excel Files (*.xlsx)" if file_type == 'xlsx' else 
                       "Gephi Graph (*.gexf)" if file_type == 'gexf' else
                       "GraphML (*.graphml)" if file_type == 'graphml' else
                       "Pajek Network (*.net)")
@@ -4237,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)
@@ -4267,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
@@ -4490,7 +4579,13 @@ class TabbedDataWidget(QTabWidget):
         """Add a new table with the given name"""
         if name in self.tables:
             # If tab already exists, update its content
-            idx = self.indexOf(self.tables[name])
+            old_table = self.tables[name]
+            idx = self.indexOf(old_table)
+            
+            # Remove the old table reference from parent's data_table
+            if self.parent_window and old_table in self.parent_window.data_table:
+                self.parent_window.data_table.remove(old_table)
+                
             self.removeTab(idx)
             
         # Create a new CustomTableView with is_top_table=True
@@ -4510,7 +4605,7 @@ class TabbedDataWidget(QTabWidget):
             
         # Update parent's data_table reference
         if self.parent_window:
-            self.parent_window.data_table = new_table
+            self.parent_window.data_table.append(new_table)
             
     def close_tab(self, index):
         """Close the tab at the given index"""
@@ -4525,12 +4620,12 @@ class TabbedDataWidget(QTabWidget):
         if name_to_remove:
             del self.tables[name_to_remove]
             
-        self.removeTab(index)
-        
-        # Update parent's data_table reference to current table
-        if self.parent_window and self.count() > 0:
-            self.parent_window.data_table = self.currentWidget()
+        # Update parent's data_table reference by removing the widget
+        if self.parent_window and widget in self.parent_window.data_table:
+            self.parent_window.data_table.remove(widget)
             
+        self.removeTab(index)
+                
     def clear_all_tabs(self):
         """Remove all tabs"""
         while self.count() > 0:
@@ -4895,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."""
@@ -4930,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]))
 
@@ -4954,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):
@@ -5247,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:
@@ -5261,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()
@@ -5433,18 +5589,23 @@ class RadialDialog(QDialog):
 
     def radial(self):
 
-        distance = float(self.distance.text()) if self.distance.text().strip() else 50
+        try:
+
+            distance = float(self.distance.text()) if self.distance.text().strip() else 50
+
+            directory = str(self.distance.text()) if self.directory.text().strip() else None
 
-        directory = str(self.distance.text()) if self.directory.text().strip() else None
+            if my_network.node_centroids is None:
+                self.parent().show_centroid_dialog()
 
-        if my_network.node_centroids is None:
-            self.parent().show_centroid_dialog()
+            radial = my_network.radial_distribution(distance, directory = directory)
 
-        radial = my_network.radial_distribution(distance, directory = directory)
+            self.parent().format_for_upperright_table(radial, 'Radial Distance From Any Node', 'Average Number of Neighboring Nodes', title = 'Radial Distribution Analysis')
 
-        self.parent().format_for_upperright_table(radial, 'Radial Distance From Any Node', 'Average Number of Neighboring Nodes', title = 'Radial Distribution Analysis')
+            self.accept()
 
-        self.accept()
+        except Exception as e:
+            print(f"An error occurred: {e}")
 
 class DegreeDistDialog(QDialog):
 
@@ -5477,7 +5638,7 @@ class DegreeDistDialog(QDialog):
 
             self.accept()
 
-        except Excpetion as e:
+        except Exception as e:
             print(f"An error occurred: {e}")
 
 class NeighborIdentityDialog(QDialog):
@@ -5589,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):
@@ -6303,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("")
@@ -7372,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("")
@@ -7783,6 +7988,12 @@ class SkeletonizeDialog(QDialog):
         self.remove = QLineEdit("0")
         layout.addRow("Remove Branches Pixel Length (int):", self.remove)
 
+        # auto checkbox (default True)
+        self.auto = QPushButton("Auto")
+        self.auto.setCheckable(True)
+        self.auto.setChecked(False)
+        layout.addRow("Attempt to Auto Correct Skeleton Looping:", self.auto)
+
        # Add Run button
         run_button = QPushButton("Run Skeletonize")
         run_button.clicked.connect(self.run_skeletonize)
@@ -7796,11 +8007,17 @@ class SkeletonizeDialog(QDialog):
                 remove = int(self.remove.text()) if self.remove.text() else 0
             except ValueError:
                 remove = 0
+
+            auto = self.auto.isChecked()
             
             # Get the active channel data from parent
             active_data = self.parent().channel_data[self.parent().active_channel]
             if active_data is None:
                 raise ValueError("No active image selected")
+
+            if auto:
+                active_data = n3d.skeletonize(active_data)
+                active_data = n3d.fill_holes_3d(active_data)
             
             # Call dilate method with parameters
             result = n3d.skeletonize(
@@ -7862,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)
@@ -8112,11 +8329,17 @@ class GenNodesDialog(QDialog):
         self.branch_removal = QLineEdit("0")
         layout.addRow("Skeleton Voxel Branch Length to Remove (int) (Compensates for spines off medial axis):", self.branch_removal)
 
+        self.comp_dil = QLineEdit("0")
+        layout.addRow("Voxel distance to merge nearby nodes (Int - compensates for multi-branch identification along thick branch regions):", self.comp_dil)
+
         self.max_vol = QLineEdit("0")
         layout.addRow("Maximum Voxel Volume of Vertices to Retain (int - Compensates for skeleton looping - occurs before any node merging - the smallest objects are always 27 voxels):", self.max_vol)
 
-        self.comp_dil = QLineEdit("0")
-        layout.addRow("Voxel distance to merge nearby nodes (Int - compensates for multi-branch identification along thick branch regions):", self.comp_dil)
+        # auto checkbox (default True)
+        self.auto = QPushButton("Auto")
+        self.auto.setCheckable(True)
+        self.auto.setChecked(False)
+        layout.addRow("Attempt to Auto Correct Skeleton Looping:", self.auto)
 
         if not down_factor:
             down_factor = None
@@ -8194,6 +8417,13 @@ class GenNodesDialog(QDialog):
             else:
                 order = 0
 
+            auto = self.auto.isChecked()
+
+
+            if auto:
+                my_network.edges = n3d.skeletonize(my_network.edges)
+                my_network.edges = n3d.fill_holes_3d(my_network.edges)
+
             
             result, skele = n3d.label_vertices(
                 my_network.edges,
@@ -8248,6 +8478,7 @@ class GenNodesDialog(QDialog):
             )
 
 
+
 class BranchDialog(QDialog):
 
     def __init__(self, parent=None):
@@ -8275,8 +8506,7 @@ class BranchDialog(QDialog):
         self.fix.setChecked(False)
         layout.addRow("Attempt to auto-correct branch labels:", self.fix)
 
-        self.fix_val = QLineEdit()
-        self.fix_val.setPlaceholderText("Empty = default value...")
+        self.fix_val = QLineEdit('4')
         layout.addRow("If checked above - Avg Degree of Nearby Branch Communities to Merge (Attempt to fix branch labeling - try 4 to 6 to start or leave empty):", self.fix_val)
 
         self.down_factor = QLineEdit("0")
@@ -8718,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/network_analysis.py

@@ -1024,11 +1024,8 @@ def histogram(counts, y_vals, directory = None):
     plt.ylabel('Avg Number of Neigbhoring Vertices')
 
     try:
-
         if directory is not None:
             plt.savefig(f'{directory}/radial_plot.png')
-        else:
-            plt.savefig('radial_plot.png')
     except:
         pass
 
@@ -1439,6 +1436,7 @@ def degree_distribution(G, directory = None):
 
 def power_trendline(x, y, directory = None):
     # Handle zeros in y for logarithmic transformations
+    """
     y = np.array(y)
     x = np.array(x)
     y[y == 0] += 0.001
@@ -1460,6 +1458,8 @@ def power_trendline(x, y, directory = None):
     ss_res = np.sum((y - y_pred) ** 2)
     ss_tot = np.sum((y - np.mean(y)) ** 2)
     r2 = 1 - (ss_res / ss_tot)
+    """
+    # ^ I commented out this power trendline stuff because I decided I no longer want it to do that so.
 
     # Create a scatterplot
     plt.scatter(x, y, label='Data')
@@ -1468,9 +1468,10 @@ def power_trendline(x, y, directory = None):
     plt.title('Degree Distribution of Network')
 
     # Plot the power trendline
-    plt.plot(x_fit, y_fit, color='red', label=f'Power Trendline: $y = {a:.2f}x^{{{b:.2f}}}$')
+    #plt.plot(x_fit, y_fit, color='red', label=f'Power Trendline: $y = {a:.2f}x^{{{b:.2f}}}$')
 
     # Annotate the plot with the trendline equation and R-squared value
+    """
     plt.text(
         0.05, 0.95, 
         f'$y = {a:.2f}x^{{{b:.2f}}}$\n$R^2 = {r2:.2f}$',
@@ -1478,13 +1479,12 @@ def power_trendline(x, y, directory = None):
         fontsize=12,
         verticalalignment='top'
     )
+    """
 
     try:
 
         if directory is not None:
             plt.savefig(f'{directory}/degree_plot.png')
-        else:
-            plt.savefig('degree_plot.png')
     except:
         pass
 

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.3.dist-info → nettracer3d-0.6.5.dist-info}/METADATA

@@ -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.dist-info → nettracer3d-0.6.5.dist-info}/RECORD

@@ -1,20 +1,20 @@
 nettracer3d/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nettracer3d/community_extractor.py,sha256=Zq8ZM595CTzeR6zLEZ4I6KvhkNfCPUReWvAKxTlaVfk,33495
 nettracer3d/modularity.py,sha256=V1f3s_vGd8EuVz27mzq6ycIGr0BWIpH7c7NU4QjgAHU,30247
-nettracer3d/morphology.py,sha256=yQ0GuieMVXOQpaohZlPnkEXEuCUjf8Fg352axyK8nbM,10755
-nettracer3d/nettracer.py,sha256=AS3r7Wg3MWv-FARApRCrzyuzb0l0_h944EfXFI75lng,207912
-nettracer3d/nettracer_gui.py,sha256=bTVauxgJXEF1Ufay3gXCqjy5J5DAHMnt5MlviSRzn2A,383537
-nettracer3d/network_analysis.py,sha256=MJBBjslA1k_R8ymid77U-qGSgzxFVfzGVQhE0IdhnbE,48046
+nettracer3d/morphology.py,sha256=yncUj04Noj_mcdJze4qMfYw-21AbebwiIcu1bDWGgCM,17778
+nettracer3d/nettracer.py,sha256=vsEDFlsz7WtWdkaK_uJXjbA_QzJRYW9pAQgLiAZOJKc,209987
+nettracer3d/nettracer_gui.py,sha256=492wQV_3nIAPPJRClXA-NssaCvx9H6GDMg6yaiL-BeM,393682
+nettracer3d/network_analysis.py,sha256=q1q7lxtA3lebxitfC_jfiT9cnpYXJw4q0Oy2_-Aj8qE,48068
 nettracer3d/network_draw.py,sha256=F7fw6Pcf4qWOhdKwLmhwqWdschbDlHzwCVolQC9imeU,14117
 nettracer3d/node_draw.py,sha256=k3sCTfUCJs3aH1C1q1gTNxDz9EAQbBd1hsUIJajxRx8,9823
 nettracer3d/proximity.py,sha256=FnIiI_AzfXd22HwCIFIyQRZxKYJ8YscIDdPnIv-wsO4,10560
 nettracer3d/run.py,sha256=xYeaAc8FCx8MuzTGyL3NR3mK7WZzffAYAH23bNRZYO4,127
 nettracer3d/segmenter.py,sha256=oKQEKQpo3o6cqfN6Z_IAgx8V-HXpegQNjfWFz3Bdu04,83449
 nettracer3d/simple_network.py,sha256=fP1gkDdtQcHruEZpUdasKdZeVacoLOxKhR3bY0L1CAQ,15426
-nettracer3d/smart_dilate.py,sha256=6m03KHtRMv0zfJ2aHc1Om4Fhh2abPy-IqDzRCmIEHCY,24588
-nettracer3d-0.6.3.dist-info/licenses/LICENSE,sha256=gM207DhJjWrxLuEWXl0Qz5ISbtWDmADfjHp3yC2XISs,888
-nettracer3d-0.6.3.dist-info/METADATA,sha256=qTU9_FA2xsowZID-6_tB7kMJ2cQH8EkAipAKaEu0VzU,3668
-nettracer3d-0.6.3.dist-info/WHEEL,sha256=tTnHoFhvKQHCh4jz3yCn0WPTYIy7wXx3CJtJ7SJGV7c,91
-nettracer3d-0.6.3.dist-info/entry_points.txt,sha256=Nx1rr_0QhJXDBHAQg2vcqCzLMKBzSHfwy3xwGkueVyc,53
-nettracer3d-0.6.3.dist-info/top_level.txt,sha256=zsYy9rZwirfCEOubolhee4TyzqBAL5gSUeFMzhFTX8c,12
-nettracer3d-0.6.3.dist-info/RECORD,,
+nettracer3d/smart_dilate.py,sha256=vnBj2soDGVBioKaNQi-bcyAtg0nuWcNGmlrzUNFFYQE,23191
+nettracer3d-0.6.5.dist-info/licenses/LICENSE,sha256=gM207DhJjWrxLuEWXl0Qz5ISbtWDmADfjHp3yC2XISs,888
+nettracer3d-0.6.5.dist-info/METADATA,sha256=q1Qp-eXkzhqVVG1A1OkPQeOVqMLbHwx7GdpI1fm_6NA,3476
+nettracer3d-0.6.5.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+nettracer3d-0.6.5.dist-info/entry_points.txt,sha256=Nx1rr_0QhJXDBHAQg2vcqCzLMKBzSHfwy3xwGkueVyc,53
+nettracer3d-0.6.5.dist-info/top_level.txt,sha256=zsYy9rZwirfCEOubolhee4TyzqBAL5gSUeFMzhFTX8c,12
+nettracer3d-0.6.5.dist-info/RECORD,,

{nettracer3d-0.6.3.dist-info → nettracer3d-0.6.5.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (77.0.1)
+Generator: setuptools (78.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any