nettracer3d 0.8.8__py3-none-any.whl → 0.8.9__py3-none-any.whl

nettracer3d/nettracer_gui.py

@@ -3161,6 +3161,18 @@ class ImageViewerWindow(QMainWindow):
             # End this stroke but keep session active for continuous painting
             self.painting = False
 
+            if self.erase:
+                if (hasattr(self, 'virtual_draw_operations') and self.virtual_draw_operations) or \
+                   (hasattr(self, 'virtual_erase_operations') and self.virtual_erase_operations) or \
+                   (hasattr(self, 'current_operation') and self.current_operation):
+                    # Finish current operation first
+                    if hasattr(self, 'current_operation') and self.current_operation:
+                        self.pm.finish_current_virtual_operation()
+                    # Now convert to real data
+                    self.pm.convert_virtual_strokes_to_data()
+                    current_xlim = self.ax.get_xlim()
+                    current_ylim = self.ax.get_ylim()
+                    self.update_display(preserve_zoom=(current_xlim, current_ylim))
 
             if self.resume:
                 self.machine_window.segmentation_worker.resume()
@@ -4779,7 +4791,7 @@ class ImageViewerWindow(QMainWindow):
             try:
                 #if len(self.channel_data[channel_index].shape) == 4:
                 if 1 in self.channel_data[channel_index].shape:
-                    print("Removing singleton dimension (I am assuming this is a channel dimension?)")
+                    #print("Removing singleton dimension (I am assuming this is a channel dimension?)")
                     self.channel_data[channel_index] = np.squeeze(self.channel_data[channel_index])
             except:
                 pass
@@ -4907,6 +4919,14 @@ class ImageViewerWindow(QMainWindow):
             self.original_ylim, self.original_xlim = (self.shape[1] + 0.5, -0.5), (-0.5, self.shape[2] - 0.5)
             #print(self.original_xlim)
 
+            self.completed_paint_strokes = [] #Reset pending paint operations
+            self.current_stroke_points = []
+            self.current_stroke_type = None
+            self.virtual_draw_operations = []
+            self.virtual_erase_operations = []
+            self.current_operation = []
+            self.current_operation_type = None
+
             if not end_paint:
 
                 self.update_display(reset_resize = reset_resize, preserve_zoom = preserve_zoom)
@@ -5143,8 +5163,8 @@ class ImageViewerWindow(QMainWindow):
             if self.mini_overlay == True: #If we are rendering the highlight overlay for selected values one at a time.
                 self.create_mini_overlay(node_indices = self.clicked_values['nodes'], edge_indices = self.clicked_values['edges'])
             self.update_display(preserve_zoom=view_settings)
-            if self.machine_window is not None:
-                self.machine_window.poke_segmenter()
+            #if self.machine_window is not None:
+                #self.machine_window.poke_segmenter()
             self.pending_slice = None
 
     def update_brightness(self, channel_index, values):
@@ -6478,6 +6498,13 @@ class BrightnessContrastDialog(QDialog):
             channel_layout.addWidget(slider_container)
             layout.addWidget(channel_widget)
             
+            #debouncing
+            self.debounce_timer = QTimer()
+            self.debounce_timer.setSingleShot(True)
+            self.debounce_timer.timeout.connect(self._apply_pending_updates)
+            self.pending_updates = {}
+            self.debounce_delay = 300  # 300ms delay
+
             # Connect signals
             slider.valueChanged.connect(lambda values, ch=i: self.on_slider_change(ch, values))
             min_input.editingFinished.connect(lambda ch=i: self.on_min_input_change(ch))
@@ -6488,7 +6515,18 @@ class BrightnessContrastDialog(QDialog):
         min_val, max_val = values
         self.min_inputs[channel].setText(str(min_val))
         self.max_inputs[channel].setText(str(max_val))
-        self.parent().update_brightness(channel, values)
+        
+        # Store the pending update
+        self.pending_updates[channel] = values
+        
+        # Restart the debounce timer
+        self.debounce_timer.start(self.debounce_delay)
+    
+    def _apply_pending_updates(self):
+        """Apply all pending brightness updates"""
+        for channel, values in self.pending_updates.items():
+            self.parent().update_brightness(channel, values)
+        self.pending_updates.clear()
         
     def on_min_input_change(self, channel):
         """Handle changes to minimum value input"""
@@ -9338,11 +9376,13 @@ class ThresholdDialog(QDialog):
 
     def start_ml(self, GPU = False):
 
