nettracer3d 0.8.5__tar.gz → 0.8.7__tar.gz

{nettracer3d-0.8.5/src/nettracer3d.egg-info → nettracer3d-0.8.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nettracer3d
-Version: 0.8.5
+Version: 0.8.7
 Summary: Scripts for intializing and analyzing networks from segmentations of three dimensional images.
 Author-email: Liam McLaughlin <liamm@wustl.edu>
 Project-URL: Documentation, https://nettracer3d.readthedocs.io/en/latest/
@@ -110,6 +110,6 @@ McLaughlin, L., Zhang, B., Sharma, S. et al. Three dimensional multiscalar neuro
 
 NetTracer3D was developed by Liam McLaughlin while working under Dr. Sanjay Jain at Washington University School of Medicine.
 
--- Version 0.8.5 Updates -- 
+-- Version 0.8.7 Updates -- 
 
 	* See Documentation Once Updated

{nettracer3d-0.8.5 → nettracer3d-0.8.7}/README.md

@@ -65,6 +65,6 @@ McLaughlin, L., Zhang, B., Sharma, S. et al. Three dimensional multiscalar neuro
 
 NetTracer3D was developed by Liam McLaughlin while working under Dr. Sanjay Jain at Washington University School of Medicine.
 
--- Version 0.8.5 Updates -- 
+-- Version 0.8.7 Updates -- 
 
 	* See Documentation Once Updated

{nettracer3d-0.8.5 → nettracer3d-0.8.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "nettracer3d"
-version = "0.8.5"
+version = "0.8.7"
 authors = [
   { name="Liam McLaughlin", email="liamm@wustl.edu" },
 ]

{nettracer3d-0.8.5 → nettracer3d-0.8.7}/src/nettracer3d/nettracer_gui.py

@@ -464,6 +464,8 @@ class ImageViewerWindow(QMainWindow):
         self.paint_batch = []
         self.last_paint_pos = None
 
+        self.resume = False
+
     def start_left_scroll(self):
         """Start scrolling left when left arrow is pressed."""
         # Single increment first
@@ -2170,6 +2172,15 @@ class ImageViewerWindow(QMainWindow):
             if self.machine_window is not None:
                 self.machine_window.silence_button()
             self.canvas.setCursor(Qt.CursorShape.CrossCursor)
+            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()
+                self.update_display()
             if self.pan_mode or self.brush_mode:
                 current_xlim = self.ax.get_xlim()
                 current_ylim = self.ax.get_ylim()
@@ -2194,6 +2205,15 @@ class ImageViewerWindow(QMainWindow):
             self.threed = False
             self.last_change = None
             self.brush_mode = False
+            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()
+                self.update_display()
             if self.machine_window is not None:
                 self.machine_window.silence_button()
             self.canvas.setCursor(Qt.CursorShape.OpenHandCursor)
@@ -2227,8 +2247,6 @@ class ImageViewerWindow(QMainWindow):
             else:
                 channel = 2
 
-            self.pm.initiate_paint_session(channel, current_xlim, current_ylim)
-
             if self.pan_mode:
                 current_xlim = self.ax.get_xlim()
                 current_ylim = self.ax.get_ylim()
@@ -2240,6 +2258,15 @@ class ImageViewerWindow(QMainWindow):
             self.zoom_mode = False
             self.update_brush_cursor()
         else:
+            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()
+                self.update_display()
             # Get current zoom and do display update
             current_xlim = self.ax.get_xlim()
             current_ylim = self.ax.get_ylim()
@@ -2498,6 +2525,8 @@ class ImageViewerWindow(QMainWindow):
 
                 if self.machine_window is not None:
                     if self.machine_window.segmentation_worker is not None:
+                        if not self.machine_window.segmentation_worker._paused:
+                            self.resume = True
                         self.machine_window.segmentation_worker.pause()
                 
                 # Store current channel visibility state
@@ -2520,10 +2549,23 @@ class ImageViewerWindow(QMainWindow):
             """Handle brush mode with virtual painting."""
             if event.inaxes != self.ax:
                 return
+
+            current_xlim = self.ax.get_xlim() if hasattr(self, 'ax') and self.ax.get_xlim() != (0, 1) else None
+            current_ylim = self.ax.get_ylim() if hasattr(self, 'ax') and self.ax.get_ylim() != (0, 1) else None
+
+            if self.pen_button.isChecked():
+                channel = self.active_channel
+            else:
+                channel = 2
+
+            self.pm.initiate_paint_session(channel, current_xlim, current_ylim)
+
             
             if event.button == 1 or event.button == 3:
                 if self.machine_window is not None:
                     if self.machine_window.segmentation_worker is not None:
+                        if not self.machine_window.segmentation_worker._paused:
+                            self.resume = True
                         self.machine_window.segmentation_worker.pause()
                         
                 x, y = int(event.xdata), int(event.ydata)
@@ -2533,7 +2575,7 @@ class ImageViewerWindow(QMainWindow):
                 current_ylim = self.ax.get_ylim() if hasattr(self, 'ax') and self.ax.get_ylim() != (0, 1) else None
                 
                 if event.button == 1 and getattr(self, 'can', False):
-                    self.update_display(preserve_zoom=(current_xlim, current_ylim), skip_paint_reinit = True)
+                    self.update_display(preserve_zoom=(current_xlim, current_ylim))
                     self.handle_can(x, y)
                     return
                     
@@ -3099,29 +3141,30 @@ class ImageViewerWindow(QMainWindow):
                     
                     if not hasattr(self, 'zoom_changed'):
                         self.zoom_changed = False
-            
+
             self.canvas.draw()
 
         #  Handle brush mode cleanup with paint session management
         if self.brush_mode and hasattr(self, 'painting') and self.painting:
+
+            self.pm.connect_virtual_paint_points()
+            self.pm.update_virtual_paint_display()
+
+
             # Finish current operation
+            self.pm.finish_current_stroke()
             self.pm.finish_current_virtual_operation()
             
             # Reset last position for next stroke
-            self.last_virtual_pos = None
+            #self.last_virtual_pos = None
             
             # End this stroke but keep session active for continuous painting
             self.painting = False
 
-            current_xlim = self.ax.get_xlim() if hasattr(self, 'ax') and self.ax.get_xlim() != (0, 1) else None
-            current_ylim = self.ax.get_ylim() if hasattr(self, 'ax') and self.ax.get_ylim() != (0, 1) else None
-
-            self.update_display(preserve_zoom=(current_xlim, current_ylim), continue_paint = True)
-
-            if self.machine_window is not None:
-                if self.machine_window.segmentation_worker is not None:
-                    self.machine_window.segmentation_worker.resume()
 
+            if self.resume:
+                self.machine_window.segmentation_worker.resume()
+                self.resume = False
             
 
     def highlight_value_in_tables(self, clicked_value):
@@ -3243,7 +3286,6 @@ class ImageViewerWindow(QMainWindow):
 
                 self.zoom_changed = False  # Flag that zoom has changed
                 
-                
             
             self.canvas.draw()
         
@@ -5089,6 +5131,14 @@ class ImageViewerWindow(QMainWindow):
         """Actually perform the slice update after debounce delay."""
         if self.pending_slice is not None:
             slice_value, view_settings = self.pending_slice
+            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()
             self.current_slice = slice_value
             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'])
@@ -5112,7 +5162,7 @@ class ImageViewerWindow(QMainWindow):
 
 
     
-    def update_display(self, preserve_zoom=None, dims = None, called = False, reset_resize = False, continue_paint = False, skip_paint_reinit = False):
+    def update_display(self, preserve_zoom=None, dims = None, called = False, reset_resize = False):
         """Update the display with currently visible channels and highlight overlay."""
         try:
             self.figure.clear()
@@ -5121,9 +5171,9 @@ class ImageViewerWindow(QMainWindow):
                 self.channel_visible = self.pre_pan_channel_state.copy()
                 self.is_pan_preview = False
                 self.pan_background_image = None
-                if self.machine_window is not None:
-                    if self.machine_window.segmentation_worker is not None:
-                        self.machine_window.segmentation_worker.resume()
+                if self.resume:
+                    self.machine_window.segmentation_worker.resume()
+                    self.resume = False
             if self.static_background is not None:
                 # NEW: Convert virtual strokes to real data before cleanup
                 if (hasattr(self, 'virtual_draw_operations') and self.virtual_draw_operations) or \
@@ -5142,17 +5192,17 @@ class ImageViewerWindow(QMainWindow):
                     self.restore_channels = []
                 except:
                     pass
-                if not continue_paint:
-                    self.static_background = None
 
-                    if self.machine_window is None:
-                        try:
-                            self.channel_data[4][self.current_slice, :, :] = n3d.overlay_arrays_simple(self.channel_data[self.temp_chan][self.current_slice, :, :], self.channel_data[4][self.current_slice, :, :])
-                            self.load_channel(self.temp_chan, self.channel_data[4], data = True, end_paint = True)
-                            self.channel_data[4] = None
-                            self.channel_visible[4] = False
-                        except:
-                            pass
+                self.static_background = None
+
+                if self.machine_window is None:
+                    try:
+                        self.channel_data[4][self.current_slice, :, :] = n3d.overlay_arrays_simple(self.channel_data[self.temp_chan][self.current_slice, :, :], self.channel_data[4][self.current_slice, :, :])
+                        self.load_channel(self.temp_chan, self.channel_data[4], data = True, end_paint = True)
+                        self.channel_data[4] = None
+                        self.channel_visible[4] = False
+                    except:
+                        pass
 
             # Get active channels and their dimensions
             active_channels = [i for i in range(4) if self.channel_data[i] is not None]
@@ -5383,17 +5433,6 @@ class ImageViewerWindow(QMainWindow):
             
             self.canvas.draw()
 
-            if self.brush_mode and not skip_paint_reinit:
-                # Get current zoom to preserve it
-                current_xlim = self.ax.get_xlim() if hasattr(self, 'ax') and self.ax.get_xlim() != (0, 1) else None
-                current_ylim = self.ax.get_ylim() if hasattr(self, 'ax') and self.ax.get_ylim() != (0, 1) else None
-
-                if self.pen_button.isChecked():
-                    channel = self.active_channel
-                else:
-                    channel = 2
-
-                self.pm.initiate_paint_session(channel, current_xlim, current_ylim)
 
         except:
             import traceback
@@ -9605,6 +9644,8 @@ class MachineWindow(QMainWindow):
             self.fore_button.click()
             self.fore_button.click()
 
+            self.num_chunks = 0
+
         except:
             return
 
@@ -9747,18 +9788,6 @@ class MachineWindow(QMainWindow):
 
             self.parent().pm = painting.PaintManager(parent = self.parent())
 
-            # Start virtual paint session
-            # Get current zoom to preserve it
-            current_xlim = self.parent().ax.get_xlim() if hasattr(self, 'ax') and self.ax.get_xlim() != (0, 1) else None
-            current_ylim = self.parent().ax.get_ylim() if hasattr(self, 'ax') and self.ax.get_ylim() != (0, 1) else None
-
-            if self.parent().pen_button.isChecked():
-                channel = self.parent().active_channel
-            else:
-                channel = 2
-
-            self.parent().pm.initiate_paint_session(channel, current_xlim, current_ylim)
-
             self.parent().pan_button.setChecked(False)
             self.parent().zoom_button.setChecked(False)
             if self.parent().pan_mode:
@@ -9786,6 +9815,15 @@ class MachineWindow(QMainWindow):
         # Wait a bit for cleanup
         time.sleep(0.1)
 
+        if (hasattr(self.parent(), 'virtual_draw_operations') and self.parent().virtual_draw_operations) or \
+           (hasattr(self.parent(), 'virtual_erase_operations') and self.parent().virtual_erase_operations) or \
+           (hasattr(self.parent(), 'current_operation') and self.parent().current_operation):
+            # Finish current operation first
+            if hasattr(self.parent(), 'current_operation') and self.parent().current_operation:
+                self.parent().pm.finish_current_virtual_operation()
+            # Now convert to real data
+            self.parent().pm.convert_virtual_strokes_to_data()
+
         self.previewing = True
         try:
             try:
@@ -9829,7 +9867,7 @@ class MachineWindow(QMainWindow):
             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(lambda: self.update_display(skip_paint_reinit = True))  # Just update display
+            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:
@@ -9882,7 +9920,7 @@ class MachineWindow(QMainWindow):
             
         return changed
 
-    def update_display(self, skip_paint_reinit = False):
+    def update_display(self):
         if not hasattr(self, '_last_update'):
             self._last_update = 0
         
@@ -9892,6 +9930,7 @@ class MachineWindow(QMainWindow):
 
         self._last_z = current_z
 
+        self.num_chunks += 1
 
         current_time = time.time()
         if current_time - self._last_update >= 1:  # Match worker's interval
@@ -9908,18 +9947,7 @@ class MachineWindow(QMainWindow):
 
                 if not self.parent().painting:
                     # Only update if view limits are valid
-                    self.parent().update_display(preserve_zoom=(current_xlim, current_ylim), skip_paint_reinit = skip_paint_reinit)
-
-                    if self.parent().brush_mode:
-                        current_xlim = self.parent().ax.get_xlim() if hasattr(self, 'ax') and self.ax.get_xlim() != (0, 1) else None
-                        current_ylim = self.parent().ax.get_ylim() if hasattr(self, 'ax') and self.ax.get_ylim() != (0, 1) else None
-
-                        if self.parent().pen_button.isChecked():
-                            channel = self.parent().active_channel
-                        else:
-                            channel = 2
-
-                        self.parent().pm.initiate_paint_session(channel, current_xlim, current_ylim)
+                    self.parent().update_display(preserve_zoom=(current_xlim, current_ylim))
                     
                     self._last_update = current_time
             except Exception as e:
@@ -10110,6 +10138,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)
                     self.chunk_processed.emit()
                     self.chunks_since_update = 0
                     self.last_update = current_time