nettracer3d 0.8.5__py3-none-any.whl → 0.8.7__py3-none-any.whl

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 

nettracer3d/painting.py

@@ -7,6 +7,26 @@ import numpy as np
 class PaintManager(QMainWindow):
     def __init__(self, parent = None):
         super().__init__(parent)
+        self.resume = False
+        
+        # Initialize stroke tracking storage once
+        if parent is not None:
+            if not hasattr(parent, 'completed_paint_strokes'):
+                parent.completed_paint_strokes = []  # List of individual completed strokes
+            if not hasattr(parent, 'current_stroke_points'):
+                parent.current_stroke_points = []    # Current stroke being drawn
+            if not hasattr(parent, 'current_stroke_type'):
+                parent.current_stroke_type = None    # 'draw' or 'erase'
+            
+            # Keep the old properties for display purposes
+            if not hasattr(parent, 'virtual_draw_operations'):
+                parent.virtual_draw_operations = []
+            if not hasattr(parent, 'virtual_erase_operations'):
+                parent.virtual_erase_operations = []
+            if not hasattr(parent, 'current_operation'):
+                parent.current_operation = []
+            if not hasattr(parent, 'current_operation_type'):
+                parent.current_operation_type = None
 
     def get_line_points(self, x0, y0, x1, y1):
         """Get all points in a line between (x0,y0) and (x1,y1) using Bresenham's algorithm."""
@@ -44,7 +64,8 @@ class PaintManager(QMainWindow):
 
         if self.parent().machine_window is not None:
             if self.parent().machine_window.segmentation_worker is not None:
-                # Instead of just pausing, completely stop and clean up the worker
+                if not self.parent().machine_window.segmentation_worker._paused:
+                    self.resume = True
                 self.parent().machine_window.segmentation_worker.pause()
 
 
@@ -54,10 +75,9 @@ class PaintManager(QMainWindow):
         # Capture the background once
         self.parent().static_background = self.parent().canvas.copy_from_bbox(self.parent().ax.bbox)
 
-        if self.parent().machine_window is not None:
-            if self.parent().machine_window.segmentation_worker is not None:
-                # Instead of just pausing, completely stop and clean up the worker
-                self.parent().machine_window.segmentation_worker.resume()
+        if self.resume:
+            self.parent().machine_window.segmentation_worker.resume()
+            self.resume = False
 
 
 
@@ -70,11 +90,35 @@ class PaintManager(QMainWindow):
         if not self.parent().channel_visible[channel]:
             self.parent().channel_visible[channel] = True
             
-        # Initialize virtual paint storage - separate draw and erase operations
-        self.parent().virtual_draw_operations = []  # Stores drawing operations
-        self.parent().virtual_erase_operations = []  # Stores erase operations
+        # Initialize stroke tracking storage ONLY if they don't exist
+        if not hasattr(self.parent(), 'completed_paint_strokes'):
+            self.parent().completed_paint_strokes = []
+        if not hasattr(self.parent(), 'current_stroke_points'):
+            self.parent().current_stroke_points = []
+        if not hasattr(self.parent(), 'current_stroke_type'):
+            self.parent().current_stroke_type = None
+            
+        # Initialize display storage ONLY if they don't exist
+        if not hasattr(self.parent(), 'virtual_draw_operations'):
+            self.parent().virtual_draw_operations = []
+        if not hasattr(self.parent(), 'virtual_erase_operations'):
+            self.parent().virtual_erase_operations = []
+        if not hasattr(self.parent(), 'current_operation'):
+            self.parent().current_operation = []
+        if not hasattr(self.parent(), 'current_operation_type'):
+            self.parent().current_operation_type = None
+
+    def reset_all_paint_storage(self):
+        """Reset all paint storage - call this when you want to start completely fresh."""
+        self.parent().completed_paint_strokes = []
+        self.parent().current_stroke_points = []
+        self.parent().current_stroke_type = None
+        self.parent().virtual_draw_operations = []
+        self.parent().virtual_erase_operations = []
         self.parent().current_operation = []
-        self.parent().current_operation_type = None  # 'draw' or 'erase'
+        self.parent().current_operation_type = None
+
+    
 
     def add_virtual_paint_point(self, x, y, brush_size, erase=False, foreground=True):
         """Add a single paint point to the virtual layer."""
@@ -109,11 +153,19 @@ class PaintManager(QMainWindow):
             'threedthresh': getattr(self.parent(), 'threedthresh', 1)
         }
         
-        # Create visual circle
+        # Add to stroke tracking (NEW - separate stroke tracking)
+        if self.parent().current_stroke_type != operation_type:
+            # Finish previous stroke if switching between draw/erase
+            self.finish_current_stroke()
+            self.parent().current_stroke_type = operation_type
+        
+        self.parent().current_stroke_points.append(operation_data)
+        
+        # Create visual circle for display
         circle = plt.Circle((x, y), brush_size/2, 
                            color=paint_color, alpha=alpha, animated=True)
         
-        # Add to current operation
+        # Add to display operations (OLD - for visual display)
         if self.parent().current_operation_type != operation_type:
             # Finish previous operation if switching between draw/erase
             self.finish_current_virtual_operation()
@@ -126,6 +178,23 @@ class PaintManager(QMainWindow):
         
         self.parent().ax.add_patch(circle)
 
+    def finish_current_stroke(self):
+        """Finish the current stroke and add it to completed strokes."""
+        if not self.parent().current_stroke_points:
+            return
+            
+        # Store the completed stroke with its type
+        stroke_data = {
+            'points': self.parent().current_stroke_points.copy(),
+            'type': self.parent().current_stroke_type
+        }
+        
+        self.parent().completed_paint_strokes.append(stroke_data)
+        
+        # Clear current stroke
+        self.parent().current_stroke_points = []
+        self.parent().current_stroke_type = None
+
     def add_virtual_paint_stroke(self, x, y, brush_size, erase=False, foreground=True):
         """Add a paint stroke - simple visual, interpolation happens during data conversion."""
         # Just add the current point for visual display (no interpolation yet)
@@ -134,22 +203,119 @@ class PaintManager(QMainWindow):
         # Store the last position for data conversion later
         self.parent().last_virtual_pos = (x, y)
 
-    def finish_current_virtual_operation(self):
-        """Finish the current operation (draw or erase) and add it to the appropriate list."""
+    def connect_virtual_paint_points(self):
+        """Connect points with lines matching the circle size by converting to screen coordinates."""
         
-        if not self.parent().current_operation:
+        if not hasattr(self.parent(), 'current_operation') or len(self.parent().current_operation) < 2:
             return
-            
-        if self.parent().current_operation_type == 'draw':
-            self.parent().virtual_draw_operations.append(self.parent().current_operation)
-        elif self.parent().current_operation_type == 'erase':
-            self.parent().virtual_erase_operations.append(self.parent().current_operation)
         
-        self.parent().current_operation = []
-        self.parent().current_operation_type = None
+        # Get existing points but DON'T remove them
+        existing_points = self.parent().current_operation.copy()
+        point_data = [item['data'] for item in existing_points if 'data' in item]
+        
+        if len(point_data) < 2:
+            return
+        
+        # Get visual properties and brush size from first point
+        first_data = point_data[0]
+        brush_size_data = first_data['brush_size']  # This is in data coordinates
+        
+        # Convert brush size from data coordinates to points for linewidth
+        # Get the transformation from data to display coordinates
+        ax = self.parent().ax
+        
+        # Transform two points to see the scaling
+        p1_data = [0, 0]
+        p2_data = [brush_size_data, 0]  # One brush_size unit away
+        
+        p1_display = ax.transData.transform(p1_data)
+        p2_display = ax.transData.transform(p2_data)
+        
+        # Calculate pixels per data unit
+        pixels_per_data_unit = abs(p2_display[0] - p1_display[0])
+        
+        # Convert to points (matplotlib uses 72 points per inch, figure.dpi pixels per inch)
+        fig = ax.figure
+        points_per_pixel = 72.0 / fig.dpi
+        brush_size_points = pixels_per_data_unit * points_per_pixel
+        
+        if first_data['erase']:
+            line_color = 'black'
+            alpha = 0.5
+        else:
+            if self.parent().machine_window is not None:
+                if first_data['foreground']:
+                    line_color = 'green'
+                    alpha = 0.7
+                else:
+                    line_color = 'red'
+                    alpha = 0.7
+            else:
+                line_color = 'white'
+                alpha = 0.7
+        
+        # Create line segments for connections using LineCollection
+        from matplotlib.collections import LineCollection
+        
+        segments = []
+        for i in range(len(point_data) - 1):
+            x1, y1 = point_data[i]['x'], point_data[i]['y']
+            x2, y2 = point_data[i+1]['x'], point_data[i+1]['y']
+            segments.append([(x1, y1), (x2, y2)])
+        
+        # Create line collection with converted linewidth
+        if segments:
+            lc = LineCollection(segments, 
+                               colors=line_color, 
+                               alpha=alpha,
+                               linewidths=brush_size_points,  # Now in points, matching circles
+                               animated=True)
+            self.parent().ax.add_collection(lc)
+            
+            # Add the line collection as a visual-only element
+            self.parent().current_operation.append({
+                'line_collection': lc,
+                'is_connection_visual': True
+            })
+
+    def finish_current_virtual_operation(self):
+       """Finish the current operation (draw or erase) and add it to the appropriate list."""
+       
+       if not self.parent().current_operation:
+           return
+       
+       # Filter out connection visuals from the operation before storing
+       data_items = []
+       visual_items = []
+       
+       for item in self.parent().current_operation:
+           if item.get('is_connection_visual', False):
+               visual_items.append(item)
+           else:
+               data_items.append(item)
+       
+       # Only store the data items for this specific stroke
+       if data_items:
+           if self.parent().current_operation_type == 'draw':
+               self.parent().virtual_draw_operations.append(data_items)
+           elif self.parent().current_operation_type == 'erase':
+               self.parent().virtual_erase_operations.append(data_items)
+       
+       # Clean up visual items that are connection-only
+       for item in visual_items:
+           try:
+               if 'line_collection' in item:
+                   item['line_collection'].remove()
+               elif 'line' in item:
+                   item['line'].remove()
+           except:
+               pass
+       
+       self.parent().current_operation = []
+       self.parent().current_operation_type = None
 
     def update_virtual_paint_display(self):