-        try:
-            print("Please select image to load into nodes channel for segmentation or press X if you already have the one you want. Note that this load may permit a color image in the nodes channel for segmentation purposes only, which is otherwise not allowed.")
-            self.parent().load_channel(0, color = True)
-        except:
-            pass
+        if self.parent().channel_data[0] is None:
+
+            try:
+                print("Please select image to load into nodes channel for segmentation or press X if you already have the one you want. Note that this load may permit a color image in the nodes channel for segmentation purposes only, which is otherwise not allowed.")
+                self.parent().load_channel(0, color = True)
+            except:
+                pass
 
 
         if self.parent().channel_data[2] is not None or self.parent().channel_data[3] is not None or self.parent().highlight_overlay is not None:
@@ -9589,14 +9629,8 @@ class MachineWindow(QMainWindow):
             train_quick.clicked.connect(lambda: self.train_model(speed=True))
             train_detailed = QPushButton("Train Detailed Model (For Morphology)")
             train_detailed.clicked.connect(lambda: self.train_model(speed=False))
-            save = QPushButton("Save Model")
-            save.clicked.connect(self.save_model)
-            load = QPushButton("Load Model")
-            load.clicked.connect(self.load_model)
             training_layout.addWidget(train_quick)
             training_layout.addWidget(train_detailed)
-            training_layout.addWidget(save)
-            training_layout.addWidget(load)
             training_group.setLayout(training_layout)
 
             # Group 4: Segmentation Options
@@ -9621,12 +9655,27 @@ class MachineWindow(QMainWindow):
             segmentation_layout.addWidget(full_button)
             segmentation_group.setLayout(segmentation_layout)
 
+            # Group 5: Loading Options
+            loading_group = QGroupBox("Saving/Loading")
+            loading_layout = QHBoxLayout()
+            self.save = QPushButton("Save Model")
+            self.save.clicked.connect(self.save_model)
+            self.load = QPushButton("Load Model")
+            self.load.clicked.connect(self.load_model)
+            load_nodes = QPushButton("Load Image (For Seg - Supports Color Images)")
+            load_nodes.clicked.connect(self.load_nodes)
+            loading_layout.addWidget(self.save)
+            loading_layout.addWidget(self.load)
+            loading_layout.addWidget(load_nodes)
+            loading_group.setLayout(loading_layout) 
+
             # Add all groups to main layout
             main_layout.addWidget(drawing_group)
             if not GPU:
                 main_layout.addWidget(processing_group)
             main_layout.addWidget(training_group)
             main_layout.addWidget(segmentation_group)
+            main_layout.addWidget(loading_group)
 
             # Set the main widget as the central widget
             self.setCentralWidget(main_widget)
@@ -9649,6 +9698,79 @@ class MachineWindow(QMainWindow):
         except:
             return
 
+    def load_nodes(self):
+
+        def confirm_machine_dialog():
+            """Shows a dialog asking user to confirm if they want to start the segmenter"""
+            msg = QMessageBox()
+            msg.setIcon(QMessageBox.Icon.Question)
+            msg.setText("Alert")
+            msg.setInformativeText("Use of this feature will require use of both overlay channels and the highlight overlay. Please save any data and return, or proceed if you do not need those overlays")
+            msg.setWindowTitle("Proceed?")
+            msg.setStandardButtons(QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No)
+            return msg.exec() == QMessageBox.StandardButton.Yes
+
+        if self.parent().channel_data[2] is not None or self.parent().channel_data[3] is not None or self.parent().highlight_overlay is not None:
+            if confirm_machine_dialog():
+                pass
+            else:
+                return
+
+        try:
+
+            try:
+                print("Please select image to load into nodes channel for segmentation or press X if you already have the one you want. Note that this load may permit a color image in the nodes channel for segmentation purposes only, which is otherwise not allowed.")
+                self.parent().reset(nodes = True, edges = True, search_region = True, network_overlay = True, id_overlay = True)
+                self.parent().highlight_overlay = None
+                self.parent().load_channel(0, color = True)
+                if self.parent().active_channel == 0:
+                    if self.parent().channel_data[0] is not None:
+                        try:
+                            active_data = self.parent().channel_data[0]
+                            act_channel = 0
+                        except:
+                            active_data = self.parent().channel_data[1]
+                            act_channel = 1
+                            import traceback
+                            traceback.print_exc()
+                    else:
+                        active_data = self.parent().channel_data[1]
+                        act_channel = 1
+
+                try:
+                    if len(active_data.shape) == 3:
+                        array1 = np.zeros_like(active_data).astype(np.uint8)
+                    elif len(active_data.shape) == 4:
+                        array1 = np.zeros_like(active_data)[:,:,:,0].astype(np.uint8)
+                except:
+                    print("No data in nodes channel")
+                    import traceback
+                    traceback.print_exc()
+                    return
+                array3 = np.zeros_like(array1).astype(np.uint8)
+                self.parent().highlight_overlay = array3 #Clear this out for the segmenter to use
+
+                self.parent().load_channel(2, array1, True)
+                self.trained = False
+                self.previewing = False
+
+                self.segmenter = segmenter.InteractiveSegmenter(active_data, use_gpu=False)
+
+                self.segmentation_worker = None
+
+                self.fore_button.click()
+                self.fore_button.click()
+
+                self.num_chunks = 0
+                self.parent().update_display()
+            except:
+                import traceback
+                traceback.print_exc()
+                pass            
+
+        except:
+            pass
+
     def toggle_segment(self):
 
         if self.segmentation_worker is not None:
@@ -9850,10 +9972,8 @@ class MachineWindow(QMainWindow):
         self.kill_segmentation()
         time.sleep(0.1)
 
-        if self.use_two:
-            self.previewing = True
-        else:
-            print("Beginning new segmentation...")
+        if not self.trained:
+            return
 
         if self.parent().channel_data[2] is not None:
             active_data = self.parent().channel_data[2]
@@ -9863,19 +9983,16 @@ class MachineWindow(QMainWindow):
         array3 = np.zeros_like(active_data).astype(np.uint8)
         self.parent().highlight_overlay = array3 #Clear this out for the segmenter to use
 
-        if not self.trained:
-            return
-        else:
-            self.segmentation_worker = SegmentationWorker(self.parent().highlight_overlay, self.segmenter, self.use_gpu, self.use_two, self.previewing, self, self.mem_lock)
-            self.segmentation_worker.chunk_processed.connect(self.update_display)  # Just update display
-            current_xlim = self.parent().ax.get_xlim()
-            current_ylim = self.parent().ax.get_ylim()
-            try:
-                x, y = self.parent().get_current_mouse_position()
-            except:
-                x, y = 0, 0
-            self.segmenter.update_position(self.parent().current_slice, x, y)
-            self.segmentation_worker.start()
+        self.segmentation_worker = SegmentationWorker(self.parent().highlight_overlay, self.segmenter, self.use_gpu, self.use_two, self.previewing, self, self.mem_lock)
+        self.segmentation_worker.chunk_processed.connect(self.update_display)  # Just update display
+        current_xlim = self.parent().ax.get_xlim()
+        current_ylim = self.parent().ax.get_ylim()
+        try:
+            x, y = self.parent().get_current_mouse_position()
+        except:
+            x, y = 0, 0
+        self.segmenter.update_position(self.parent().current_slice, x, y)
+        self.segmentation_worker.start()
 
     def confirm_seg_dialog(self):
         """Shows a dialog asking user to confirm segment all"""
@@ -10086,7 +10203,10 @@ class SegmentationWorker(QThread):
         self.mem_lock = mem_lock
         self._stop = False
         self._paused = False  # Add pause flag
-        self.update_interval = 1  # Increased to 500ms
+        if self.machine_window.parent().shape[1] * self.machine_window.parent().shape[2] > 3000 * 3000: #arbitrary throttle for large arrays.
+            self.update_interval = 10
+        else:
+            self.update_interval = 1  # Increased to 1s
         self.chunks_since_update = 0
         self.chunks_per_update = 5  # Only update every 5 chunks
         self.poked = False # If it should wake up or not
@@ -10138,8 +10258,8 @@ class SegmentationWorker(QThread):
                 current_time = time.time()
                 if (self.chunks_since_update >= self.chunks_per_update and 
                     current_time - self.last_update >= self.update_interval):
-                    if self.machine_window.parent().shape[1] * self.machine_window.parent().shape[2] > 3000 * 3000: #arbitrary throttle for large arrays.
-                        self.msleep(3000)
+                    #if self.machine_window.parent().shape[1] * self.machine_window.parent().shape[2] > 3000 * 3000: #arbitrary throttle for large arrays.
+                        #self.msleep(3000)
                     self.chunk_processed.emit()
                     self.chunks_since_update = 0
                     self.last_update = current_time