nettracer3d 0.9.0__py3-none-any.whl → 0.9.2__py3-none-any.whl

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)
@@ -466,6 +466,299 @@ 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."""
         # Single increment first
@@ -500,7 +793,6 @@ class ImageViewerWindow(QMainWindow):
             self.slice_slider.setValue(new_value)
         elif self.scroll_direction > 0 and new_value <= self.slice_slider.maximum():
             self.slice_slider.setValue(new_value)
-        
 
     def create_highlight_overlay(self, node_indices=None, edge_indices=None, overlay1_indices = None, overlay2_indices = None, bounds = False):
         """
@@ -514,6 +806,17 @@ class ImageViewerWindow(QMainWindow):
         self.mini_overlay = False #If this method is ever being called, it means we are rendering the entire overlay so mini overlay needs to reset.
         self.mini_overlay_data = None
 
+
+        if not self.high_button.isChecked():
+
+            if len(self.clicked_values['edges']) > 0:
+                self.format_for_upperright_table(self.clicked_values['edges'], title = 'Selected Edges')
+            if len(self.clicked_values['nodes']) > 0:
+                self.format_for_upperright_table(self.clicked_values['nodes'], title = 'Selected Nodes')
+
+            return
+
+
         def process_chunk(chunk_data, indices_to_check):
             """Process a single chunk of the array to create highlight mask"""
             mask = np.isin(chunk_data, indices_to_check)
@@ -550,7 +853,7 @@ class ImageViewerWindow(QMainWindow):
         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 not node_indices and not edge_indices and not overlay1_indices and not overlay2_indices:
+        if not node_indices and not edge_indices and not overlay1_indices and not overlay2_indices and self.machine_window is None:
             self.highlight_overlay = None
             self.highlight_bounds = None
             self.update_display(preserve_zoom=(current_xlim, current_ylim))
@@ -623,7 +926,7 @@ class ImageViewerWindow(QMainWindow):
             self.highlight_overlay = np.maximum(self.highlight_overlay, overlay1_overlay)
         if overlay2_overlay is not None:
             self.highlight_overlay = np.maximum(self.highlight_overlay, overlay2_overlay)
-                
+        
         # Update display
         self.update_display(preserve_zoom=(current_xlim, current_ylim))
 
@@ -822,9 +1125,6 @@ class ImageViewerWindow(QMainWindow):
 
 
 
-        
-
-
 
 #METHODS RELATED TO RIGHT CLICK:
     
@@ -1991,7 +2291,10 @@ class ImageViewerWindow(QMainWindow):
                             del my_network.network_lists[0][i]
                             del my_network.network_lists[1][i]
                             del my_network.network_lists[2][i]
-
+                    for node in self.clicked_values['nodes']:
+                        del my_network.node_centroids[node]
+                        del my_network.node_identities[node]
+                        del my_network.communities[node]
 
 
             if len(self.clicked_values['edges']) > 0:
@@ -2006,6 +2309,8 @@ class ImageViewerWindow(QMainWindow):
                             del my_network.network_lists[0][i]
                             del my_network.network_lists[1][i]
                             del my_network.network_lists[2][i]
+                    for node in self.clicked_values['edges']:
+                        del my_network.edge_centroids[edge]
 
             my_network.network_lists = my_network.network_lists
 
@@ -2021,7 +2326,7 @@ class ImageViewerWindow(QMainWindow):
                 for column in range(model.columnCount(None)):
                     self.network_table.resizeColumnToContents(column)
 
-            self.show_centroid_dialog()
+            #self.show_centroid_dialog()
         except Exception as e:
             print(f"Error: {e}")
 
@@ -2147,11 +2452,16 @@ class ImageViewerWindow(QMainWindow):
         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.high_button.isChecked():
+        if self.high_button.isChecked() and self.machine_window is None:
             if self.highlight_overlay is None and ((len(self.clicked_values['nodes']) + len(self.clicked_values['edges'])) > 0):
                 if self.needs_mini:
                     self.create_mini_overlay(node_indices = self.clicked_values['nodes'], edge_indices = self.clicked_values['edges'])
                     self.needs_mini = False
+                else:
+                    self.create_highlight_overlay(node_indices = self.clicked_values['nodes'], edge_indices = self.clicked_values['edges'])
+            else:
+                self.create_highlight_overlay(node_indices = self.clicked_values['nodes'], edge_indices = self.clicked_values['edges'])
+
         
         self.update_display(preserve_zoom=(current_xlim, current_ylim))
 
@@ -2164,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
@@ -2187,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:
@@ -2234,15 +2544,31 @@ class ImageViewerWindow(QMainWindow):
                 # Store current channel visibility state
                 self.pre_pan_channel_state = self.channel_visible.copy()
                 
