nettracer3d 0.8.6__tar.gz → 0.8.8__tar.gz

{nettracer3d-0.8.6/src/nettracer3d.egg-info → nettracer3d-0.8.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nettracer3d
-Version: 0.8.6
+Version: 0.8.8
 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.6 Updates -- 
+-- Version 0.8.8 Updates -- 
 
 	* See Documentation Once Updated

{nettracer3d-0.8.6 → nettracer3d-0.8.8}/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.6 Updates -- 
+-- Version 0.8.8 Updates -- 
 
 	* See Documentation Once Updated

{nettracer3d-0.8.6 → nettracer3d-0.8.8}/pyproject.toml

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

{nettracer3d-0.8.6 → nettracer3d-0.8.8}/src/nettracer3d/nettracer_gui.py

@@ -2172,7 +2172,18 @@ class ImageViewerWindow(QMainWindow):
             if self.machine_window is not None:
                 self.machine_window.silence_button()
             self.canvas.setCursor(Qt.CursorShape.CrossCursor)
-            if self.pan_mode or self.brush_mode:
+            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.pan_mode:
                 current_xlim = self.ax.get_xlim()
                 current_ylim = self.ax.get_ylim()
                 self.update_display(preserve_zoom=(current_xlim, current_ylim))
@@ -2189,6 +2200,7 @@ class ImageViewerWindow(QMainWindow):
         self.pan_mode = self.pan_button.isChecked()
         if self.pan_mode:
 
+
             self.zoom_button.setChecked(False)
             self.pen_button.setChecked(False)
             self.zoom_mode = False
@@ -2196,13 +2208,42 @@ class ImageViewerWindow(QMainWindow):
             self.threed = False
             self.last_change = None
             self.brush_mode = False
-            if self.machine_window is not None:
-                self.machine_window.silence_button()
-            self.canvas.setCursor(Qt.CursorShape.OpenHandCursor)
-            if self.brush_mode:
+            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.machine_window is not None:
+                self.machine_window.silence_button()
+            self.canvas.setCursor(Qt.CursorShape.OpenHandCursor)
+
+            if self.pan_background_image is None:
+
+                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
+                self.pre_pan_channel_state = self.channel_visible.copy()
+                
+                # Create static background from currently visible channels
+                self.create_pan_background()
+                
+                # Hide all channels and show only the background
+                self.channel_visible = [False] * 4
+                self.is_pan_preview = True
+                
+                # Update display to show only background
+                self.update_display_pan_mode()
+
         else:
             current_xlim = self.ax.get_xlim()
             current_ylim = self.ax.get_ylim()
@@ -2229,8 +2270,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()
@@ -2242,6 +2281,14 @@ 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()
             # Get current zoom and do display update
             current_xlim = self.ax.get_xlim()
             current_ylim = self.ax.get_ylim()
@@ -2495,29 +2542,7 @@ class ImageViewerWindow(QMainWindow):
 
             self.panning = True
             self.pan_start = (event.xdata, event.ydata)
-
-            if self.pan_background_image is None:
-
-                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
-                self.pre_pan_channel_state = self.channel_visible.copy()
-                
-                # Create static background from currently visible channels
-                self.create_pan_background()
-                
-                # Hide all channels and show only the background
-                self.channel_visible = [False] * 4
-                self.is_pan_preview = True
-                
-                # Update display to show only background
-                self.update_display_pan_mode()
-            else:
-                self.canvas.setCursor(Qt.CursorShape.ClosedHandCursor)
+            self.canvas.setCursor(Qt.CursorShape.ClosedHandCursor)
 
 
         elif self.brush_mode:
@@ -2525,21 +2550,16 @@ class ImageViewerWindow(QMainWindow):
             if event.inaxes != self.ax:
                 return
 
-            """
-            try:
-                if self.machine_window is not None and not self.machine_window.segmentation_worker._paused:
-                    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
+            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
+            if self.pen_button.isChecked():
+                channel = self.active_channel
+            else:
+                channel = 2
+
+            self.pm.initiate_paint_session(channel, current_xlim, current_ylim)
 
-                    self.pm.initiate_paint_session(channel, current_xlim, current_ylim)
-            except:
-                pass
-            """
             
             if event.button == 1 or event.button == 3:
                 if self.machine_window is not None:
@@ -2555,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
                     
@@ -2965,7 +2985,7 @@ class ImageViewerWindow(QMainWindow):
                 if z1 == z2 == self.current_slice:
                     self.ax.plot([x1, x2], [y1, y2], 'r--', alpha=0.5)
             
-            self.canvas.setCursor(Qt.CursorShape.ClosedHandCursor)
+            #self.canvas.setCursor(Qt.CursorShape.ClosedHandCursor)
 
             self.canvas.draw_idle()
 
@@ -3121,24 +3141,26 @@ 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.resume:
                 self.machine_window.segmentation_worker.resume()
@@ -3264,7 +3286,6 @@ class ImageViewerWindow(QMainWindow):
 
                 self.zoom_changed = False  # Flag that zoom has changed
                 
-                
             
             self.canvas.draw()
         
@@ -5110,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'])
@@ -5133,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()
@@ -5163,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]
@@ -5404,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
@@ -9770,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:
@@ -9809,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:
@@ -9852,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:
@@ -9905,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
         
@@ -9932,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: