nettracer3d 0.6.4__py3-none-any.whl → 0.6.6__py3-none-any.whl

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("")
@@ -6558,16 +6748,16 @@ class MachineWindow(QMainWindow):
         self.GPU.setChecked(False)
         self.GPU.clicked.connect(self.toggle_GPU)
         self.use_gpu = False
-        self.two = QPushButton("Train By 2D Slice Patterns (Cheaper - CPU only)")
+        self.two = QPushButton("Train By 2D Slice Patterns")
         self.two.setCheckable(True)
-        self.two.setChecked(True)
+        self.two.setChecked(False)
         self.two.clicked.connect(self.toggle_two)
-        self.use_two = True
+        self.use_two = False
         self.three = QPushButton("Train by 3D Patterns")
         self.three.setCheckable(True)
-        self.three.setChecked(False)
+        self.three.setChecked(True)
         self.three.clicked.connect(self.toggle_three)
-        processing_layout.addWidget(self.GPU)
+        #processing_layout.addWidget(self.GPU)   [Decided to hold off on this until its more robust]
         processing_layout.addWidget(self.two)
         processing_layout.addWidget(self.three)
         processing_group.setLayout(processing_layout)
@@ -6600,7 +6790,7 @@ class MachineWindow(QMainWindow):
         full_button.clicked.connect(self.segment)
         segmentation_layout.addWidget(seg_button)
         #segmentation_layout.addWidget(self.pause_button)   # <--- for some reason the segmenter preview is still running even when killed, may be regenerating itself somewhere. May or may not actually try to resolve this because this feature isnt that necessary.
-        segmentation_layout.addWidget(self.lock_button)
+        #segmentation_layout.addWidget(self.lock_button)   # Also turned this off
         segmentation_layout.addWidget(full_button)
         segmentation_group.setLayout(segmentation_layout)
 
@@ -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("")
@@ -7615,6 +7805,18 @@ class HoleDialog(QDialog):
         
         layout = QFormLayout(self)
 
+        # auto checkbox (default True)
+        self.headon = QPushButton("Head-on")
+        self.headon.setCheckable(True)
+        self.headon.setChecked(False)
+        layout.addRow("Only Use 2D Slicing Dimension:", self.headon)
+
+        # auto checkbox (default True)
+        self.borders = QPushButton("Borders")
+        self.borders.setCheckable(True)
+        self.borders.setChecked(True)
+        layout.addRow("Fill Small Holes Along Borders:", self.borders)
+
        # Add Run button
         run_button = QPushButton("Run Fill Holes")
         run_button.clicked.connect(self.run_holes)
@@ -7628,10 +7830,15 @@ class HoleDialog(QDialog):
             active_data = self.parent().channel_data[self.parent().active_channel]
             if active_data is None:
                 raise ValueError("No active image selected")
+
+            borders = self.borders.isChecked()
+            headon = self.headon.isChecked()
             
             # Call dilate method with parameters
             result = n3d.fill_holes_3d(
-                active_data
+                active_data,
+                head_on = headon,
+                fill_borders = borders
             )
 
             self.parent().load_channel(self.parent().active_channel, result, True)
@@ -7889,7 +8096,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 +8965,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: