nettracer3d 0.8.6__tar.gz → 0.8.7__tar.gz

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

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

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

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

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

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

@@ -2172,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()
@@ -2196,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)
@@ -2229,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()
@@ -2242,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()
@@ -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
                     
@@ -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:

nettracer3d-0.8.7/src/nettracer3d/painting.py

@@ -0,0 +1,549 @@
+from PyQt6.QtWidgets import QApplication, QMainWindow
+import matplotlib.pyplot as plt
+import copy
+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."""
+        points = []
+        dx = abs(x1 - x0)
+        dy = abs(y1 - y0)
+        x, y = x0, y0
+        sx = 1 if x0 < x1 else -1
+        sy = 1 if y0 < y1 else -1
+        
+        if dx > dy:
+            err = dx / 2.0
+            while x != x1:
+                points.append((x, y))
+                err -= dy
+                if err < 0:
+                    y += sy
+                    err += dx
+                x += sx
+        else:
+            err = dy / 2.0
+            while y != y1:
+                points.append((x, y))
+                err -= dx
+                if err < 0:
+                    x += sx
+                    err += dy
+                y += sy
+                
+        points.append((x, y))
+        return points
+
+    def initiate_paint_session(self, channel, current_xlim, current_ylim):
+        # Create static background (same as selection rectangle)
+
+        if self.parent().machine_window is not None:
+            if self.parent().machine_window.segmentation_worker is not None:
+                if not self.parent().machine_window.segmentation_worker._paused:
+                    self.resume = True
+                self.parent().machine_window.segmentation_worker.pause()
+
+
+        if not self.parent().channel_visible[channel]:
+            self.parent().channel_visible[channel] = True
+            
+        # Capture the background once
+        self.parent().static_background = self.parent().canvas.copy_from_bbox(self.parent().ax.bbox)
+
+        if self.resume:
+            self.parent().machine_window.segmentation_worker.resume()
+            self.resume = False
+
+
+
+    def start_virtual_paint_session(self, channel, current_xlim, current_ylim):
+        """Start a virtual paint session that doesn't modify arrays until the end."""
+        self.parent().painting = True
+        self.parent().paint_channel = channel
+        
+        # Store original state
+        if not self.parent().channel_visible[channel]:
+            self.parent().channel_visible[channel] = True
+            
+        # 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
+
+    
+
+    def add_virtual_paint_point(self, x, y, brush_size, erase=False, foreground=True):
+        """Add a single paint point to the virtual layer."""
+        
+        # Determine operation type and visual properties
+        if erase:
+            paint_color = 'black'  # Visual indicator for erase
+            alpha = 0.5
+            operation_type = 'erase'
+        else:
+            if self.parent().machine_window is not None:
+                if foreground:
+                    paint_color = 'green'  # Visual for foreground (value 1)
+                    alpha = 0.7
+                else:
+                    paint_color = 'red'  # Visual for background (value 2)
+                    alpha = 0.7
+            else:
+                paint_color = 'white'  # Normal paint
+                alpha = 0.7
+            operation_type = 'draw'
+                
+        # Store the operation data (for later conversion to real paint)
+        operation_data = {
+            'x': x,
+            'y': y,
+            'brush_size': brush_size,
+            'erase': erase,
+            'foreground': foreground,
+            'channel': self.parent().paint_channel,
+            'threed': getattr(self.parent(), 'threed', False),
+            'threedthresh': getattr(self.parent(), 'threedthresh', 1)
+        }
+        
+        # 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 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()
+            self.parent().current_operation_type = operation_type
+        
+        self.parent().current_operation.append({
+            'circle': circle,
+            'data': operation_data
+        })
+        
+        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)
+        self.add_virtual_paint_point(x, y, brush_size, erase, foreground)
+        
+        # Store the last position for data conversion later
+        self.parent().last_virtual_pos = (x, y)
+
+    def connect_virtual_paint_points(self):
+        """Connect points with lines matching the circle size by converting to screen coordinates."""
+        
+        if not hasattr(self.parent(), 'current_operation') or len(self.parent().current_operation) < 2:
+            return
+        
+        # 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 - handles different object types."""
+        if not hasattr(self.parent(), 'static_background') or self.parent().static_background is None:
+            return
+        
+        # Restore the clean background
+        self.parent().canvas.restore_region(self.parent().static_background)
+        
+        # Draw all completed operations
+        for operation_list in [self.parent().virtual_draw_operations, self.parent().virtual_erase_operations]:
+            for operation in operation_list:
+                for item in operation:
+                    self._draw_virtual_item(item)
+        
+        # Draw current operation being painted
+        if hasattr(self.parent(), 'current_operation'):
+            for item in self.parent().current_operation:
+                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 each stroke separately to actual array data using ONLY the new stroke tracking system."""
+        
+        # Finish the current stroke first
+        self.finish_current_stroke()
+        
+        # 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 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=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(
+                        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
+        
+        # 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:
+                    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
+        
+        # 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'):
+            return
+        
+        # Now apply all the virtual strokes to the actual arrays
+        for stroke in self.parent().virtual_paint_strokes:
+            for circle in stroke:
+                center = circle.center
+                radius = circle.radius
+                is_erase = circle.get_facecolor()[0] == 0  # Black = erase
+                
+                # Apply to actual array
+                self.paint_at_position_vectorized(
+                    int(center[0]), int(center[1]), 
+                    erase=is_erase, 
+                    channel=self.paint_channel,
+                    brush_size=int(radius * 2)
+                )
+                
+                # Remove the virtual circle
+                circle.remove()
+        
+        # Clean up virtual paint data
+        self.virtual_paint_strokes = []
+        self.current_stroke = []
+        
+        # Reset background
+        self.static_background = None
+        self.painting = False
+        
+        # Full refresh to show final result
+        self.update_display()
+
+    def paint_at_position_vectorized(self, center_x, center_y, erase=False, channel=2, 
+                                   slice_idx=None, brush_size=None, threed=None, 
+                                   threedthresh=None, foreground=True, machine_window=None):
+        """Vectorized paint operation for better performance."""
+        if self.parent().channel_data[channel] is None:
+            return
+        
+        # Use provided parameters or fall back to instance variables
+        slice_idx = slice_idx if slice_idx is not None else self.parent().current_slice
+        brush_size = brush_size if brush_size is not None else getattr(self.parent(), 'brush_size', 5)
+        threed = threed if threed is not None else getattr(self.parent(), 'threed', False)
+        threedthresh = threedthresh if threedthresh is not None else getattr(self.parent(), 'threedthresh', 1)
+        
+        # Handle 3D painting by recursively calling for each slice
+        if threed and threedthresh > 1:
+            half_range = (threedthresh - 1) // 2
+            low = max(0, slice_idx - half_range)
+            high = min(self.parent().channel_data[channel].shape[0] - 1, slice_idx + half_range)
+            
+            
+            for i in range(low, high + 1):
+                
+                # Recursive call for each slice, but with threed=False to avoid infinite recursion
+                self.paint_at_position_vectorized(
+                    center_x, center_y, 
+                    erase=erase, 
+                    channel=channel,
+                    slice_idx=i,  # Paint on slice i
+                    brush_size=brush_size,
+                    threed=False,  # Important: turn off 3D for recursive calls
+                    threedthresh=1,
+                    foreground=foreground,
+                    machine_window=machine_window
+                )
+                
+                
+            return  # Exit early, recursive calls handle everything
+        
+        # Regular 2D painting (single slice)
+        
+        # Determine paint value
+        if erase:
+            val = 0
+        elif machine_window is None:
+            try:
+                val = self.parent().min_max[channel][1]
+            except:
+                val = 255
+        elif foreground:
+            val = 1
+        else:
+            val = 2
+        
+        height, width = self.parent().channel_data[channel][slice_idx].shape
+        radius = brush_size // 2
+        
+        # Calculate affected region bounds
+        y_min = max(0, center_y - radius)
+        y_max = min(height, center_y + radius + 1)
+        x_min = max(0, center_x - radius)
+        x_max = min(width, center_x + radius + 1)
+        
+        if y_min >= y_max or x_min >= x_max:
+            return  # No valid region to paint
+        
+        # Create coordinate grids for the affected region
+        y_coords, x_coords = np.mgrid[y_min:y_max, x_min:x_max]
+        
+        # Calculate distances squared (avoid sqrt for performance)
+        distances_sq = (x_coords - center_x) ** 2 + (y_coords - center_y) ** 2
+        mask = distances_sq <= radius ** 2
+        
+        # Paint on this single slice
+        
+        self.parent().channel_data[channel][slice_idx][y_min:y_max, x_min:x_max][mask] = val

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

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

nettracer3d-0.8.6/src/nettracer3d/painting.py

@@ -1,375 +0,0 @@
-from PyQt6.QtWidgets import QApplication, QMainWindow
-import matplotlib.pyplot as plt
-import copy
-import numpy as np
-
-
-class PaintManager(QMainWindow):
-    def __init__(self, parent = None):
-        super().__init__(parent)
-
-        self.resume = False
-
-    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."""
-        points = []
-        dx = abs(x1 - x0)
-        dy = abs(y1 - y0)
-        x, y = x0, y0
-        sx = 1 if x0 < x1 else -1
-        sy = 1 if y0 < y1 else -1
-        
-        if dx > dy:
-            err = dx / 2.0
-            while x != x1:
-                points.append((x, y))
-                err -= dy
-                if err < 0:
-                    y += sy
-                    err += dx
-                x += sx
-        else:
-            err = dy / 2.0
-            while y != y1:
-                points.append((x, y))
-                err -= dx
-                if err < 0:
-                    x += sx
-                    err += dy
-                y += sy
-                
-        points.append((x, y))
-        return points
-
-    def initiate_paint_session(self, channel, current_xlim, current_ylim):
-        # Create static background (same as selection rectangle)
-
-        if self.parent().machine_window is not None:
-            if self.parent().machine_window.segmentation_worker is not None:
-                if not self.parent().machine_window.segmentation_worker._paused:
-                    self.resume = True
-                self.parent().machine_window.segmentation_worker.pause()
-
-
-        if not self.parent().channel_visible[channel]:
-            self.parent().channel_visible[channel] = True
-            
-        # Capture the background once
-        self.parent().static_background = self.parent().canvas.copy_from_bbox(self.parent().ax.bbox)
-
-        if self.resume:
-            self.parent().machine_window.segmentation_worker.resume()
-            self.resume = False
-
-
-
-    def start_virtual_paint_session(self, channel, current_xlim, current_ylim):
-        """Start a virtual paint session that doesn't modify arrays until the end."""
-        self.parent().painting = True
-        self.parent().paint_channel = channel
-        
-        # Store original state
-        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
-        self.parent().current_operation = []
-        self.parent().current_operation_type = None  # 'draw' or 'erase'
-
-    def add_virtual_paint_point(self, x, y, brush_size, erase=False, foreground=True):
-        """Add a single paint point to the virtual layer."""
-        
-        # Determine operation type and visual properties
-        if erase:
-            paint_color = 'black'  # Visual indicator for erase
-            alpha = 0.5
-            operation_type = 'erase'
-        else:
-            if self.parent().machine_window is not None:
-                if foreground:
-                    paint_color = 'green'  # Visual for foreground (value 1)
-                    alpha = 0.7
-                else:
-                    paint_color = 'red'  # Visual for background (value 2)
-                    alpha = 0.7
-            else:
-                paint_color = 'white'  # Normal paint
-                alpha = 0.7
-            operation_type = 'draw'
-                
-        # Store the operation data (for later conversion to real paint)
-        operation_data = {
-            'x': x,
-            'y': y,
-            'brush_size': brush_size,
-            'erase': erase,
-            'foreground': foreground,
-            'channel': self.parent().paint_channel,
-            'threed': getattr(self.parent(), 'threed', False),
-            'threedthresh': getattr(self.parent(), 'threedthresh', 1)
-        }
-        
-        # Create visual circle
-        circle = plt.Circle((x, y), brush_size/2, 
-                           color=paint_color, alpha=alpha, animated=True)
-        
-        # Add to current operation
-        if self.parent().current_operation_type != operation_type:
-            # Finish previous operation if switching between draw/erase
-            self.finish_current_virtual_operation()
-            self.parent().current_operation_type = operation_type
-        
-        self.parent().current_operation.append({
-            'circle': circle,
-            'data': operation_data
-        })
-        
-        self.parent().ax.add_patch(circle)
-
-    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)
-        self.add_virtual_paint_point(x, y, brush_size, erase, foreground)
-        
-        # 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."""
-        
-        if not self.parent().current_operation:
-            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
-
-    def update_virtual_paint_display(self):
-        """Update display with virtual paint strokes - super fast like selection rectangle."""
-        if not hasattr(self.parent(), 'static_background') or self.parent().static_background is None:
-            return
-        
-        # Restore the clean background
-        self.parent().canvas.restore_region(self.parent().static_background)
-        
-        # Draw all completed operations
-        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'])
-        
-        # 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'])
-        
-        # Blit everything at once
-        self.parent().canvas.blit(self.parent().ax.bbox)
-
-    def convert_virtual_strokes_to_data(self):
-        """Convert virtual paint strokes to actual array data with interpolation applied here."""
-        
-        # 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
-        
-        # Then, apply all erase operations with interpolation (same changes)
-        for operation in self.parent().virtual_erase_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=True,
-                            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=True,
-                        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
-        
-        # Clean up
-        self.parent().virtual_draw_operations = []
-        self.parent().virtual_erase_operations = []
-        if hasattr(self.parent(), 'current_operation'):
-            for item in self.parent().current_operation:
-                try:
-                    item['circle'].remove()
-                except:
-                    pass
-            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'):
-            return
-        
-        # Now apply all the virtual strokes to the actual arrays
-        for stroke in self.parent().virtual_paint_strokes:
-            for circle in stroke:
-                center = circle.center
-                radius = circle.radius
-                is_erase = circle.get_facecolor()[0] == 0  # Black = erase
-                
-                # Apply to actual array
-                self.paint_at_position_vectorized(
-                    int(center[0]), int(center[1]), 
-                    erase=is_erase, 
-                    channel=self.paint_channel,
-                    brush_size=int(radius * 2)
-                )
-                
-                # Remove the virtual circle
-                circle.remove()
-        
-        # Clean up virtual paint data
-        self.virtual_paint_strokes = []
-        self.current_stroke = []
-        
-        # Reset background
-        self.static_background = None
-        self.painting = False
-        
-        # Full refresh to show final result
-        self.update_display()
-
-    def paint_at_position_vectorized(self, center_x, center_y, erase=False, channel=2, 
-                                   slice_idx=None, brush_size=None, threed=None, 
-                                   threedthresh=None, foreground=True, machine_window=None):
-        """Vectorized paint operation for better performance."""
-        if self.parent().channel_data[channel] is None:
-            return
-        
-        # Use provided parameters or fall back to instance variables
-        slice_idx = slice_idx if slice_idx is not None else self.parent().current_slice
-        brush_size = brush_size if brush_size is not None else getattr(self.parent(), 'brush_size', 5)
-        threed = threed if threed is not None else getattr(self.parent(), 'threed', False)
-        threedthresh = threedthresh if threedthresh is not None else getattr(self.parent(), 'threedthresh', 1)
-        
-        # Handle 3D painting by recursively calling for each slice
-        if threed and threedthresh > 1:
-            half_range = (threedthresh - 1) // 2
-            low = max(0, slice_idx - half_range)
-            high = min(self.parent().channel_data[channel].shape[0] - 1, slice_idx + half_range)
-            
-            
-            for i in range(low, high + 1):
-                
-                # Recursive call for each slice, but with threed=False to avoid infinite recursion
-                self.paint_at_position_vectorized(
-                    center_x, center_y, 
-                    erase=erase, 
-                    channel=channel,
-                    slice_idx=i,  # Paint on slice i
-                    brush_size=brush_size,
-                    threed=False,  # Important: turn off 3D for recursive calls
-                    threedthresh=1,
-                    foreground=foreground,
-                    machine_window=machine_window
-                )
-                
-                
-            return  # Exit early, recursive calls handle everything
-        
-        # Regular 2D painting (single slice)
-        
-        # Determine paint value
-        if erase:
-            val = 0
-        elif machine_window is None:
-            try:
-                val = self.parent().min_max[channel][1]
-            except:
-                val = 255
-        elif foreground:
-            val = 1
-        else:
-            val = 2
-        
-        height, width = self.parent().channel_data[channel][slice_idx].shape
-        radius = brush_size // 2
-        
-        # Calculate affected region bounds
-        y_min = max(0, center_y - radius)
-        y_max = min(height, center_y + radius + 1)
-        x_min = max(0, center_x - radius)
-        x_max = min(width, center_x + radius + 1)
-        
-        if y_min >= y_max or x_min >= x_max:
-            return  # No valid region to paint
-        
-        # Create coordinate grids for the affected region
-        y_coords, x_coords = np.mgrid[y_min:y_max, x_min:x_max]
-        
-        # Calculate distances squared (avoid sqrt for performance)
-        distances_sq = (x_coords - center_x) ** 2 + (y_coords - center_y) ** 2
-        mask = distances_sq <= radius ** 2
-        
-        # Paint on this single slice
-        
-        self.parent().channel_data[channel][slice_idx][y_min:y_max, x_min:x_max][mask] = val