-                # Create static background from currently visible channels
-                self.create_pan_background()
-                
-                # Hide all channels and show only the background
-                self.channel_visible = [False] * 4
-                self.is_pan_preview = True
-                
-                # Update display to show only background
-                self.update_display_pan_mode()
+                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()
@@ -2714,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]
@@ -2728,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)
@@ -2781,8 +3114,9 @@ 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"""
+        """Create a properly rendered composite image for panning with downsample support"""
         # Get active channels and dimensions (copied from update_display)
         active_channels = [i for i in range(4) if self.channel_data[i] is not None]
         if active_channels:
@@ -2793,8 +3127,58 @@ class ImageViewerWindow(QMainWindow):
         else:
             return None
         
-        # Create a blank RGBA composite to accumulate all channels
-        composite = np.zeros((min_height, min_width, 4), dtype=np.float32)
+        # Store original dimensions for coordinate mapping
+        self.original_dims = (min_height, min_width)
+        
+        # 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
+
+
+        # 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
+        
+        # Helper function to downsample image (same as in update_display)
+        def downsample_image(image, factor):
+            if factor == 1:
+                return image
+            
+            # Handle different image types
+            if len(image.shape) == 2:
+                # Grayscale
+                return image[::factor, ::factor]
+            elif len(image.shape) == 3:
+                # RGB/RGBA
+                return image[::factor, ::factor, :]
+            else:
+                return image
+        
+        # Create a blank RGBA composite to accumulate all channels (using display dimensions)
+        composite = np.zeros((display_height, display_width, 4), dtype=np.float32)
         
         # Process each visible channel exactly like update_display does
         for channel in range(4):
@@ -2811,24 +3195,27 @@ class ImageViewerWindow(QMainWindow):
                 else:
                     current_image = self.channel_data[channel]
 
+                # Downsample the image for rendering
+                display_image = downsample_image(current_image, downsample_factor)
+
                 if is_rgb and self.channel_data[channel].shape[-1] == 3:
                     # RGB image - convert to RGBA and blend
-                    rgb_alpha = np.ones((*current_image.shape[:2], 4), dtype=np.float32)
-                    rgb_alpha[:, :, :3] = current_image.astype(np.float32) / 255.0
+                    rgb_alpha = np.ones((*display_image.shape[:2], 4), dtype=np.float32)
+                    rgb_alpha[:, :, :3] = display_image.astype(np.float32) / 255.0
                     rgb_alpha[:, :, 3] = 0.7  # Same alpha as update_display
                     composite = self.blend_layers(composite, rgb_alpha)
                     
                 elif is_rgb and self.channel_data[channel].shape[-1] == 4:
                     # RGBA image - blend directly
-                    rgba_image = current_image.astype(np.float32) / 255.0
+                    rgba_image = display_image.astype(np.float32) / 255.0
                     composite = self.blend_layers(composite, rgba_image)
                     
                 else:
                     # Regular channel processing (same logic as update_display)
                     if self.min_max[channel][0] == None:
-                        self.min_max[channel][0] = np.min(current_image)
+                        self.min_max[channel][0] = np.min(self.channel_data[channel])
                     if self.min_max[channel][1] == None:
-                        self.min_max[channel][1] = np.max(current_image)
+                        self.min_max[channel][1] = np.max(self.channel_data[channel])
 
                     img_min = self.min_max[channel][0]
                     img_max = self.min_max[channel][1]
@@ -2840,16 +3227,16 @@ class ImageViewerWindow(QMainWindow):
                         vmin = img_min + (img_max - img_min) * self.channel_brightness[channel]['min']
                         vmax = img_min + (img_max - img_min) * self.channel_brightness[channel]['max']
                     
-                    # Normalize the image
+                    # Normalize the downsampled image
                     if vmin == vmax:
-                        normalized_image = np.zeros_like(current_image)
+                        normalized_image = np.zeros_like(display_image)
                     else:
-                        normalized_image = np.clip((current_image - vmin) / (vmax - vmin), 0, 1)
+                        normalized_image = np.clip((display_image - vmin) / (vmax - vmin), 0, 1)
                     
                     # Apply channel color and alpha
                     if channel == 2 and self.machine_window is not None:
                         # Special case for machine window channel 2
-                        channel_rgba = self.apply_machine_colormap(current_image)
+                        channel_rgba = self.apply_machine_colormap(display_image)
                     else:
                         # Regular channel with custom color
                         color = self.base_colors[channel]
@@ -2862,21 +3249,24 @@ class ImageViewerWindow(QMainWindow):
                     # Blend this channel into the composite
                     composite = self.blend_layers(composite, channel_rgba)
         
-        # Add highlight overlays if they exist (same logic as update_display)
+        # Add highlight overlays if they exist (with downsampling)
         if self.mini_overlay and self.highlight and self.machine_window is None:
-            highlight_rgba = self.create_highlight_rgba(self.mini_overlay_data, yellow=True)
+            display_overlay = downsample_image(self.mini_overlay_data, downsample_factor)
+            highlight_rgba = self.create_highlight_rgba(display_overlay, yellow=True)
             composite = self.blend_layers(composite, highlight_rgba)
         elif self.highlight_overlay is not None and self.highlight:
             highlight_slice = self.highlight_overlay[self.current_slice]
+            display_highlight = downsample_image(highlight_slice, downsample_factor)
             if self.machine_window is None:
-                highlight_rgba = self.create_highlight_rgba(highlight_slice, yellow=True)
+                highlight_rgba = self.create_highlight_rgba(display_highlight, yellow=True)
             else:
-                highlight_rgba = self.create_highlight_rgba(highlight_slice, yellow=False)
+                highlight_rgba = self.create_highlight_rgba(display_highlight, yellow=False)
             composite = self.blend_layers(composite, highlight_rgba)
         
         # 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)
@@ -2902,7 +3292,7 @@ class ImageViewerWindow(QMainWindow):
         if yellow:
             # Yellow highlight
             mask = highlight_data > 0
-            rgba[mask] = [1, 1, 0, 0.5]  # Yellow with alpha 0.5
+            rgba[mask] = [1, 1, 0, 0.8]  # Yellow with alpha 0.5
         else:
             # Multi-color highlight for machine window
             mask_1 = (highlight_data == 1)
@@ -2914,7 +3304,31 @@ class ImageViewerWindow(QMainWindow):
 
     def blend_layers(self, base, overlay):
         """Alpha blend two RGBA layers"""
-        # Standard alpha blending formula
+        
+        def resize_overlay_to_base(overlay_arr, base_arr):
+            base_height, base_width = base_arr.shape[:2]
+            overlay_height, overlay_width = overlay_arr.shape[:2]
+            
+            # First crop if overlay is larger
+            cropped_overlay = overlay_arr[:base_height, :base_width]
+            
+            # Then pad if still smaller after cropping
+            current_height, current_width = cropped_overlay.shape[:2]
+            pad_height = base_height - current_height
+            pad_width = base_width - current_width
+            
+            if pad_height > 0 or pad_width > 0:
+                cropped_overlay = np.pad(cropped_overlay,
+                                        ((0, pad_height), (0, pad_width), (0, 0)),
+                                        mode='constant', constant_values=0)
+            
+            return cropped_overlay
+        
+        # Resize the ENTIRE overlay array to match base dimensions
+        if overlay.shape[:2] != base.shape[:2]:
+            overlay = resize_overlay_to_base(overlay, base)
+        
+        # Now extract alpha channels (they should be the same size)
         alpha_overlay = overlay[:, :, 3:4]
         alpha_base = base[:, :, 3:4]
         
@@ -2935,31 +3349,105 @@ class ImageViewerWindow(QMainWindow):
         
         return result
 
-    def update_display_pan_mode(self):
-        """Lightweight display update for pan preview mode"""
+    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:
             # Clear and setup axes
             self.ax.clear()
             self.ax.set_facecolor('black')
             
-            # Get dimensions
-            height, width = self.pan_background_image.shape[:2]
-            
+            # Get original dimensions (before downsampling)
+            if hasattr(self, 'original_dims') and self.original_dims:
+                height, width = self.original_dims
+            else:
+                # Fallback to pan background image dimensions
+                height, width = self.pan_background_image.shape[:2]
+                # If we have downsample factor, scale back up
+                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
-            self.ax.imshow(self.pan_background_image, 
-                          extent=(-0.5, width-0.5, height-0.5, -0.5),
+            # Use extent to stretch downsampled image back to original coordinate space
+            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)
             
             # Style the axes (same as update_display)
             self.ax.set_xlabel('X')
-            self.ax.set_ylabel('Y') 
-            self.ax.set_title(f'Slice {self.current_slice}')
+            self.ax.set_ylabel('Y')
+            if downsample_factor > 1:
+                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')
             self.ax.yaxis.label.set_color('black')
             self.ax.title.set_color('black')
@@ -2967,7 +3455,7 @@ class ImageViewerWindow(QMainWindow):
             for spine in self.ax.spines.values():
                 spine.set_color('black')
                 
-            # Add measurement points if they exist (same as update_display)
+            # Add measurement points if they exist (coordinates remain in original space)
             for point in self.measurement_points:
                 x1, y1, z1 = point['point1']
                 x2, y2, z2 = point['point2']
@@ -2999,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)
@@ -3019,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
                     
@@ -3093,7 +3594,10 @@ class ImageViewerWindow(QMainWindow):
                 except:
                     pass
                 self.selection_rect = None
-                self.canvas.draw()
+                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))  
+                #self.canvas.draw()
 
         elif self.zoom_mode:
             # Handle zoom mode press
@@ -3126,11 +3630,13 @@ class ImageViewerWindow(QMainWindow):
                 
                 new_xlim = [xdata - x_range, xdata + x_range]
                 new_ylim = [ydata - y_range, ydata + y_range]
+
+                shift_pressed = 'shift' in event.modifiers
                 
-                if (new_xlim[0] <= self.original_xlim[0] or 
-                    new_xlim[1] >= self.original_xlim[1] or
-                    new_ylim[0] <= self.original_ylim[0] or
-                    new_ylim[1] >= self.original_ylim[1]):
+                if (new_xlim[0] <= 0 or 
+                    new_xlim[1] >= self.shape[2] or
+                    new_ylim[0] <= 0 or
+                    new_ylim[1] >= self.shape[1]) or shift_pressed:
                     self.ax.set_xlim(self.original_xlim)
                     self.ax.set_ylim(self.original_ylim)
                 else:
@@ -3142,7 +3648,10 @@ class ImageViewerWindow(QMainWindow):
                     if not hasattr(self, 'zoom_changed'):
                         self.zoom_changed = False
 
-            self.canvas.draw()
+            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))    
+            #self.canvas.draw()
 
         #  Handle brush mode cleanup with paint session management
         if self.brush_mode and hasattr(self, 'painting') and self.painting:
@@ -3277,7 +3786,7 @@ class ImageViewerWindow(QMainWindow):
                 
                 if not hasattr(self, 'zoom_changed'):
                     self.zoom_changed = False
-                
+
             elif event.button == 3:  # Right click - zoom out
                 x_range = (current_xlim[1] - current_xlim[0])
                 y_range = (current_ylim[1] - current_ylim[0])
@@ -3296,10 +3805,11 @@ class ImageViewerWindow(QMainWindow):
                     self.ax.set_ylim(new_ylim)
 
 
-                self.zoom_changed = False  # Flag that zoom has changed
-                
-            
-            self.canvas.draw()
+            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))                
+
+            #self.canvas.draw()
         
         elif event.button == 3:  # Right click
             self.create_context_menu(event)
@@ -3606,11 +4116,85 @@ class ImageViewerWindow(QMainWindow):
         help_button = menubar.addAction("Help")
         help_button.triggered.connect(self.help_me)
 
+        # 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 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)
+
+        # Add camera button
         cam_button = QPushButton("📷")
         cam_button.setFixedSize(40, 40)
-        cam_button.setStyleSheet("font-size: 24px;")  # Makes emoji larger
+        cam_button.setStyleSheet("font-size: 24px;")
         cam_button.clicked.connect(self.snap)
-        menubar.setCornerWidget(cam_button, Qt.Corner.TopRightCorner)
+        corner_layout.addWidget(cam_button)
+        
+        # Set as corner widget
+        menubar.setCornerWidget(corner_widget, Qt.Corner.TopRightCorner)
+
+    def on_downsample_changed(self, text):
+        """Called whenever the text in the downsample input changes"""
+        try:
+            if text.strip() == "":
+                self.downsample_factor = 1
+            else:
+                value = float(text)
+                if value <= 0:
+                    self.downsample_factor = 1
+                else:
+                    self.downsample_factor = int(value) if value == int(value) else value
+        except (ValueError, TypeError):
+            self.downsample_factor = 1
+
+    def validate_downsample_input(self, text = None, update = True):
+        """Called when user finishes editing (loses focus or presses Enter)"""
+        if text:
+            self.downsample_factor = text
+        else:
+            try: # If enabled for manual display downsampling
+                text = self.downsample_input.text().strip()
+                if text == "":
+                    # Empty input - set to default
+                    self.downsample_factor = 1
+                    self.downsample_input.setText("1")
+                else:
+                    value = int(text)
+                    if value < 1:
+                        # Invalid value - reset to default
+                        self.downsample_factor = 1
+                        self.downsample_input.setText("1")
+                    else:
+                        # Valid value - use it (prefer int if possible)
+                        if value == int(value):
+                            self.downsample_factor = int(value)
+                            self.downsample_input.setText(str(int(value)))
+                        else:
+                            self.downsample_factor = value
+                            self.downsample_input.setText(f"{value:.1f}")
+            except:
+                # Invalid input - reset to default
+                self.downsample_factor = 1
+
+        self.throttle = self.shape[1] * self.shape[2] > 3000 * 3000 * self.downsample_factor
+        
+        # Optional: Trigger display update if you want immediate effect
+        if update:
+            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))
 
     def snap(self):
         try:
@@ -3643,7 +4227,14 @@ class ImageViewerWindow(QMainWindow):
                     filename += '.png'
                     format_type = 'png'
                 
-                # Method 1: Save with axes bbox (recommended)
+                if self.downsample_factor > 1:
+                    self.pan_mode = True # Update display will ignore downsamples if this is true so we can just use it here
+                    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
+                    self.update_display(preserve_zoom=(current_xlim, current_ylim))
+
+                # Save with axes bbox
                 bbox = self.ax.get_window_extent().transformed(self.figure.dpi_scale_trans.inverted())
                 self.figure.savefig(filename,
                                   dpi=300,
@@ -3654,6 +4245,8 @@ class ImageViewerWindow(QMainWindow):
                                   pad_inches=0)
                 
                 print(f"Axes snapshot saved: {filename}")
+
+                self.toggle_pan_mode() # Assesses pan state since we messed with its vars potentially
                 
         except Exception as e:
             print(f"Error saving snapshot: {e}")
@@ -4372,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)
+                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)
 
@@ -4399,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
@@ -4685,6 +5279,8 @@ 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(
                     self,
@@ -4752,9 +5348,13 @@ class ImageViewerWindow(QMainWindow):
             try:
                 if len(self.channel_data[channel_index].shape) == 3:  # potentially 2D RGB
                     if self.channel_data[channel_index].shape[-1] in (3, 4):  # last dim is 3 or 4
-                        if self.confirm_rgb_dialog():
-                            # User confirmed it's 2D RGB, expand to 4D
+                        if not data and self.shape is None:
+                            if self.confirm_rgb_dialog():
+                                # User confirmed it's 2D RGB, expand to 4D
+                                self.channel_data[channel_index] = np.expand_dims(self.channel_data[channel_index], axis=0)
+                        elif self.shape[0] == 1: # this can only be true if the user already loaded in a 2d image
                             self.channel_data[channel_index] = np.expand_dims(self.channel_data[channel_index], axis=0)
+
             except:
                 pass
 
@@ -4861,6 +5461,11 @@ class ImageViewerWindow(QMainWindow):
                 pass
 
             self.shape = self.channel_data[channel_index].shape
+            if self.shape[1] * self.shape[2] > 3000 * 3000 * self.downsample_factor:
+                self.throttle = True
+            else:
+                self.throttle = False
+
 
             self.img_height, self.img_width = self.shape[1], self.shape[2]
             self.original_ylim, self.original_xlim = (self.shape[1] + 0.5, -0.5), (-0.5, self.shape[2] - 0.5)
@@ -4874,11 +5479,15 @@ 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)
 
-
                 
         except Exception as e:
 
@@ -4890,7 +5499,7 @@ class ImageViewerWindow(QMainWindow):
                     f"Failed to load tiff file: {str(e)}"
                 )
 
-    def delete_channel(self, channel_index, called = True):
+    def delete_channel(self, channel_index, called = True, update = True):
         """Delete the specified channel and update the display."""
         if called:
             # Confirm deletion
@@ -4936,11 +5545,13 @@ class ImageViewerWindow(QMainWindow):
                 else:
                     # If no channels are available, disable active channel selector
                     self.active_channel_combo.setEnabled(False)
+                    self.shape = None # Also there is not an active shape anymore
             
-            # Update display
-            self.update_display()
+            if update:
+                # Update display
+                self.update_display()
 
-    def reset(self, nodes = False, network = False, xy_scale = 1, z_scale = 1, edges = False, search_region = False, network_overlay = False, id_overlay = False):
+    def reset(self, nodes = False, network = False, xy_scale = 1, z_scale = 1, edges = False, search_region = False, network_overlay = False, id_overlay = False, update = True):
         """Method to flexibly reset certain fields to free up the RAM as desired"""
         
         # Set scales first before any clearing operations
@@ -4961,10 +5572,10 @@ class ImageViewerWindow(QMainWindow):
             self.selection_table.setModel(PandasModel(empty_df))
 
         if nodes:
-            self.delete_channel(0, False)
+            self.delete_channel(0, False, update = update)
 
         if edges:
-            self.delete_channel(1, False)
+            self.delete_channel(1, False, update = update)
         try:
             if search_region:
                 my_network.search_region = None
@@ -4972,10 +5583,10 @@ class ImageViewerWindow(QMainWindow):
             pass
 
         if network_overlay:
-            self.delete_channel(2, False)
+            self.delete_channel(2, False, update = update)
 
         if id_overlay:
-            self.delete_channel(3, False)
+            self.delete_channel(3, False, update = update)
 
 
 
@@ -5109,9 +5720,14 @@ class ImageViewerWindow(QMainWindow):
             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'])
-            self.update_display(preserve_zoom=view_settings)
+            if not self.hold_update:
+                self.update_display(preserve_zoom=view_settings)
+            else:
+                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):
@@ -5127,51 +5743,59 @@ class ImageViewerWindow(QMainWindow):
         self.update_display(preserve_zoom = (current_xlim, current_ylim))
 
 
-
-    
-    def update_display(self, preserve_zoom=None, dims = None, called = False, reset_resize = False):
-        """Update the display with currently visible channels and highlight overlay."""
+    def update_display(self, preserve_zoom=None, dims=None, called=False, reset_resize=False, skip=False):
+        """Optimized display update with view-based cropping for performance."""
         try:
-            self.figure.clear()
+            # Initialize reusable components if they don't exist
+            if not hasattr(self, 'channel_images'):
+                self.channel_images = {}
+                self.highlight_image = None
+                self.measurement_artists = []
+                self.axes_initialized = False
+                self.original_dims = None
+            
+            # Handle special states (pan, static background)
             if self.pan_background_image is not None:
-                # Restore previously visible channels
                 self.channel_visible = self.pre_pan_channel_state.copy()
                 self.is_pan_preview = False
                 self.pan_background_image = None
                 if self.resume:
                     self.machine_window.segmentation_worker.resume()
                     self.resume = False
+                if self.prev_down != self.downsample_factor:
+                    self.validate_downsample_input(text = self.prev_down)
+                return
+           
             if self.static_background is not None:
-                # NEW: Convert virtual strokes to real data before cleanup
+                # Your existing virtual strokes conversion logic
                 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()
                 
-                # Restore hidden channels
                 try:
                     for i in self.restore_channels:
                         self.channel_visible[i] = True
                     self.restore_channels = []
                 except:
                     pass
-
                 self.static_background = None
-
+                
+                # Your existing machine_window logic
                 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][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
+            # Get dimensions
             active_channels = [i for i in range(4) if self.channel_data[i] is not None]
             if dims is None:
                 if active_channels:
@@ -5180,247 +5804,260 @@ class ImageViewerWindow(QMainWindow):
                     min_height = min(d[0] for d in dims)
                     min_width = min(d[1] for d in dims)
                 else:
-                    min_height = 1
-                    min_width = 1
+                    min_height = min_width = 1
             else:
-                min_height = dims[0]
-                min_width = dims[1]
+                min_height, min_width = dims[:2]
+            
+            # Store original dimensions for pixel coordinate conversion
+            self.original_dims = (min_height, min_width)
+
+            # Initialize axes only once or when needed
+            if not self.axes_initialized or not hasattr(self, 'ax') or self.ax is None:
+                self.figure.clear()
+                self.figure.patch.set_facecolor('white')
+                self.ax = self.figure.add_subplot(111)
+                self.ax.set_facecolor('black')
+                self.axes_initialized = True
+                
+                # Style the axes once
+                self.ax.set_xlabel('X')
+                self.ax.set_ylabel('Y')
+                self.ax.xaxis.label.set_color('black')
+                self.ax.yaxis.label.set_color('black')
+                self.ax.tick_params(colors='black')
+                for spine in self.ax.spines.values():
+                    spine.set_color('black')
+            else:
+                # Clear only the image data, keep axes structure
+                for img in list(self.ax.get_images()):
+                    img.remove()
+                # Clear measurement points
+                for artist in self.measurement_artists:
+                    artist.remove()
+                self.measurement_artists.clear()
+
+            # Determine the current view bounds (either from preserve_zoom or current state)
+            if preserve_zoom:
+                current_xlim, current_ylim = preserve_zoom
+            else:
+                current_xlim = (-0.5, self.shape[2] - 0.5)
+                current_ylim = (self.shape[1] - 0.5, -0.5)
+            
+            # 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)))
 
-            # Set axes limits before displaying any images
+            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
+            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)
+            
+            # 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)
+
+            # Set limits to original dimensions (important for pixel queries)
             self.ax.set_xlim(-0.5, min_width - 0.5)
             self.ax.set_ylim(min_height - 0.5, -0.5)
+            self.ax.set_title(f'Slice {self.current_slice}')
+            self.ax.title.set_color('black')
             
-            # Create subplot with tight layout and white figure background
-            self.figure.patch.set_facecolor('white')
-            self.ax = self.figure.add_subplot(111)
-            
-            # Store current zoom limits if they exist and weren't provided
-     
-            current_xlim, current_ylim = preserve_zoom if preserve_zoom else (None, None)
-            
-            # Define base colors for each channel with increased intensity
             base_colors = self.base_colors
-            # Set only the axes (image area) background to black
-            self.ax.set_facecolor('black')
             
-            # Display each visible channel
+            # Helper function to crop and downsample image
+            def crop_and_downsample_image(image, y_start, y_end, x_start, x_end, factor):
+                # Crop first
+                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
+                
+                # Then downsample if needed
+                if factor == 1:
+                    return cropped
+                
+                if len(cropped.shape) == 2:
+                    return cropped[::factor, ::factor]
+                elif len(cropped.shape) == 3:
+                    return cropped[::factor, ::factor, :]
+                else:
+                    return cropped
+
+            
+            # Update channel images efficiently with cropping and downsampling
             for channel in range(4):
-                if (self.channel_visible[channel] and 
-                    self.channel_data[channel] is not None):
-                    
-                    # Check if we're dealing with RGB data
-                    is_rgb = len(self.channel_data[channel].shape) == 4 and (self.channel_data[channel].shape[-1] == 3 or self.channel_data[channel].shape[-1] == 4)
+                if self.channel_visible[channel] and self.channel_data[channel] is not None:
+                    # Get current image data
+                    is_rgb = len(self.channel_data[channel].shape) == 4 and (
+                        self.channel_data[channel].shape[-1] in [3, 4])
                     
                     if len(self.channel_data[channel].shape) == 3 and not is_rgb:
                         current_image = self.channel_data[channel][self.current_slice, :, :]
                     elif is_rgb:
-                        current_image = self.channel_data[channel][self.current_slice]  # Already has RGB channels
+                        current_image = self.channel_data[channel][self.current_slice]
                     else:
                         current_image = self.channel_data[channel]
 
+                    # Crop and downsample the image for rendering
+                    display_image = crop_and_downsample_image(
+                        current_image, y_min_padded, y_max_padded, 
+                        x_min_padded, x_max_padded, downsample_factor)
+
                     if is_rgb and self.channel_data[channel].shape[-1] in [3, 4]:
-                        # For RGB/RGBA images, use brightness/contrast to control alpha instead
-                        
-                        # Calculate alpha based on brightness settings
+                        # RGB handling (keep your existing logic)
                         brightness_min = self.channel_brightness[channel]['min']
                         brightness_max = self.channel_brightness[channel]['max']
-                        
-                        # Map brightness range to alpha range (0.0 to 1.0)
-                        # brightness_min controls minimum alpha, brightness_max controls maximum alpha
                         alpha_range = brightness_max - brightness_min
-                        base_alpha = brightness_min                        
-                        # You can adjust these multipliers to control the alpha range
-                        final_alpha = base_alpha + alpha_range  # Scale to reasonable alpha range
-                        final_alpha = np.clip(final_alpha, 0.0, 1.0)  # Ensure valid alpha range
+                        base_alpha = brightness_min
+                        final_alpha = np.clip(base_alpha + alpha_range, 0.0, 1.0)
                         
-                        # Display the image with brightness-controlled alpha
-                        if current_image.shape[-1] == 4:
-                            # For RGBA, multiply existing alpha by our brightness-controlled alpha
-                            img_with_alpha = current_image.copy()
+                        if display_image.shape[-1] == 4:
+                            img_with_alpha = display_image.copy()
                             img_with_alpha[..., 3] = img_with_alpha[..., 3] * final_alpha
-                            self.ax.imshow(img_with_alpha)
+                            # Use crop_extent to place in correct location
+                            im = self.ax.imshow(img_with_alpha, extent=crop_extent)
                         else:
-                            # For RGB, apply brightness-controlled alpha directly
-                            self.ax.imshow(current_image, alpha=final_alpha)
-                            
+                            im = self.ax.imshow(display_image, alpha=final_alpha, extent=crop_extent)
                     else:
-                        # Regular channel processing with colormap (your existing code)
-                        # Calculate brightness/contrast limits from entire volume
+                        # Regular channel processing with optimized normalization
                         if self.min_max[channel][0] is None:
-                            self.min_max[channel][0] = np.min(self.channel_data[channel])
-                        if self.min_max[channel][1] is None:
-                            self.min_max[channel][1] = np.max(self.channel_data[channel])
-                        img_min = self.min_max[channel][0]
-                        img_max = self.min_max[channel][1]
+                            # For very large arrays, consider sampling for min/max
+                            if self.channel_data[channel].size > 1000000:
+                                sample = self.channel_data[channel][::max(1, self.channel_data[channel].shape[0]//100)]
+                                self.min_max[channel] = [np.min(sample), np.max(sample)]
+                            else:
+                                self.min_max[channel] = [np.min(self.channel_data[channel]), 
+                                                       np.max(self.channel_data[channel])]
+                        
+                        img_min, img_max = self.min_max[channel]
                         
-                        # Calculate vmin and vmax, ensuring we don't get a zero range
                         if img_min == img_max:
-                            vmin = img_min
-                            vmax = img_min + 1
+                            vmin, vmax = img_min, img_min + 1
+                            normalized_image = np.zeros_like(display_image)
                         else:
                             vmin = img_min + (img_max - img_min) * self.channel_brightness[channel]['min']
                             vmax = img_min + (img_max - img_min) * self.channel_brightness[channel]['max']
-                        
-                        # Normalize the image safely
-                        if vmin == vmax:
-                            normalized_image = np.zeros_like(current_image)
-                        else:
-                            normalized_image = np.clip((current_image - vmin) / (vmax - vmin), 0, 1)
+                            
+                            if vmin == vmax:
+                                normalized_image = np.zeros_like(display_image)
+                            else:
+                                normalized_image = np.clip((display_image - vmin) / (vmax - vmin), 0, 1)
                         
                         if channel == 2 and self.machine_window is not None:
                             custom_cmap = LinearSegmentedColormap.from_list(
                                 f'custom_{channel}',
-                                [(0, 0, 0, 0),          # transparent for 0
-                                 (0.5, 1, 0.5, 1),      # light green for 1
-                                 (1, 0.5, 0.5, 1)]      # light red for 2
+                                [(0, 0, 0, 0), (0.5, 1, 0.5, 1), (1, 0.5, 0.5, 1)]
                             )
-                            self.ax.imshow(current_image,
-                                         cmap=custom_cmap,
-                                         vmin=0,
-                                         vmax=2,
-                                         alpha=0.7,
-                                         interpolation='nearest',
-                                         extent=(-0.5, min_width-0.5, min_height-0.5, -0.5))
+                            im = self.ax.imshow(display_image, cmap=custom_cmap, vmin=0, vmax=2,
+                                              alpha=0.7, interpolation='nearest', extent=crop_extent)
                         else:
-                            # Create custom colormap with higher intensity
                             color = base_colors[channel]
                             custom_cmap = LinearSegmentedColormap.from_list(
-                                f'custom_{channel}',
-                                [(0,0,0,0), (*color,1)]
-                            )
+                                f'custom_{channel}', [(0,0,0,0), (*color,1)])
                             
-                            # Display the image with slightly higher alpha
-                            self.ax.imshow(normalized_image,
-                                         alpha=0.7,
-                                         cmap=custom_cmap,
-                                         vmin=0,
-                                         vmax=1,
-                                         extent=(-0.5, min_width-0.5, min_height-0.5, -0.5))
+                            im = self.ax.imshow(normalized_image, alpha=0.7, cmap=custom_cmap,
+                                              vmin=0, vmax=1, extent=crop_extent)
 
+            # Handle preview, overlays, and measurements (apply cropping here too)
             if self.preview and not called:
-                self.create_highlight_overlay_slice(self.targs, bounds = self.bounds)
+                self.create_highlight_overlay_slice(self.targs, bounds=self.bounds)
 
-            # Add highlight overlay if it exists
+            # Overlay handling (optimized with cropping and downsampling)
             if self.mini_overlay and self.highlight and self.machine_window is None:
-                highlight_cmap = LinearSegmentedColormap.from_list(
-                    'highlight',
-                    [(0, 0, 0, 0), (1, 1, 0, 1)]  # yellow
-                )
-                self.ax.imshow(self.mini_overlay_data,
-                             cmap=highlight_cmap,
-                             alpha=0.8)
-            elif self.highlight_overlay is not None and self.highlight and self.machine_window is None:
-                highlight_slice = self.highlight_overlay[self.current_slice]
-                highlight_cmap = LinearSegmentedColormap.from_list(
-                    'highlight',
-                    [(0, 0, 0, 0), (1, 1, 0, 1)]  # yellow
-                )
-                self.ax.imshow(highlight_slice,
-                             cmap=highlight_cmap,
-                             alpha=0.8)
+                highlight_cmap = LinearSegmentedColormap.from_list('highlight', [(0, 0, 0, 0), (1, 1, 0, 1)])
+                display_overlay = crop_and_downsample_image(
+                    self.mini_overlay_data, y_min_padded, y_max_padded, 
+                    x_min_padded, x_max_padded, downsample_factor)
+                self.ax.imshow(display_overlay, cmap=highlight_cmap, alpha=0.8, extent=crop_extent)
             elif self.highlight_overlay is not None and self.highlight:
                 highlight_slice = self.highlight_overlay[self.current_slice]
-                highlight_cmap = LinearSegmentedColormap.from_list(
-                    'highlight',
-                    [(0, 0, 0, 0),          # transparent for 0
-                     (1, 1, 0, 1),          # bright yellow for 1
-                     (0, 0.7, 1, 1)]        # cool blue for 2
-                )
-                self.ax.imshow(highlight_slice,
-                             cmap=highlight_cmap,
-                             vmin=0,
-                             vmax=2,         # Important: set vmax to 2 to accommodate both values
-                             alpha=0.3)
-
-            if self.channel_data[4] is not None:
-
-                highlight_slice = self.channel_data[4][self.current_slice]
-                img_min = self.min_max[4][0]
-                img_max = self.min_max[4][1]
-                
-                # Calculate vmin and vmax, ensuring we don't get a zero range
-                if img_min == img_max:
-                    vmin = img_min
-                    vmax = img_min + 1
-                else:
-                    vmin = img_min + (img_max - img_min) * self.channel_brightness[4]['min']
-                    vmax = img_min + (img_max - img_min) * self.channel_brightness[4]['max']
-                
-                # Normalize the image safely
-                if vmin == vmax:
-                    normalized_image = np.zeros_like(highlight_slice)
+                display_highlight = crop_and_downsample_image(
+                    highlight_slice, y_min_padded, y_max_padded, 
+                    x_min_padded, x_max_padded, downsample_factor)
+                if self.machine_window is None:
+                    highlight_cmap = LinearSegmentedColormap.from_list('highlight', [(0, 0, 0, 0), (1, 1, 0, 1)])
+                    self.ax.imshow(display_highlight, cmap=highlight_cmap, alpha=0.8, extent=crop_extent)
                 else:
-                    normalized_image = np.clip((highlight_slice - vmin) / (vmax - vmin), 0, 1)
-
-                color = base_colors[self.temp_chan]
-                custom_cmap = LinearSegmentedColormap.from_list(
-                    f'custom_{4}',
-                    [(0,0,0,0), (*color,1)]
-                )
-                
-
-                self.ax.imshow(normalized_image,
-                             alpha=0.7,
-                             cmap=custom_cmap,
-                             vmin=0,
-                             vmax=1)
-
-            # Style the axes
-            self.ax.set_xlabel('X')
-            self.ax.set_ylabel('Y')
-            self.ax.set_title(f'Slice {self.current_slice}')
-
-            # Make axis labels and ticks black for visibility against white background
-            self.ax.xaxis.label.set_color('black')
-            self.ax.yaxis.label.set_color('black')
-            self.ax.title.set_color('black')
-            self.ax.tick_params(colors='black')
-            for spine in self.ax.spines.values():
-                spine.set_color('black')
+                    highlight_cmap = LinearSegmentedColormap.from_list('highlight', 
+                        [(0, 0, 0, 0), (1, 1, 0, 1), (0, 0.7, 1, 1)])
+                    self.ax.imshow(display_highlight, cmap=highlight_cmap, vmin=0, vmax=2, alpha=0.3, extent=crop_extent)
 
-            # Adjust the layout to ensure the plot fits well in the figure
-            self.figure.tight_layout()
-
-            # Redraw measurement points and their labels
+            # Redraw measurement points efficiently (no cropping needed - these are vector graphics)
+            # Only draw points that are within the visible region for additional performance
             for point in self.measurement_points:
                 x1, y1, z1 = point['point1']
                 x2, y2, z2 = point['point2']
                 pair_idx = point['pair_index']
                 
-                # Draw points and labels if they're on current slice
-                if z1 == self.current_slice:
-                    self.ax.plot(x1, y1, 'yo', markersize=8)
-                    self.ax.text(x1, y1+5, str(pair_idx), 
-                                color='white', ha='center', va='bottom')
-                if z2 == self.current_slice:
-                    self.ax.plot(x2, y2, 'yo', markersize=8)
-                    self.ax.text(x2, y2+5, str(pair_idx), 
-                                color='white', ha='center', va='bottom')
+                # Check if points are in visible region
+                point1_visible = (z1 == self.current_slice and 
+                                current_xlim[0] <= x1 <= current_xlim[1] and 
+                                current_ylim[1] <= y1 <= current_ylim[0])
+                point2_visible = (z2 == self.current_slice and 
+                                current_xlim[0] <= x2 <= current_xlim[1] and 
+                                current_ylim[1] <= y2 <= current_ylim[0])
+                
+                if point1_visible:
+                    pt1 = self.ax.plot(x1, y1, 'yo', markersize=8)[0]
+                    txt1 = self.ax.text(x1, y1+5, str(pair_idx), color='white', ha='center', va='bottom')
+                    self.measurement_artists.extend([pt1, txt1])
                     
-                # Draw line if both points are on current slice
-                if z1 == z2 == self.current_slice:
-                    self.ax.plot([x1, x2], [y1, y2], 'r--', alpha=0.5)
-        
-            if active_channels:
-                self.ax.set_xlim(-0.5, min_width - 0.5)
-                self.ax.set_ylim(min_height - 0.5, -0.5)
+                if point2_visible:
+                    pt2 = self.ax.plot(x2, y2, 'yo', markersize=8)[0]
+                    txt2 = self.ax.text(x2, y2+5, str(pair_idx), color='white', ha='center', va='bottom')
+                    self.measurement_artists.extend([pt2, txt2])
+                    
+                if z1 == z2 == self.current_slice and (point1_visible or point2_visible):
+                    line = self.ax.plot([x1, x2], [y1, y2], 'r--', alpha=0.5)[0]
+                    self.measurement_artists.append(line)
+
+            # Store current view limits for next update
+            self.ax._current_xlim = current_xlim
+            self.ax._current_ylim = current_ylim
 
+            # Handle resizing
             if self.resizing:
                 self.original_xlim = self.ax.get_xlim()
                 self.original_ylim = self.ax.get_ylim()
-            # Restore zoom limits if they existed
+                
+            # Restore zoom (this sets the final view, not the data extent)
             if current_xlim is not None and current_ylim is not None:
                 self.ax.set_xlim(current_xlim)
                 self.ax.set_ylim(current_ylim)
+                
             if reset_resize:
                 self.resizing = False
             
-            self.canvas.draw()
+            # Use draw_idle for better performance
+            self.canvas.draw_idle()
+
+        except Exception as e:
+            pass
+            #import traceback
+            #print(traceback.format_exc())
+
 
 
-        except:
-            import traceback
-            print(traceback.format_exc())
 
     def get_channel_image(self, channel):
         """Find the matplotlib image object for a specific channel."""
@@ -5452,7 +6089,10 @@ class ImageViewerWindow(QMainWindow):
             stats['num_nodes'] = my_network.network.number_of_nodes()
             stats['num_edges'] = my_network.network.number_of_edges()
         except:
-            pass
+            try:
+                stats['num_nodes'] = len(np.unique(my_network.nodes)) - 1
+            except:
+                pass
 
         try:
             idens = invert_dict(my_network.node_identities)
@@ -6463,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))
@@ -7378,11 +8018,10 @@ class ComIdDialog(QDialog):
         self.umap.setChecked(True)
         layout.addRow("Generate UMAP?:", self.umap)
 
-        # weighted checkbox (default True)
-        self.label = QPushButton("Label")
-        self.label.setCheckable(True)
-        self.label.setChecked(False)
-        layout.addRow("If using above - label UMAP points?:", self.label)
+        self.label = QComboBox()
+        self.label.addItems(["No Label", "By Community", "By Neighborhood (If already calculated via 'Analyze -> Network -> Convert Network Communities...')"])
+        self.label.setCurrentIndex(0)
+        layout.addRow("Label UMAP Points How?:", self.label)
 
         self.limit = QLineEdit("")
         layout.addRow("Min Community Size for UMAP (Smaller communities will be ignored in graph, does not apply if empty)", self.limit)
@@ -7402,6 +8041,12 @@ class ComIdDialog(QDialog):
 
         try:
 
+            if self.parent().prev_coms is not None:
+                temp = my_network.communities
+                my_network.communities = self.parent().prev_coms
+            else:
+                temp = None
+
             if my_network.node_identities is None:
                 print("Node identities must be set")
 
@@ -7414,7 +8059,9 @@ class ComIdDialog(QDialog):
             mode = self.mode.currentIndex()
 
             umap = self.umap.isChecked()
-            label = self.label.isChecked()
+
+            label = self.label.currentIndex()
+
             proportional = self.proportional.isChecked()
             limit = int(self.limit.text()) if self.limit.text().strip() else 0
 
@@ -7427,10 +8074,13 @@ class ComIdDialog(QDialog):
 
             else:
 
-                info, names = my_network.community_id_info_per_com(umap = umap, label = label, limit = limit, proportional = proportional)
+                info, names = my_network.community_id_info_per_com(umap = umap, label = label, limit = limit, proportional = proportional, neighbors = temp)
 
                 self.parent().format_for_upperright_table(info, 'Community', names, 'Average of Community Makeup')
 
+            if self.parent().prev_coms is not None:
+                my_network.communities = temp
+
             self.accept()
 
         except Exception as e:
@@ -7786,10 +8436,12 @@ class NearNeighDialog(QDialog):
                 title = f"Nearest {num} Neighbor(s) Distance of {targ} from {root}"
                 header = f"Shortest Distance to Closest {num} {targ}(s)"
                 header2 = f"{root} Node ID"
+                header3 = f'Theoretical Uniform Distance to Closest {num} {targ}(s)'
             else:
                 title = f"Nearest {num} Neighbor(s) Distance Between Nodes"
                 header = f"Shortest Distance to Closest {num} Nodes"
                 header2 = "Root Node ID"
+                header3 = f'Simulated Theoretical Uniform Distance to Closest {num} Nodes'
 
             if centroids and my_network.node_centroids is None:
                 self.parent().show_centroid_dialog()
@@ -7797,15 +8449,22 @@ class NearNeighDialog(QDialog):
                     return
 
             if not numpy:
-                avg, output, quant_overlay = my_network.nearest_neighbors_avg(root, targ, my_network.xy_scale, my_network.z_scale, num = num, heatmap = heatmap, threed = threed, quant = quant, centroids = centroids)
+                avg, output, quant_overlay, pred = my_network.nearest_neighbors_avg(root, targ, my_network.xy_scale, my_network.z_scale, num = num, heatmap = heatmap, threed = threed, quant = quant, centroids = centroids)
             else:
-                avg, output, overlay, quant_overlay = my_network.nearest_neighbors_avg(root, targ, my_network.xy_scale, my_network.z_scale, num = num, heatmap = heatmap, threed = threed, numpy = True, quant = quant, centroids = centroids)
+                avg, output, overlay, quant_overlay, pred = my_network.nearest_neighbors_avg(root, targ, my_network.xy_scale, my_network.z_scale, num = num, heatmap = heatmap, threed = threed, numpy = True, quant = quant, centroids = centroids)
                 self.parent().load_channel(3, overlay, data = True)
 
             if quant_overlay is not None:
                 self.parent().load_channel(2, quant_overlay, data = True)
+
+            avg = {header:avg}
+
+            if pred is not None:
+
+                avg[header3] = pred
+
             
-            self.parent().format_for_upperright_table([avg], metric = f'Avg {title}', title = f'Avg {title}')
+            self.parent().format_for_upperright_table(avg, 'Category', 'Value', title = f'Avg {title}')
             self.parent().format_for_upperright_table(output, header2, header, title = title)
 
             self.accept()
@@ -7830,7 +8489,7 @@ class NearNeighDialog(QDialog):
                 root = available[0]
 
                 for targ in available:
-                    avg, _, _ = my_network.nearest_neighbors_avg(root, targ, my_network.xy_scale, my_network.z_scale, num = num, centroids = centroids)
+                    avg, _, _, _ = my_network.nearest_neighbors_avg(root, targ, my_network.xy_scale, my_network.z_scale, num = num, centroids = centroids)
                     output_dict[f"{root} vs {targ}"] = avg
 
                 del available[0]
@@ -8742,15 +9401,6 @@ class ResizeDialog(QDialog):
             undo_button.clicked.connect(lambda: self.run_resize(undo = True))
             layout.addRow(undo_button)
 
-        if my_network.xy_scale != my_network.z_scale:
-            norm_button_upsize = QPushButton(f"Normalize Scaling with Upsample")
-            norm_button_upsize.clicked.connect(lambda: self.run_resize(upsize = True, special = True))
-            layout.addRow(norm_button_upsize)
-
-            norm_button_downsize = QPushButton("Normalize Scaling with Downsample")
-            norm_button_downsize.clicked.connect(lambda: self.run_resize(upsize = False, special = True))
-            layout.addRow(norm_button_downsize)
-
         run_button = QPushButton("Run Resize")
         run_button.clicked.connect(self.run_resize)
         layout.addRow(run_button)
@@ -8764,7 +9414,7 @@ class ResizeDialog(QDialog):
 
     def run_resize(self, undo = False, upsize = True, special = False):
         try:
-            self.parent().resizing = True
+            self.parent().resizing = False
             # Get parameters
             try:
                 resize = float(self.resize.text()) if self.resize.text() else None
@@ -8778,6 +9428,12 @@ class ResizeDialog(QDialog):
             
             resize = resize if resize is not None else (zsize, ysize, xsize)
 
+            if (self.parent().shape[1] * resize) < 1 or (self.parent().shape[2] * resize) < 1:
+                print("Incompatible x/y dimensions")
+                return
+            elif (self.parent().shape[0] * resize) < 1:
+                resize = (1, resize, resize)
+
             if special:
                 if upsize:
                     if (my_network.z_scale > my_network.xy_scale):
@@ -8819,11 +9475,7 @@ class ResizeDialog(QDialog):
                 new_shape = tuple(int(dim * resize) for dim in array_shape)
             else:
                 new_shape = tuple(int(dim * factor) for dim, factor in zip(array_shape, resize))
-                
-            #if any(dim < 1 for dim in new_shape):
-                #QMessageBox.critical(self, "Error", f"Resize would result in invalid dimensions: {new_shape}")
-                #self.reset_fields()
-                #return
+
 
             cubic = self.cubic.isChecked()
             order = 3 if cubic else 0
@@ -8837,7 +9489,7 @@ class ResizeDialog(QDialog):
                 for channel in range(4):
                     if self.parent().channel_data[channel] is not None:
                         resized_data = n3d.resize(self.parent().channel_data[channel], resize, order)
-                        self.parent().load_channel(channel, channel_data=resized_data, data=True, assign_shape = False)
+                        self.parent().load_channel(channel, channel_data=resized_data, data=True)
 
 
                 
@@ -8858,7 +9510,7 @@ class ResizeDialog(QDialog):
                 for channel in range(4):
                     if self.parent().channel_data[channel] is not None:
                         resized_data = n3d.upsample_with_padding(self.parent().channel_data[channel], original_shape = self.parent().original_shape)
-                        self.parent().load_channel(channel, channel_data=resized_data, data=True, assign_shape = False)
+                        self.parent().load_channel(channel, channel_data=resized_data, data=True)
 
                 if self.parent().mini_overlay_data is not None:
 
@@ -9664,6 +10316,7 @@ class MachineWindow(QMainWindow):
 
             self.num_chunks = 0
 
+
         except:
             return
 
@@ -10126,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():
@@ -10141,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()
@@ -10149,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()
 
 
 
@@ -10172,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: #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
@@ -10218,11 +10876,14 @@ class SegmentationWorker(QThread):
                 if self._stop:
                     break
                 
-                for z,y,x in foreground_coords:
-                    self.overlay[z,y,x] = 1
-                for z,y,x in background_coords:
-                    self.overlay[z,y,x] = 2
-                
+                if foreground_coords:
+                    fg_array = np.array(list(foreground_coords))
+                    self.overlay[fg_array[:, 0], fg_array[:, 1], fg_array[:, 2]] = 1
+
+                if background_coords:
+                    bg_array = np.array(list(background_coords))
+                    self.overlay[bg_array[:, 0], bg_array[:, 1], bg_array[:, 2]] = 2
+
                 self.chunks_since_update += 1
                 current_time = time.time()
                 if (self.chunks_since_update >= self.chunks_per_update and 
@@ -10247,27 +10908,6 @@ class SegmentationWorker(QThread):
             import traceback
             traceback.print_exc()
 
-    def run_batch(self):
-        try:
-            foreground_coords, _ = self.segmenter.segment_volume()
-            
-            # Modify the array directly
-            self.overlay.fill(False)
-            for z,y,x in foreground_coords:
-                # Check for pause/stop during batch processing too
-                self._check_pause()
-                if self._stop:
-                    break
-                self.overlay[z,y,x] = True
-                
-            self.finished.emit()
-            
-        except Exception as e:
-            print(f"Error in segmentation: {e}")
-            raise
-            
-
-
 
 class ThresholdWindow(QMainWindow):
     def __init__(self, parent=None, accepted_mode=0):