nettracer3d 0.9.1__tar.gz → 0.9.2__tar.gz

{nettracer3d-0.9.1/src/nettracer3d.egg-info → nettracer3d-0.9.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nettracer3d
-Version: 0.9.1
+Version: 0.9.2
 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,9 +110,8 @@ 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.9.1 Updates --
-	* Adjusted the segment by 3D function to now show the 3D chunks in the preview mode. Previously it showed 2D segmentations in the preview which finished the current plane faster but didn't show accurate training data.
-	* Adjusted the neighborhood heatmap predicted range value to now just simulate a uniform distribution rather than trying to use a mathematical algorithm. 
-	* The image display window now uses image pyramids and cropping for zoom ins so it should run a lot faster on bigger images.
-	* The community UMAP can now color them by neighborhood.
-	* No longer zooms all the way out by default with right click in zoom mode. Now user needs to Shift + Right Click.
+-- Version 0.9.2 Updates --
+	* Image viewer canvas window can now be popped out into a separate window.
+	* Image pyramid calculation is more dynamic instead of using arbitrary size thresholds.
+	* Adjusted pan mode
+	* Some bug fixes.

{nettracer3d-0.9.1 → nettracer3d-0.9.2}/README.md

@@ -65,9 +65,8 @@ 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.9.1 Updates --
-	* Adjusted the segment by 3D function to now show the 3D chunks in the preview mode. Previously it showed 2D segmentations in the preview which finished the current plane faster but didn't show accurate training data.
-	* Adjusted the neighborhood heatmap predicted range value to now just simulate a uniform distribution rather than trying to use a mathematical algorithm. 
-	* The image display window now uses image pyramids and cropping for zoom ins so it should run a lot faster on bigger images.
-	* The community UMAP can now color them by neighborhood.
-	* No longer zooms all the way out by default with right click in zoom mode. Now user needs to Shift + Right Click.
+-- Version 0.9.2 Updates --
+	* Image viewer canvas window can now be popped out into a separate window.
+	* Image pyramid calculation is more dynamic instead of using arbitrary size thresholds.
+	* Adjusted pan mode
+	* Some bug fixes.

{nettracer3d-0.9.1 → nettracer3d-0.9.2}/pyproject.toml

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

{nettracer3d-0.9.1 → nettracer3d-0.9.2}/src/nettracer3d/nettracer_gui.py

@@ -5,7 +5,7 @@ from PyQt6.QtWidgets import (QApplication, QMainWindow, QWidget, QVBoxLayout, QG
                             QFormLayout, QLineEdit, QPushButton, QFileDialog,
                             QLabel, QComboBox, QMessageBox, QTableView, QInputDialog,
                             QMenu, QTabWidget, QGroupBox)
-from PyQt6.QtCore import (QPoint, Qt, QAbstractTableModel, QTimer,  QThread, pyqtSignal, QObject, QCoreApplication)
+from PyQt6.QtCore import (QPoint, Qt, QAbstractTableModel, QTimer,  QThread, pyqtSignal, QObject, QCoreApplication, QEvent)
 import numpy as np
 import time
 from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
@@ -18,7 +18,7 @@ from nettracer3d import smart_dilate as sdl
 from matplotlib.colors import LinearSegmentedColormap
 from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
 import pandas as pd
-from PyQt6.QtGui import (QFont, QCursor, QColor, QPixmap, QFontMetrics, QPainter, QPen)
+from PyQt6.QtGui import (QFont, QCursor, QColor, QPixmap, QFontMetrics, QPainter, QPen, QShortcut, QKeySequence)
 import tifffile
 import copy
 import multiprocessing as mp
@@ -137,7 +137,6 @@ class ImageViewerWindow(QMainWindow):
         self.img_height = None
         self.pre_pan_channel_state = None  # Store which channels were visible before pan
         self.is_pan_preview = False        # Track if we're in pan preview mode
-        self.pre_pan_channel_state = None    # Store which channels were visible before pan
         self.pan_background_image = None     # Store the rendered composite image
         self.pan_zoom_state = None           # Store zoom state when pan began
         self.is_pan_preview = False          # Track if we're in pan preview mode
@@ -309,18 +308,19 @@ class ImageViewerWindow(QMainWindow):
         
         # Create left panel for image and controls
         left_panel = QWidget()
-        left_layout = QVBoxLayout(left_panel)
+        self.left_layout = QVBoxLayout(left_panel)
+
         
         # Create matplotlib canvas for image display
         self.figure = Figure(figsize=(8, 8))
         self.canvas = FigureCanvas(self.figure)
         self.ax = self.figure.add_subplot(111)
-        left_layout.addWidget(self.canvas)
+        self.left_layout.addWidget(self.canvas)
 
         self.canvas.mpl_connect('scroll_event', self.on_mpl_scroll)
 
         
-        left_layout.addWidget(control_panel)
+        self.left_layout.addWidget(control_panel)
 
         # Add timer for debouncing slice updates
         self._slice_update_timer = QTimer()
@@ -358,7 +358,7 @@ class ImageViewerWindow(QMainWindow):
         self.continuous_scroll_timer.timeout.connect(self.continuous_scroll)
         self.scroll_direction = 0  # 0: none, -1: left, 1: right
         
-        left_layout.addWidget(slider_container)
+        self.left_layout.addWidget(slider_container)
 
         
         main_layout.addWidget(left_panel)
@@ -467,6 +467,297 @@ class ImageViewerWindow(QMainWindow):
         self.resume = False
 
         self.hold_update = False
+        self._first_pan_done = False
+
+    def popup_canvas(self):
+        """Pop the canvas out into its own window"""
+        if hasattr(self, 'popup_window') and self.popup_window.isVisible():
+            # If popup already exists, just bring it to front
+            self.popup_window.raise_()
+            self.popup_window.activateWindow()
+            if hasattr(self, 'control_popup_window'):
+                self.control_popup_window.raise_()
+                self.control_popup_window.activateWindow()
+            # Also bring machine window to front if it exists
+            if self.machine_window is not None:
+                self.machine_window.raise_()
+                self.machine_window.activateWindow()
+            return
+        
+        self.is_popped = True
+
+        # Store original figure size and canvas size policy before popping out
+        self.original_figure_size = self.figure.get_size_inches()
+        self.original_canvas_size_policy = self.canvas.sizePolicy()
+        
+        # Create popup window for canvas
+        self.popup_window = QMainWindow()
+        self.popup_window.setWindowTitle("NetTracer3D - Canvas View")
+        self.popup_window.setGeometry(200, 200, 1000, 800)  # Bigger size
+        
+        # Install event filters for both window management and keyboard shortcuts
+        self.popup_window.installEventFilter(self)
+        
+        # Create popup window for control panel and slider
+        self.control_popup_window = QMainWindow()
+        self.control_popup_window.setWindowTitle("NetTracer3D - Controls")
+        self.control_popup_window.setGeometry(1220, 200, 400, 200)  # Bigger height for slider
+        
+        # Install event filter on control window too
+        self.control_popup_window.installEventFilter(self)
+        
+        # Make control window non-closeable while popped out
+        self.control_popup_window.setWindowFlags(
+            self.control_popup_window.windowFlags() & ~Qt.WindowType.WindowCloseButtonHint
+        )
+        
+        # Set control panel as child of canvas popup for natural stacking
+        self.control_popup_window.setParent(self.popup_window, Qt.WindowType.Window)
+        
+        # Remove canvas from left panel
+        self.canvas.setParent(None)
+        
+        # Remove control panel from left panel
+        # First find the control_panel widget
+        control_panel = None
+        for i in range(self.left_layout.count()):
+            widget = self.left_layout.itemAt(i).widget()
+            if widget and hasattr(widget, 'findChild') and widget.findChild(QComboBox):
+                control_panel = widget
+                break
+        
+        # Remove slider container from left panel
+        slider_container = None
+        for i in range(self.left_layout.count()):
+            widget = self.left_layout.itemAt(i).widget()
+            if widget and hasattr(widget, 'findChild') and widget.findChild(QSlider):
+                slider_container = widget
+                break
+        
+        if control_panel:
+            control_panel.setParent(None)
+            self.popped_control_panel = control_panel
+            
+        if slider_container:
+            slider_container.setParent(None)
+            self.popped_slider_container = slider_container
+        
+        # Move the actual canvas to popup window
+        self.popup_window.setCentralWidget(self.canvas)
+        
+        # Create a container widget for the control popup to hold both control panel and slider
+        control_container = QWidget()
+        control_container_layout = QVBoxLayout(control_container)
+        
+        # Add control panel to container
+        if control_panel:
+            control_container_layout.addWidget(control_panel)
+            
+        # Add slider container to container
+        if slider_container:
+            control_container_layout.addWidget(slider_container)
+        
+        # Set the container as the central widget
+        self.control_popup_window.setCentralWidget(control_container)
+        
+        # Create placeholder for left panel
+        placeholder = QLabel("Canvas and controls are popped out\nClick to return both")
+        placeholder.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        placeholder.setStyleSheet("""
+            QLabel {
+                background-color: #f0f0f0;
+                border: 2px dashed #ccc;
+                font-size: 14px;
+                color: #666;
+            }
+        """)
+        placeholder.mousePressEvent = lambda event: self.return_canvas()
+        
+        # Add placeholder to left layout
+        self.left_layout.insertWidget(0, placeholder)  # Insert at canvas position
+        self.canvas_placeholder = placeholder
+        
+        # Create keyboard shortcuts for popup windows
+        self.create_popup_shortcuts()
+        
+        # Show both popup windows
+        self.popup_window.show()
+        self.control_popup_window.show()
+        
+        # Ensure proper initial window order
+        self.ensure_window_order()
+        
+        # Connect close event to return canvas (only canvas window can be closed)
+        self.popup_window.closeEvent = self.on_popup_close
+
+    def eventFilter(self, obj, event):
+        """Filter events to manage window stacking and keyboard shortcuts"""
+        # Handle keyboard events for popup windows
+        if (obj == self.popup_window or obj == self.control_popup_window) and event.type() == QEvent.Type.KeyPress:
+            # Forward key events to main window's keyPressEvent method
+            self.keyPressEvent(event)
+            return True  # Event handled
+        
+        # Handle scroll events for popup canvas
+        if obj == self.popup_window and event.type() == QEvent.Type.Wheel:
+            # Forward wheel events to the scroll handler
+            canvas_widget = self.popup_window.centralWidget()
+            if canvas_widget == self.canvas:
+                # Create a mock matplotlib event from the Qt wheel event
+                self.handle_popup_scroll(event)
+                return True
+        
+        # Existing window stacking code
+        if obj == self.popup_window:
+            if event.type() == QEvent.Type.WindowActivate:
+                # Canvas popup was activated, raise our preferred windows
+                QTimer.singleShot(0, self.ensure_window_order)
+            elif event.type() == QEvent.Type.FocusIn:
+                # Canvas got focus, raise controls
+                QTimer.singleShot(0, self.ensure_window_order)
+        
+        return super().eventFilter(obj, event)
+
+    def create_popup_shortcuts(self):
+        """Create keyboard shortcuts for popup windows"""
+        if not hasattr(self, 'popup_shortcuts'):
+            self.popup_shortcuts = []
+        
+        # Define shortcuts - using your existing keyPressEvent logic
+        shortcuts_config = [
+            ('Z', lambda: self.zoom_button.click()),
+            ('Ctrl+Z', self.handle_undo),
+            ('X', lambda: self.high_button.click()),
+            ('Shift+F', self.handle_find),
+            ('Ctrl+S', self.handle_resave),
+            ('Ctrl+L', lambda: self.load_from_network_obj(directory=self.last_load)),
+            ('F', lambda: self.toggle_can() if self.brush_mode and self.machine_window is None else None),
+            ('D', lambda: self.toggle_threed() if self.brush_mode and self.machine_window is None else None),
+            ('A', lambda: self.machine_window.switch_foreground() if self.machine_window is not None else None),
+        ]
+        
+        # Create shortcuts for both popup windows
+        for key_seq, func in shortcuts_config:
+            # Canvas popup window shortcuts
+            shortcut1 = QShortcut(QKeySequence(key_seq), self.popup_window)
+            shortcut1.activated.connect(func)
+            self.popup_shortcuts.append(shortcut1)
+            
+            # Control popup window shortcuts
+            shortcut2 = QShortcut(QKeySequence(key_seq), self.control_popup_window)
+            shortcut2.activated.connect(func)
+            self.popup_shortcuts.append(shortcut2)
+
+    def handle_undo(self):
+        """Handle undo shortcut"""
+        try:
+            self.load_channel(self.last_change[1], self.last_change[0], True)
+        except:
+            pass
+
+    def handle_popup_scroll(self, qt_event):
+        """Handle scroll events in popup window"""
+        # Get the matplotlib canvas from the popup window
+        canvas = self.popup_window.centralWidget()
+        if canvas == self.canvas:
+            # Create a mock matplotlib event to pass to your existing scroll handler
+            # You might need to adapt this based on how your on_mpl_scroll method works
+            # For now, we'll try to call it directly with the Qt event
+            try:
+                # If your scroll handler needs a matplotlib event, you may need to 
+                # create a mock event or adapt the handler
+                pass  # You'll need to implement the scroll forwarding here
+            except:
+                pass
+
+    def ensure_window_order(self):
+        """Ensure control panel and machine window stay above canvas"""
+        if hasattr(self, 'control_popup_window') and self.control_popup_window.isVisible():
+            self.control_popup_window.raise_()
+        
+        if self.machine_window is not None and self.machine_window.isVisible():
+            self.machine_window.raise_()
+
+    def return_canvas(self):
+        """Return canvas and control panel to main window"""
+        if hasattr(self, 'popup_window'):
+            # Clean up popup shortcuts
+            if hasattr(self, 'popup_shortcuts'):
+                for shortcut in self.popup_shortcuts:
+                    shortcut.deleteLater()
+                del self.popup_shortcuts
+            
+            # Remove event filters when returning
+            self.popup_window.removeEventFilter(self)
+            if hasattr(self, 'control_popup_window'):
+                self.control_popup_window.removeEventFilter(self)
+            
+            # Remove canvas from popup
+            self.canvas.setParent(None)
+            self.is_popped = False
+            
+            # Remove control panel from popup
+            if hasattr(self, 'popped_control_panel') and hasattr(self, 'control_popup_window'):
+                self.popped_control_panel.setParent(None)
+                
+            # Remove slider container from popup
+            if hasattr(self, 'popped_slider_container') and hasattr(self, 'control_popup_window'):
+                self.popped_slider_container.setParent(None)
+            
+            # Remove placeholder
+            if hasattr(self, 'canvas_placeholder'):
+                self.canvas_placeholder.setParent(None)
+                del self.canvas_placeholder
+            
+            # Reset canvas to original size and size policy
+            if hasattr(self, 'original_figure_size'):
+                self.figure.set_size_inches(self.original_figure_size)
+            if hasattr(self, 'original_canvas_size_policy'):
+                self.canvas.setSizePolicy(self.original_canvas_size_policy)
+            
+            # Reset canvas minimum and maximum sizes to allow proper resizing
+            self.canvas.setMinimumSize(0, 0)  # Remove any minimum size constraints
+            self.canvas.setMaximumSize(16777215, 16777215)  # Reset to Qt's default maximum
+            
+            # Return canvas to left panel
+            self.left_layout.insertWidget(0, self.canvas)  # Insert at top
+            
+            # Return control panel to left panel (after canvas)
+            if hasattr(self, 'popped_control_panel'):
+                self.left_layout.insertWidget(1, self.popped_control_panel)  # Insert after canvas
+                del self.popped_control_panel
+                
+            # Return slider container to left panel (after control panel)
+            if hasattr(self, 'popped_slider_container'):
+                self.left_layout.insertWidget(2, self.popped_slider_container)  # Insert after control panel
+                del self.popped_slider_container
+            
+            # Force the canvas to redraw with proper sizing
+            self.canvas.draw()
+            
+            # Reset the main window layout to ensure proper proportions
+            # Get the main widget and force layout recalculation
+            main_widget = self.centralWidget()
+            if main_widget:
+                main_widget.updateGeometry()
+                main_widget.update()
+            
+            # Close both popup windows
+            self.popup_window.close()
+            if hasattr(self, 'control_popup_window'):
+                self.control_popup_window.close()
+                del self.control_popup_window
+            
+            # Clean up stored size references
+            if hasattr(self, 'original_figure_size'):
+                del self.original_figure_size
+            if hasattr(self, 'original_canvas_size_policy'):
+                del self.original_canvas_size_policy
+
+    def on_popup_close(self, event):
+        """Return canvas when popup is closed"""
+        self.return_canvas()
+        event.accept()
 
     def start_left_scroll(self):
         """Start scrolling left when left arrow is pressed."""
@@ -834,6 +1125,7 @@ class ImageViewerWindow(QMainWindow):
 
 
 
+
 #METHODS RELATED TO RIGHT CLICK:
     
     def create_context_menu(self, event):
@@ -2182,7 +2474,6 @@ class ImageViewerWindow(QMainWindow):
             self.pan_button.setChecked(False)
 
             self.pen_button.setChecked(False)
-            self.pan_mode = False
             self.brush_mode = False
             self.can = False
             self.threed = False
@@ -2205,6 +2496,7 @@ class ImageViewerWindow(QMainWindow):
                 current_xlim = self.ax.get_xlim()
                 current_ylim = self.ax.get_ylim()
                 self.update_display(preserve_zoom=(current_xlim, current_ylim))
+            self.pan_mode = False
 
         else:
             if self.machine_window is None:
@@ -2251,21 +2543,32 @@ class ImageViewerWindow(QMainWindow):
                 
                 # Store current channel visibility state
                 self.pre_pan_channel_state = self.channel_visible.copy()
-
-                self.prev_down = self.downsample_factor
-                if self.throttle:
-                    if self.downsample_factor < 3:
-                        self.validate_downsample_input(text = 3)
-                
-                # Create static background from currently visible channels
-                self.create_pan_background()
-                
-                # Hide all channels and show only the background
-                self.channel_visible = [False] * 4
-                self.is_pan_preview = True
                 
-                # Update display to show only background
-                self.update_display_pan_mode()
+                current_xlim = self.ax.get_xlim()
+                current_ylim = self.ax.get_ylim()
+
+                if (abs(current_xlim[1] - current_xlim[0]) * abs(current_ylim[0] - current_ylim[1]) > 400 * 400 and not self.shape[2] * self.shape[1] > 9000 * 9000 * 6) or self.shape[2] * self.shape[1] < 3000 * 3000:
+
+                    # Create static background from currently visible channels
+                    self.create_pan_background()
+                    
+                    # Hide all channels and show only the background
+                    self.channel_visible = [False] * 4
+                    self.is_pan_preview = True
+                    
+                    # Get current downsample factor
+                    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
+                    # Update display to show only background
+                    self.update_display_pan_mode(current_xlim, current_ylim)
+                    self.needs_update = False
+                else:
+                    self.needs_update = True
+                    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
+                    # Update display to show only background
+                    self._first_pan_done = False
+                    self.update_display(current_xlim, current_ylim)
 
         else:
             current_xlim = self.ax.get_xlim()
@@ -2737,7 +3040,6 @@ class ImageViewerWindow(QMainWindow):
             self.canvas.blit(self.ax.bbox)
 
         elif self.panning and self.pan_start is not None:
-
             # Calculate the movement
             dx = event.xdata - self.pan_start[0]
             dy = event.ydata - self.pan_start[1]
@@ -2751,22 +3053,30 @@ class ImageViewerWindow(QMainWindow):
             new_ylim = [ylim[0] - dy, ylim[1] - dy]
             
             # Get image bounds using cached dimensions
-            if self.img_width is not None:  # Changed from self.channel_data[0] check
+            if self.img_width is not None:
                 # Ensure new limits don't go beyond image bounds
                 if new_xlim[0] < 0:
                     new_xlim = [0, xlim[1] - xlim[0]]
-                elif new_xlim[1] > self.img_width:  # Changed from img_width variable lookup
+                elif new_xlim[1] > self.img_width:
                     new_xlim = [self.img_width - (xlim[1] - xlim[0]), self.img_width]
                     
                 if new_ylim[0] < 0:
                     new_ylim = [0, ylim[1] - ylim[0]]
-                elif new_ylim[1] > self.img_height:  # Changed from img_height variable lookup
+                elif new_ylim[1] > self.img_height:
                     new_ylim = [self.img_height - (ylim[1] - ylim[0]), self.img_height]
             
             # Apply new limits
             self.ax.set_xlim(new_xlim)
             self.ax.set_ylim(new_ylim)
-            self.canvas.draw_idle()  # Changed from draw() to draw_idle()
+            
+            # Only call draw_idle if we have a pan background OR if this isn't the first pan
+            if self.pan_background_image is not None or self._first_pan_done == True:
+                self.canvas.draw_idle()
+            else:
+                # For the first pan without background, mark that we've done the first pan
+                self._first_pan_done = True
+                # Force a proper display update instead of draw_idle
+                self.update_display(preserve_zoom=(new_xlim, new_ylim))
             
             # Update pan start position
             self.pan_start = (event.xdata, event.ydata)
@@ -2804,6 +3114,7 @@ class ImageViewerWindow(QMainWindow):
         self.pan_background_image = self.create_composite_for_pan()
         self.pan_zoom_state = (current_xlim, current_ylim)
 
+
     def create_composite_for_pan(self):
         """Create a properly rendered composite image for panning with downsample support"""
         # Get active channels and dimensions (copied from update_display)
@@ -2820,8 +3131,33 @@ class ImageViewerWindow(QMainWindow):
         self.original_dims = (min_height, min_width)
         
         # Get current downsample factor
-        downsample_factor = getattr(self, 'downsample_factor', 1)
-        
+        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
+
+
+        # Calculate the visible region in pixel coordinates
+        x_min = max(0, int(np.floor(current_xlim[0] + 0.5)))
+        x_max = min(min_width, int(np.ceil(current_xlim[1] + 0.5)))
+        y_min = max(0, int(np.floor(current_ylim[1] + 0.5)))  # Note: y is flipped
+        y_max = min(min_height, int(np.ceil(current_ylim[0] + 0.5)))
+
+        box_len = x_max - x_min
+        box_height = y_max - y_min
+        x_min = max(0, x_min - box_len)
+        x_max = min(self.shape[2], x_max + box_len)
+        y_min = max(0, y_min - box_height)
+        y_max = min(self.shape[1], y_max + box_height)
+
+        # If using image pyramids
+        size = (x_max - x_min) * (y_max - y_min)
+        val = int(np.ceil(size/(3000 * 3000)))
+        if self.shape[1] * self.shape[2] > 3000 * 3000 * val:
+            val = 3
+
+        self.validate_downsample_input(text = val, update = False)
+
+        downsample_factor = self.downsample_factor
+
         # Calculate display dimensions (downsampled)
         display_height = min_height // downsample_factor
         display_width = min_width // downsample_factor
@@ -2930,6 +3266,7 @@ class ImageViewerWindow(QMainWindow):
         # Convert to 0-255 range for display
         return (composite * 255).astype(np.uint8)
 
+
     def apply_machine_colormap(self, image):
         """Apply the special machine window colormap for channel 2"""
         rgba = np.zeros((*image.shape, 4), dtype=np.float32)
@@ -3012,7 +3349,7 @@ class ImageViewerWindow(QMainWindow):
         
         return result
 
-    def update_display_pan_mode(self):
+    def update_display_pan_mode(self, current_xlim, current_ylim):
         """Lightweight display update for pan preview mode with downsample support"""
 
         if self.is_pan_preview and self.pan_background_image is not None:
@@ -3030,17 +3367,76 @@ class ImageViewerWindow(QMainWindow):
                 downsample_factor = getattr(self, 'downsample_factor', 1)
                 height *= downsample_factor
                 width *= downsample_factor
+
+            def crop_image(image, y_start, y_end, x_start, x_end):
+                # Crop
+                if len(image.shape) == 2:
+                    cropped = image[y_start:y_end, x_start:x_end]
+                elif len(image.shape) == 3:
+                    cropped = image[y_start:y_end, x_start:x_end, :]
+                else:
+                    cropped = image
+                
+                return cropped
+
+
+            downsample_factor = self.downsample_factor
+            min_height, min_width = self.original_dims
+
+            # Calculate the visible region in pixel coordinates
+            x_min = max(0, int(np.floor(current_xlim[0] + 0.5)))
+            x_max = min(min_width, int(np.ceil(current_xlim[1] + 0.5)))
+            y_min = max(0, int(np.floor(current_ylim[1] + 0.5)))  # Note: y is flipped
+            y_max = min(min_height, int(np.ceil(current_ylim[0] + 0.5)))
+
+            box_len = x_max - x_min
+            box_height = y_max - y_min
+            x_min = max(0, x_min - box_len)
+            x_max = min(self.shape[2], x_max + box_len)
+            y_min = max(0, y_min - box_height)
+            y_max = min(self.shape[1], y_max + box_height)
+
+            # Add some padding to avoid edge artifacts during pan/zoom
+            padding = max(10, downsample_factor * 2)
+            x_min_padded = max(0, x_min - padding)
+            x_max_padded = min(min_width, x_max + padding)
+            y_min_padded = max(0, y_min - padding)
+            y_max_padded = min(min_height, y_max + padding)
+
+            # Convert coordinates to downsampled space for cropping
+            downsample_factor = self.downsample_factor
+
+            # Convert to downsampled coordinates for cropping
+            x_min_ds = x_min // downsample_factor
+            x_max_ds = x_max // downsample_factor  
+            y_min_ds = y_min // downsample_factor
+            y_max_ds = y_max // downsample_factor
+
+            # Add padding in downsampled space
+            padding_ds = max(10 // downsample_factor, 2)
+            x_min_padded_ds = max(0, x_min_ds - padding_ds)
+            x_max_padded_ds = min(self.pan_background_image.shape[1], x_max_ds + padding_ds)
+            y_min_padded_ds = max(0, y_min_ds - padding_ds)
+            y_max_padded_ds = min(self.pan_background_image.shape[0], y_max_ds + padding_ds)
+
+            # Crop using downsampled coordinates
+            display_image = crop_image(
+                self.pan_background_image, y_min_padded_ds, y_max_padded_ds, 
+                x_min_padded_ds, x_max_padded_ds)
             
+            # Calculate the extent for the cropped region (in original coordinates)
+            crop_extent = (x_min_padded - 0.5, x_max_padded - 0.5, 
+                          y_max_padded - 0.5, y_min_padded - 0.5)
+
             # Display the composite background with preserved zoom
             # Use extent to stretch downsampled image back to original coordinate space
-            self.ax.imshow(self.pan_background_image, 
-                          extent=(-0.5, width-0.5, height-0.5, -0.5),
+            self.ax.imshow(display_image, 
+                          extent=crop_extent,
                           aspect='equal')
             
             # Restore the zoom state from when pan began
-            if hasattr(self, 'pan_zoom_state'):
-                self.ax.set_xlim(self.pan_zoom_state[0])
-                self.ax.set_ylim(self.pan_zoom_state[1])
+            self.ax.set_xlim(current_xlim)
+            self.ax.set_ylim(current_ylim)
             
             # Get downsample factor for title display
             downsample_factor = getattr(self, 'downsample_factor', 1)
@@ -3049,7 +3445,7 @@ class ImageViewerWindow(QMainWindow):
             self.ax.set_xlabel('X')
             self.ax.set_ylabel('Y')
             if downsample_factor > 1:
-                self.ax.set_title(f'Slice {self.current_slice} (DS: {downsample_factor}x)')
+                self.ax.set_title(f'Slice {self.current_slice}')
             else:
                 self.ax.set_title(f'Slice {self.current_slice}')
             self.ax.xaxis.label.set_color('black')
@@ -3091,6 +3487,15 @@ class ImageViewerWindow(QMainWindow):
 
         if self.pan_mode:
             
+            # Update display to show only background
+            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
+            # Update display to show only background
+            if self.pan_background_image is not None:
+                self.update_display_pan_mode(current_xlim, current_ylim)
+            else:            
+                self.update_display(preserve_zoom=(current_xlim, current_ylim))
+            
             self.panning = False
             self.pan_start = None
             self.canvas.setCursor(Qt.CursorShape.OpenHandCursor)
@@ -3111,9 +3516,13 @@ class ImageViewerWindow(QMainWindow):
                     self.show_crop_dialog(args)
 
                 elif self.zoom_mode: #Optional targeted zoom
+                    # Calculate aspect ratio to avoid zooming into very thin rectangles
+                    aspect_ratio = width / height if height > 0 else float('inf')
                     
-                    self.ax.set_xlim([x0, x0 + width])
-                    self.ax.set_ylim([y0 + height, y0])
+                    # Skip zoom if the rectangle is too narrow/thin (adjust thresholds as needed)
+                    if width > 10 and height > 10 and 0.1 < aspect_ratio < 10:
+                        self.ax.set_xlim([x0, x0 + width])
+                        self.ax.set_ylim([y0 + height, y0])
 
                     self.zoom_changed = True  # Flag that zoom has changed
                     
@@ -3710,32 +4119,19 @@ class ImageViewerWindow(QMainWindow):
         # Initialize downsample factor
         self.downsample_factor = 1
         
-        """
         # Create container widget for corner controls
         corner_widget = QWidget()
         corner_layout = QHBoxLayout(corner_widget)
         corner_layout.setContentsMargins(5, 0, 5, 0)
         
-        # Add downsample control
-        downsample_label = QLabel("Downsample Display:")
-        downsample_label.setStyleSheet("color: black; font-size: 11px;")
-        corner_layout.addWidget(downsample_label)
-        
-        self.downsample_input = QLineEdit("1")
-        self.downsample_input.setFixedWidth(40)
-        self.downsample_input.setFixedHeight(25)
-        self.downsample_input.setStyleSheet("""
-            #QLineEdit {
-                #border: 1px solid gray;
-                #border-radius: 2px;
-                #padding: 1px;
-                #font-size: 11px;
-            #}
-        """)
-        self.downsample_input.textChanged.connect(self.on_downsample_changed)
-        self.downsample_input.editingFinished.connect(self.validate_downsample_input)
-        corner_layout.addWidget(self.downsample_input)
         
+        # Add after your other buttons
+        self.popup_button = QPushButton("⤴")  # or "🔗" or "⤴"
+        self.popup_button.setFixedSize(40, 40)
+        self.popup_button.setToolTip("Pop out canvas")
+        self.popup_button.clicked.connect(self.popup_canvas)
+        corner_layout.addWidget(self.popup_button)
+
         # Add some spacing
         corner_layout.addSpacing(10)
 
@@ -3748,12 +4144,6 @@ class ImageViewerWindow(QMainWindow):
         
         # Set as corner widget
         menubar.setCornerWidget(corner_widget, Qt.Corner.TopRightCorner)
-        """
-        cam_button = QPushButton("📷")
-        cam_button.setFixedSize(40, 40)
-        cam_button.setStyleSheet("font-size: 24px;")  # Makes emoji larger
-        cam_button.clicked.connect(self.snap)
-        menubar.setCornerWidget(cam_button, Qt.Corner.TopRightCorner)
 
     def on_downsample_changed(self, text):
         """Called whenever the text in the downsample input changes"""
@@ -3799,11 +4189,6 @@ class ImageViewerWindow(QMainWindow):
                 self.downsample_factor = 1
 
         self.throttle = self.shape[1] * self.shape[2] > 3000 * 3000 * self.downsample_factor
-        if self.machine_window is not None:
-            if self.throttle: #arbitrary throttle for large arrays.
-                self.machine_window.update_interval = 10
-            else:
-                self.machine_window.update_interval = 1  # Increased to 1s
         
         # Optional: Trigger display update if you want immediate effect
         if update:
@@ -4580,7 +4965,8 @@ class ImageViewerWindow(QMainWindow):
 
             if directory != "":
 
-                self.reset(network = True, xy_scale = 1, z_scale = 1, edges = True, network_overlay = True, id_overlay = True, update = False)
+                self.reset(network = True, xy_scale = 1, z_scale = 1, nodes = True, edges = True, network_overlay = True, id_overlay = True, update = False)
+
 
                 my_network.assemble(directory)
 
@@ -4607,7 +4993,7 @@ class ImageViewerWindow(QMainWindow):
                     if channel is not None:
                         self.slice_slider.setEnabled(True)
                         self.slice_slider.setMinimum(0)
-                        self.slice_slider.setMaximum(channel.shape[0] - 1)
+                        self.slice_slider.setMaximum(self.shape[0] - 1)
                         self.slice_slider.setValue(0)
                         self.current_slice = 0
                         break
@@ -4893,6 +5279,7 @@ class ImageViewerWindow(QMainWindow):
         """Load a channel and enable active channel selection if needed."""
 
         try:
+
             self.hold_update = True
             if not data:  # For solo loading
                 filename, _ = QFileDialog.getOpenFileName(
@@ -5092,7 +5479,12 @@ class ImageViewerWindow(QMainWindow):
             self.current_operation = []
             self.current_operation_type = None
 
-            if not end_paint:
+            if self.pan_mode:
+                self.pan_button.click()
+                if self.show_channels:
+                    self.channel_buttons[channel_index].click()
+                    self.channel_buttons[channel_index].click()
+            elif not end_paint:
 
                 self.update_display(reset_resize = reset_resize, preserve_zoom = preserve_zoom)
 
@@ -5334,6 +5726,8 @@ class ImageViewerWindow(QMainWindow):
                 self.hold_update = False
             #if self.machine_window is not None:
                 #self.machine_window.poke_segmenter()
+            if self.pan_mode:
+                self.pan_button.click()
             self.pending_slice = None
 
     def update_brightness(self, channel_index, values):
@@ -5370,7 +5764,7 @@ class ImageViewerWindow(QMainWindow):
                     self.resume = False
                 if self.prev_down != self.downsample_factor:
                     self.validate_downsample_input(text = self.prev_down)
-                    return
+                return
            
             if self.static_background is not None:
                 # Your existing virtual strokes conversion logic
@@ -5455,17 +5849,18 @@ class ImageViewerWindow(QMainWindow):
             y_min = max(0, int(np.floor(current_ylim[1] + 0.5)))  # Note: y is flipped
             y_max = min(min_height, int(np.ceil(current_ylim[0] + 0.5)))
 
-            if not self.pan_mode: # If using image pyramids
-                size = (x_max - x_min) * (y_max - y_min)
-                if size < (3000 * 3000): # Smaller window
-                    val = 1
-                elif size > (3000 * 3000) and size < (6000 * 6000): # Med window
-                    val = 2
-                elif size > (6000 * 6000) and size < (9000 * 9000): # Large window
-                    val = 3
-                elif size > (9000 * 9000): # Very large window
-                    val = 3
-                self.validate_downsample_input(text = val, update = False)
+            if self.pan_mode:
+                box_len = (x_max - x_min)
+                box_height = (y_max - y_min)
+                x_min = max(0, x_min - box_len)
+                x_max = min(self.shape[2], x_max + box_len)
+                y_min = max(0, y_min - box_height)
+                y_max = min(self.shape[1], y_max + box_height)
+
+            size = (x_max - x_min) * (y_max - y_min)
+            val = int(np.ceil(size/(3000 * 3000)))
+            self.validate_downsample_input(text = val, update = False)
+
             downsample_factor = self.downsample_factor
 
             # Add some padding to avoid edge artifacts during pan/zoom
@@ -5507,6 +5902,7 @@ class ImageViewerWindow(QMainWindow):
                     return cropped[::factor, ::factor, :]
                 else:
                     return cropped
+
             
             # Update channel images efficiently with cropping and downsampling
             for channel in range(4):
@@ -6707,7 +7103,7 @@ class BrightnessContrastDialog(QDialog):
             self.debounce_timer.setSingleShot(True)
             self.debounce_timer.timeout.connect(self._apply_pending_updates)
             self.pending_updates = {}
-            self.debounce_delay = 300  # 300ms delay
+            self.debounce_delay = 20  # 300ms delay
 
             # Connect signals
             slider.valueChanged.connect(lambda values, ch=i: self.on_slider_change(ch, values))
@@ -9920,6 +10316,7 @@ class MachineWindow(QMainWindow):
 
             self.num_chunks = 0
 
+
         except:
             return
 
@@ -10382,9 +10779,8 @@ class MachineWindow(QMainWindow):
         print("Finished segmentation moved to Overlay 2. Use File -> Save(As) for disk saving.")
 
     def closeEvent(self, event):
-
         try:
-            if self.parent().isVisible():
+            if self.parent() and self.parent().isVisible():
                 if self.confirm_close_dialog():
                     # Clean up resources before closing
                     if self.brush_button.isChecked():
@@ -10397,7 +10793,6 @@ class MachineWindow(QMainWindow):
                     # Kill the segmentation thread and wait for it to finish
                     self.kill_segmentation()
                     time.sleep(0.2)  # Give additional time for cleanup
-
                     try:
                         self.parent().channel_data[0] = self.parent().reduce_rgb_dimension(self.parent().channel_data[0], 'weight')
                         self.update_display()
@@ -10405,10 +10800,20 @@ class MachineWindow(QMainWindow):
                         pass
                     
                     self.parent().machine_window = None
+                    event.accept()  # IMPORTANT: Accept the close event
                 else:
-                    event.ignore()
-        except:
-            pass
+                    event.ignore()  # User cancelled, ignore the close
+            else:
+                # Parent doesn't exist or isn't visible, just close
+                if hasattr(self, 'parent') and self.parent():
+                    self.parent().machine_window = None
+                event.accept()
+        except Exception as e:
+            print(f"Error in closeEvent: {e}")
+            # Even if there's an error, allow the window to close
+            if hasattr(self, 'parent') and self.parent():
+                self.parent().machine_window = None
+            event.accept()
 
 
 
@@ -10428,10 +10833,7 @@ class SegmentationWorker(QThread):
         self.mem_lock = mem_lock
         self._stop = False
         self._paused = False  # Add pause flag
-        if self.machine_window.parent().shape[1] * self.machine_window.parent().shape[2] > 3000 * 3000 * self.machine_window.parent().downsample_factor: #arbitrary throttle for large arrays.
-            self.update_interval = 10
-        else:
-            self.update_interval = 1  # Increased to 1s
+        self.update_interval = 2  # Increased to 2s
         self.chunks_since_update = 0
         self.chunks_per_update = 5  # Only update every 5 chunks
         self.poked = False # If it should wake up or not

{nettracer3d-0.9.1 → nettracer3d-0.9.2/src/nettracer3d.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nettracer3d
-Version: 0.9.1
+Version: 0.9.2
 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,9 +110,8 @@ 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.9.1 Updates --
-	* Adjusted the segment by 3D function to now show the 3D chunks in the preview mode. Previously it showed 2D segmentations in the preview which finished the current plane faster but didn't show accurate training data.
-	* Adjusted the neighborhood heatmap predicted range value to now just simulate a uniform distribution rather than trying to use a mathematical algorithm. 
-	* The image display window now uses image pyramids and cropping for zoom ins so it should run a lot faster on bigger images.
-	* The community UMAP can now color them by neighborhood.
-	* No longer zooms all the way out by default with right click in zoom mode. Now user needs to Shift + Right Click.
+-- Version 0.9.2 Updates --
+	* Image viewer canvas window can now be popped out into a separate window.
+	* Image pyramid calculation is more dynamic instead of using arbitrary size thresholds.
+	* Adjusted pan mode
+	* Some bug fixes.