-        """Update display with virtual paint strokes - super fast like selection rectangle."""
+        """Update display with virtual paint strokes - handles different object types."""
         if not hasattr(self.parent(), 'static_background') or self.parent().static_background is None:
             return
         
@@ -160,108 +326,118 @@ class PaintManager(QMainWindow):
         for operation_list in [self.parent().virtual_draw_operations, self.parent().virtual_erase_operations]:
             for operation in operation_list:
                 for item in operation:
-                    self.parent().ax.draw_artist(item['circle'])
+                    self._draw_virtual_item(item)
         
         # Draw current operation being painted
         if hasattr(self.parent(), 'current_operation'):
             for item in self.parent().current_operation:
-                self.parent().ax.draw_artist(item['circle'])
+                self._draw_virtual_item(item)
         
         # Blit everything at once
         self.parent().canvas.blit(self.parent().ax.bbox)
 
+    def _draw_virtual_item(self, item):
+        """Helper method to draw different types of virtual paint items."""
+        try:
+            # Skip items that are marked as visual-only connections
+            if item.get('is_connection_visual', False):
+                if 'line' in item:
+                    self.parent().ax.draw_artist(item['line'])
+                elif 'line_collection' in item:
+                    self.parent().ax.draw_artist(item['line_collection'])
+            elif 'circle' in item:
+                self.parent().ax.draw_artist(item['circle'])
+            elif 'line' in item:
+                self.parent().ax.draw_artist(item['line'])
+            elif 'line_collection' in item:
+                self.parent().ax.draw_artist(item['line_collection'])
+        except Exception as e:
+            # Skip items that can't be drawn (might have been removed)
+            pass
+
     def convert_virtual_strokes_to_data(self):
-        """Convert virtual paint strokes to actual array data with interpolation applied here."""
+        """Convert each stroke separately to actual array data using ONLY the new stroke tracking system."""
         
-        # First, apply all drawing operations with interpolation
-        for operation in self.parent().virtual_draw_operations:
-            last_pos = None
-            for item in operation:
-                data = item['data']
-                current_pos = (data['x'], data['y'])
-                
-                if last_pos is not None:
-                    points = self.get_line_points(last_pos[0], last_pos[1], current_pos[0], current_pos[1])
-                    for px, py in points:
-                        self.paint_at_position_vectorized(
-                            px, py,
-                            erase=False,
-                            channel=data['channel'],
-                            brush_size=data['brush_size'],
-                            threed=data['threed'],  # Add this
-                            threedthresh=data['threedthresh'],  # Add this
-                            foreground=data['foreground'],
-                            machine_window=self.parent().machine_window
-                        )
-                else:
-                    self.paint_at_position_vectorized(
-                        data['x'], data['y'],
-                        erase=False,
-                        channel=data['channel'],
-                        brush_size=data['brush_size'],
-                        threed=data['threed'],  # Add this
-                        threedthresh=data['threedthresh'],  # Add this
-                        foreground=data['foreground'],
-                        machine_window=self.parent().machine_window
-                    )
-                
-                last_pos = current_pos
-                try:
-                    item['circle'].remove()
-                except:
-                    pass
+        # Finish the current stroke first
+        self.finish_current_stroke()
         
-        # Then, apply all erase operations with interpolation (same changes)
-        for operation in self.parent().virtual_erase_operations:
+        # Process ONLY the completed_paint_strokes (ignore old display operations)
+        for stroke in self.parent().completed_paint_strokes:
+            stroke_points = stroke['points']
+            stroke_type = stroke['type']
+            
+            if len(stroke_points) == 0:
+                continue
+                
+            # Apply interpolation within this stroke only
             last_pos = None
-            for item in operation:
-                data = item['data']
-                current_pos = (data['x'], data['y'])
+            for point_data in stroke_points:
+                current_pos = (point_data['x'], point_data['y'])
                 
                 if last_pos is not None:
+                    # Interpolate between consecutive points in this stroke
                     points = self.get_line_points(last_pos[0], last_pos[1], current_pos[0], current_pos[1])
                     for px, py in points:
                         self.paint_at_position_vectorized(
                             px, py,
-                            erase=True,
-                            channel=data['channel'],
-                            brush_size=data['brush_size'],
-                            threed=data['threed'],  # Add this
-                            threedthresh=data['threedthresh'],  # Add this
-                            foreground=data['foreground'],
+                            erase=point_data['erase'],
+                            channel=point_data['channel'],
+                            brush_size=point_data['brush_size'],
+                            threed=point_data['threed'],
+                            threedthresh=point_data['threedthresh'],
+                            foreground=point_data['foreground'],
                             machine_window=self.parent().machine_window
                         )
                 else:
+                    # First point in stroke
                     self.paint_at_position_vectorized(
-                        data['x'], data['y'],
-                        erase=True,
-                        channel=data['channel'],
-                        brush_size=data['brush_size'],
-                        threed=data['threed'],  # Add this
-                        threedthresh=data['threedthresh'],  # Add this
-                        foreground=data['foreground'],
+                        point_data['x'], point_data['y'],
+                        erase=point_data['erase'],
+                        channel=point_data['channel'],
+                        brush_size=point_data['brush_size'],
+                        threed=point_data['threed'],
+                        threedthresh=point_data['threedthresh'],
+                        foreground=point_data['foreground'],
                         machine_window=self.parent().machine_window
                     )
                 
                 last_pos = current_pos
-                try:
-                    item['circle'].remove()
-                except:
-                    pass
         
-        # Clean up
-        self.parent().virtual_draw_operations = []
-        self.parent().virtual_erase_operations = []
+        # Clean up ALL visual elements (both old and new systems)
+        for operation_list in [self.parent().virtual_draw_operations, self.parent().virtual_erase_operations]:
+            for operation in operation_list:
+                for item in operation:
+                    try:
+                        if 'circle' in item:
+                            item['circle'].remove()
+                        elif 'line_collection' in item:
+                            item['line_collection'].remove()
+                        elif 'line' in item:
+                            item['line'].remove()
+                    except:
+                        pass
+        
         if hasattr(self.parent(), 'current_operation'):
             for item in self.parent().current_operation:
                 try:
-                    item['circle'].remove()
+                    if 'circle' in item:
+                        item['circle'].remove()
+                    elif 'line_collection' in item:
+                        item['line_collection'].remove()
+                    elif 'line' in item:
+                        item['line'].remove()
                 except:
                     pass
-            self.parent().current_operation = []
+        
+        # Reset all storage for next paint session
+        self.parent().completed_paint_strokes = []
+        self.parent().current_stroke_points = []
+        self.parent().current_stroke_type = None
+        self.parent().virtual_draw_operations = []
+        self.parent().virtual_erase_operations = []
+        self.parent().current_operation = []
         self.parent().current_operation_type = None
 
-
     def end_virtual_paint_session(self):
         """Convert virtual paint to actual array modifications when exiting paint mode."""
         if not hasattr(self.parent(), 'virtual_paint_strokes'):

{nettracer3d-0.8.5.dist-info → nettracer3d-0.8.7.dist-info}/METADATA

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

@@ -6,20 +6,20 @@ nettracer3d/modularity.py,sha256=O9OeKbjD3v6gSFz9K2GzP6LsxlpQaPfeJbM1pyIEigw,217
 nettracer3d/morphology.py,sha256=jyDjYzrZ4LvI5jOyw8DLsxmo-i5lpqHsejYpW7Tq7Mo,19786
 nettracer3d/neighborhoods.py,sha256=VWubD5CBu9aNPhUea7FbAk9aTOq0FLKR9y-1VT7YkAc,39677
 nettracer3d/nettracer.py,sha256=TEV-nDmkcGP3UjWEor1LtEwm5mFBQu2nB0VRyz9Lt08,253649
-nettracer3d/nettracer_gui.py,sha256=Uf8a9DkK475sAwOq45S1okuiQtVwU7_Ovv8NuWDQ99M,538823
+nettracer3d/nettracer_gui.py,sha256=yrWkpWVt7IvgGFkvc8tbMWy8t6O8P_2ulOKW-eOe9B4,540425
 nettracer3d/network_analysis.py,sha256=kBzsVaq4dZkMe0k-VGvQIUvM-tK0ZZ8bvb-wtsugZRQ,46150
 nettracer3d/network_draw.py,sha256=F7fw6Pcf4qWOhdKwLmhwqWdschbDlHzwCVolQC9imeU,14117
 nettracer3d/node_draw.py,sha256=kZcR1PekLg0riioNeGcALIXQyZ5PtHA_9MT6z7Zovdk,10401
-nettracer3d/painting.py,sha256=_8QyiDhU0T4B6virPxfm1HGo-XGgDTavuQx_pbs5_Tc,15916
+nettracer3d/painting.py,sha256=K_dwngivw80r-Yyg4btKMsWGn566ZE9PnrQl986uxJE,23497
 nettracer3d/proximity.py,sha256=bTaucn_InQ-v1GIk8ug-dXvDhIO59rnBMl5nIwAmNyw,35335
 nettracer3d/run.py,sha256=xYeaAc8FCx8MuzTGyL3NR3mK7WZzffAYAH23bNRZYO4,127
 nettracer3d/segmenter.py,sha256=O3xjCimPwoL8LM1w4cKVTB7saY-UptFuYC8qOIo3iWg,61637
 nettracer3d/segmenter_GPU.py,sha256=3CJLXCiySZP2dJbkpfBoXwAYbV4TnvIYAm6oQv-T-y4,63479
 nettracer3d/simple_network.py,sha256=dkG4jpc4zzdeuoaQobgGfL3PNo6N8dGKQ5hEEubFIvA,9947
 nettracer3d/smart_dilate.py,sha256=TvRUh6B4q4zIdCO1BWH-xgTdND5OUNmo99eyxG9oIAU,27145
-nettracer3d-0.8.5.dist-info/licenses/LICENSE,sha256=jnNT-yBeIAKAHpYthPvLeqCzJ6nSurgnKmloVnfsjCI,764
-nettracer3d-0.8.5.dist-info/METADATA,sha256=AiCE19SzTrqneRhGlwFase_EbjCaiLTn0FOGDmHIN0Q,7008
-nettracer3d-0.8.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-nettracer3d-0.8.5.dist-info/entry_points.txt,sha256=Nx1rr_0QhJXDBHAQg2vcqCzLMKBzSHfwy3xwGkueVyc,53
-nettracer3d-0.8.5.dist-info/top_level.txt,sha256=zsYy9rZwirfCEOubolhee4TyzqBAL5gSUeFMzhFTX8c,12
-nettracer3d-0.8.5.dist-info/RECORD,,
+nettracer3d-0.8.7.dist-info/licenses/LICENSE,sha256=jnNT-yBeIAKAHpYthPvLeqCzJ6nSurgnKmloVnfsjCI,764
+nettracer3d-0.8.7.dist-info/METADATA,sha256=6Q68XlohpUOpHNK6V7doYlQ4R9twu5D9qoJNwoyfs48,7008
+nettracer3d-0.8.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+nettracer3d-0.8.7.dist-info/entry_points.txt,sha256=Nx1rr_0QhJXDBHAQg2vcqCzLMKBzSHfwy3xwGkueVyc,53
+nettracer3d-0.8.7.dist-info/top_level.txt,sha256=zsYy9rZwirfCEOubolhee4TyzqBAL5gSUeFMzhFTX8c,12
+nettracer3d-0.8.7.dist-info/RECORD,,