nettracer3d 0.9.4__py3-none-any.whl → 0.9.6__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, QEvent)
+from PyQt6.QtCore import (QPoint, Qt, QAbstractTableModel, QTimer,  QThread, pyqtSignal, QObject, QCoreApplication, QEvent, QEventLoop)
 import numpy as np
 import time
 from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
@@ -210,6 +210,11 @@ class ImageViewerWindow(QMainWindow):
         buttons_widget = QWidget()
         buttons_layout = QHBoxLayout(buttons_widget)
 
+        self.reset_view = QPushButton("🏠")
+        self.reset_view.setFixedSize(20, 20)
+        self.reset_view.clicked.connect(self.home)
+        control_layout.addWidget(self.reset_view)
+
         # "Create" zoom button
         self.zoom_button = QPushButton("🔍")
         self.zoom_button.setCheckable(True)
@@ -293,14 +298,6 @@ class ImageViewerWindow(QMainWindow):
             
             control_layout.addWidget(channel_container)
 
-        self.show_channels = QPushButton("✓")
-        self.show_channels.setCheckable(True)
-        self.show_channels.setChecked(True)
-        self.show_channels.setFixedSize(20, 20)
-        self.show_channels.clicked.connect(self.toggle_chan_load)
-        control_layout.addWidget(self.show_channels)
-        self.chan_load = True
-
         # Create the main widget and layout
         main_widget = QWidget()
         self.setCentralWidget(main_widget)
@@ -1005,7 +1002,15 @@ class ImageViewerWindow(QMainWindow):
             pass
 
         # Update display
-        self.update_display(preserve_zoom=(current_xlim, current_ylim), called = True)
+        self.update_display(preserve_zoom=(current_xlim, current_ylim))
+
+        if self.pan_mode:
+            self.create_pan_background()
+            current_xlim = self.ax.get_xlim()
+            current_ylim = self.ax.get_ylim()
+            self.update_display_pan_mode(current_xlim, current_ylim)
+
+
 
     def create_mini_overlay(self, node_indices = None, edge_indices = None):
 
@@ -1979,6 +1984,13 @@ class ImageViewerWindow(QMainWindow):
                     except:
                         pass
 
+
+                if my_network.network is not None:
+                    try:
+                        info_dict['Neighbors'] = list(my_network.network.neighbors(label))
+                    except:
+                        pass
+
                 if my_network.communities is not None:
                     try:
                         info_dict['Community'] = my_network.communities[label]
@@ -2012,6 +2024,24 @@ class ImageViewerWindow(QMainWindow):
 
                 info_dict['Object Class'] = 'Edge'
 
+                try:
+                    # Get the existing DataFrame from the model
+                    original_df = self.network_table.model()._data
+                    
+                    # Create mask for rows where one column is any original node AND the other column is any neighbor
+                    mask = (
+                        (original_df.iloc[:, 0].isin(self.clicked_values['nodes'])) |
+                        (original_df.iloc[:, 1].isin(self.clicked_values['nodes'])) |
+                        (original_df.iloc[:, 2].isin(self.clicked_values['edges']))
+                        )
+
+                    filtered_df = original_df[mask].copy()
+                    node_list = list(set(filtered_df.iloc[:, 0].to_list() + filtered_df.iloc[:, 1].to_list()))
+                    info_dict["Num Nodes"] = len(node_list)
+                    info_dict['Nodes'] = node_list
+                except:
+                    pass
+
                 if my_network.edge_centroids is not None:
                     try:
                         info_dict['Centroid'] = my_network.edge_centroids[label]
@@ -2440,19 +2470,18 @@ class ImageViewerWindow(QMainWindow):
             print(f"Error: {e}")
 
 
-    def toggle_chan_load(self):
+    def home(self):
+
+        self.update_display()
+
 
-        if self.show_channels.isChecked():
-            self.chan_load = True
-        else:
-            self.chan_load = False
 
     def toggle_highlight(self):
         self.highlight = self.high_button.isChecked()
         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() and self.machine_window is None:
+        if self.high_button.isChecked() and self.machine_window is None and not self.preview:
             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'])
@@ -2471,7 +2500,8 @@ class ImageViewerWindow(QMainWindow):
         self.zoom_mode = self.zoom_button.isChecked()
 
         if self.zoom_mode:
-            self.pan_button.setChecked(False)
+            if self.pan_mode:
+                self.pan_button.click()
 
             self.pen_button.setChecked(False)
             self.brush_mode = False
@@ -2547,33 +2577,23 @@ class ImageViewerWindow(QMainWindow):
                 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)
 
-                    # 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()
-            current_ylim = self.ax.get_ylim()
-            self.update_display(preserve_zoom=(current_xlim, current_ylim))
+            self.setEnabled(True)
+            self.update_display(preserve_zoom=(self.ax.get_xlim(), self.ax.get_ylim()))
             if self.machine_window is None:
                 self.canvas.setCursor(Qt.CursorShape.ArrowCursor)
             else:
@@ -2584,6 +2604,9 @@ class ImageViewerWindow(QMainWindow):
         self.brush_mode = self.pen_button.isChecked()
         if self.brush_mode:
 
+            if self.pan_mode:
+                self.pan_button.click()
+
             self.pm = painting.PaintManager(parent = self)
 
             # Start virtual paint session
@@ -3069,14 +3092,7 @@ class ImageViewerWindow(QMainWindow):
             self.ax.set_xlim(new_xlim)
             self.ax.set_ylim(new_ylim)
             
-            # 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))
+            self.canvas.draw_idle()
             
             # Update pan start position
             self.pan_start = (event.xdata, event.ydata)
@@ -3105,18 +3121,36 @@ class ImageViewerWindow(QMainWindow):
 
 
     def create_pan_background(self):
-        """Create a static background image from currently visible channels with proper rendering"""
-        # Store current zoom state
-        current_xlim = self.ax.get_xlim()
-        current_ylim = self.ax.get_ylim()
-        
-        # Render all visible channels with proper colors/brightness into a single composite
-        self.pan_background_image = self.create_composite_for_pan()
-        self.pan_zoom_state = (current_xlim, current_ylim)
-
+            """Create a static background image from currently visible channels with proper rendering"""
+            # Store current zoom state
+            current_xlim = self.ax.get_xlim()
+            current_ylim = self.ax.get_ylim()
+            
+            # Try GPU acceleration first, fallback to CPU
+            try:
+                import cupy as cp
+                self.use_gpu = True
+            except ImportError:
+                self.use_gpu = False
+            
+            # Render all visible channels with proper colors/brightness into a single composite
+            self.channel_visible = self.pre_pan_channel_state.copy()
+            try:
+                if self.use_gpu:
+                    self.pan_background_image = self.create_composite_for_pan_gpu()
+                else:
+                    self.pan_background_image = self.create_composite_for_pan()
+            except Exception as e:
+                print(f'GPU implementation failed: {e}, falling back to CPU')
+                self.use_gpu = False
+                self.pan_background_image = self.create_composite_for_pan()
+            
+            self.pan_zoom_state = (current_xlim, current_ylim)
 
-    def create_composite_for_pan(self):
-        """Create a properly rendered composite image for panning with downsample support"""
+    def create_composite_for_pan_gpu(self):
+        """Create a properly rendered composite image for panning with GPU acceleration"""
+        import cupy as cp
+        
         # 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:
@@ -3134,6 +3168,28 @@ 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
 
+        # Helper function to crop and downsample image on GPU
+        def crop_and_downsample_image_gpu(image_cp, y_start, y_end, x_start, x_end, factor):
+            # Crop first
+            if len(image_cp.shape) == 2:
+                cropped = image_cp[y_start:y_end, x_start:x_end]
+            elif len(image_cp.shape) == 3:
+                cropped = image_cp[y_start:y_end, x_start:x_end, :]
+            else:
+                cropped = image_cp
+            
+            # 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
+
+        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)))
@@ -3141,41 +3197,281 @@ class ImageViewerWindow(QMainWindow):
         y_min = max(0, int(np.floor(current_ylim[1] + 0.5)))  # Note: y is flipped
         y_max = min(min_height, int(np.ceil(current_ylim[0] + 0.5)))
 
-        box_len = x_max - x_min
-        box_height = y_max - y_min
+        box_len = int((x_max - x_min)/2)
+        box_height = int((y_max - y_min)/2)
         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
-
+        val = int(np.ceil(size/(2000 * 2000)))
         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
+        # 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)
+
+        display_height = (y_max_padded - y_min_padded) // downsample_factor
+        display_width = (x_max_padded - x_min_padded) // downsample_factor
         
-        # Helper function to downsample image (same as in update_display)
-        def downsample_image(image, factor):
-            if factor == 1:
-                return image
+        # Create a blank RGBA composite to accumulate all channels (using display dimensions) - on GPU
+        composite = cp.zeros((display_height, display_width, 4), dtype=cp.float32)
+        
+        # Process each visible channel exactly like update_display does
+        for channel in range(4):
+            if (self.channel_visible[channel] and 
+                self.channel_data[channel] is not None):
+                
+                # Get current slice data (same logic as update_display)
+                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 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]
+                else:
+                    current_image = self.channel_data[channel]
+
+                # Convert to CuPy array and crop/downsample on GPU
+                current_image_cp = cp.asarray(current_image)
+                display_image_cp = crop_and_downsample_image_gpu(
+                    current_image_cp, y_min_padded, y_max_padded, 
+                    x_min_padded, x_max_padded, downsample_factor)
+
+                if is_rgb and self.channel_data[channel].shape[-1] == 3:
+                    # RGB image - convert to RGBA and blend
+                    rgb_alpha = cp.ones((*display_image_cp.shape[:2], 4), dtype=cp.float32)
+                    rgb_alpha[:, :, :3] = display_image_cp.astype(cp.float32) / 255.0
+                    rgb_alpha[:, :, 3] = 0.7  # Same alpha as update_display
+                    composite = self.blend_layers_gpu(composite, rgb_alpha)
+                    
+                elif is_rgb and self.channel_data[channel].shape[-1] == 4:
+                    # RGBA image - blend directly
+                    rgba_image = display_image_cp.astype(cp.float32) / 255.0
+                    composite = self.blend_layers_gpu(composite, rgba_image)
+                    
+                else:
+                    # Regular channel processing (same logic as update_display)
+                    if self.min_max[channel][0] == None:
+                        self.min_max[channel][0] = cp.asnumpy(cp.min(current_image_cp))
+                    if self.min_max[channel][1] == None:
+                        self.min_max[channel][1] = cp.asnumpy(cp.max(current_image_cp))
+
+                    img_min = self.min_max[channel][0]
+                    img_max = self.min_max[channel][1]
+                    
+                    if img_min == img_max:
+                        vmin = img_min
+                        vmax = img_min + 1
+                    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 downsampled image on GPU
+                    if vmin == vmax:
+                        normalized_image = cp.zeros_like(display_image_cp)
+                    else:
+                        normalized_image = cp.clip((display_image_cp - 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_gpu(display_image_cp)
+                    else:
+                        # Regular channel with custom color
+                        color = self.base_colors[channel]
+                        channel_rgba = cp.zeros((*normalized_image.shape, 4), dtype=cp.float32)
+                        channel_rgba[:, :, 0] = normalized_image * color[0]  # R
+                        channel_rgba[:, :, 1] = normalized_image * color[1]  # G  
+                        channel_rgba[:, :, 2] = normalized_image * color[2]  # B
+                        channel_rgba[:, :, 3] = normalized_image * 0.7       # A (same alpha as update_display)
+                    
+                    # Blend this channel into the composite
+                    composite = self.blend_layers_gpu(composite, channel_rgba)
+        
+        # Add highlight overlays if they exist (with downsampling)
+        if self.mini_overlay and self.highlight and self.machine_window is None:
+            mini_overlay_cp = cp.asarray(self.mini_overlay_data)
+            display_overlay = crop_and_downsample_image_gpu(mini_overlay_cp, y_min_padded, y_max_padded, x_min_padded, x_max_padded, downsample_factor)
+            highlight_rgba = self.create_highlight_rgba_gpu(display_overlay, yellow=True)
+            composite = self.blend_layers_gpu(composite, highlight_rgba)
+        elif self.highlight_overlay is not None and self.highlight:
+            highlight_slice = self.highlight_overlay[self.current_slice]
+            highlight_slice_cp = cp.asarray(highlight_slice)
+            display_highlight = crop_and_downsample_image_gpu(highlight_slice_cp, y_min_padded, y_max_padded, x_min_padded, x_max_padded, downsample_factor)
+            if self.machine_window is None:
+                highlight_rgba = self.create_highlight_rgba_gpu(display_highlight, yellow=True)
+            else:
+                highlight_rgba = self.create_highlight_rgba_gpu(display_highlight, yellow=False)
+            composite = self.blend_layers_gpu(composite, highlight_rgba)
+        
+        # Convert back to CPU and to 0-255 range for display
+        composite_cpu = cp.asnumpy(composite)
+        return (composite_cpu * 255).astype(np.uint8)
+
+    def apply_machine_colormap_gpu(self, image_cp):
+        """Apply the special machine window colormap for channel 2 - GPU version"""
+        import cupy as cp
+        
+        rgba = cp.zeros((*image_cp.shape, 4), dtype=cp.float32)
+        
+        # Transparent for 0
+        mask_0 = (image_cp == 0)
+        rgba[mask_0] = cp.array([0, 0, 0, 0])
+        
+        # Light green for 1
+        mask_1 = (image_cp == 1)
+        rgba[mask_1] = cp.array([0.5, 1, 0.5, 0.7])
+        
+        # Light red for 2
+        mask_2 = (image_cp == 2)
+        rgba[mask_2] = cp.array([1, 0.5, 0.5, 0.7])
+        
+        return rgba
+
+    def create_highlight_rgba_gpu(self, highlight_data_cp, yellow=True):
+        """Create RGBA highlight overlay - GPU version"""
+        import cupy as cp
+        
+        rgba = cp.zeros((*highlight_data_cp.shape, 4), dtype=cp.float32)
+        
+        if yellow:
+            # Yellow highlight
+            mask = highlight_data_cp > 0
+            rgba[mask] = cp.array([1, 1, 0, 0.8])  # Yellow with alpha 0.8
+        else:
+            # Multi-color highlight for machine window
+            mask_1 = (highlight_data_cp == 1)
+            mask_2 = (highlight_data_cp == 2)
+            rgba[mask_1] = cp.array([1, 1, 0, 0.5])      # Yellow for 1
+            rgba[mask_2] = cp.array([0, 0.7, 1, 0.5])    # Blue for 2
+        
+        return rgba
+
+    def blend_layers_gpu(self, base_cp, overlay_cp):
+        """Alpha blend two RGBA layers - GPU version"""
+        import cupy as cp
+        
+        def resize_overlay_to_base_gpu(overlay_arr_cp, base_arr_cp):
+            base_height, base_width = base_arr_cp.shape[:2]
+            overlay_height, overlay_width = overlay_arr_cp.shape[:2]
+            
+            # First crop if overlay is larger
+            cropped_overlay = overlay_arr_cp[: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 = cp.pad(cropped_overlay,
+                                        ((0, pad_height), (0, pad_width), (0, 0)),
+                                        mode='constant', constant_values=0)
             
-            # Handle different image types
+            return cropped_overlay
+        
+        # Resize the ENTIRE overlay array to match base dimensions
+        if overlay_cp.shape[:2] != base_cp.shape[:2]:
+            overlay_cp = resize_overlay_to_base_gpu(overlay_cp, base_cp)
+        
+        # Now extract alpha channels (they should be the same size)
+        alpha_overlay = overlay_cp[:, :, 3:4]
+        alpha_base = base_cp[:, :, 3:4]
+        
+        # Calculate output alpha
+        alpha_out = alpha_overlay + alpha_base * (1 - alpha_overlay)
+        
+        # Calculate output RGB
+        rgb_out = cp.zeros_like(base_cp[:, :, :3])
+        mask = alpha_out[:, :, 0] > 0
+        
+        rgb_out[mask] = (overlay_cp[mask, :3] * alpha_overlay[mask] + 
+                         base_cp[mask, :3] * alpha_base[mask] * (1 - alpha_overlay[mask])) / alpha_out[mask]
+        
+        # Combine RGB and alpha
+        result = cp.zeros_like(base_cp)
+        result[:, :, :3] = rgb_out
+        result[:, :, 3:4] = alpha_out
+        
+        return result
+
+    def create_composite_for_pan(self):
+        """Create a properly rendered composite image for panning with downsample support"""
+        # Get active channels and dimensions (copied from update_display)
+        active_channels = [i for i in range(4) if self.channel_data[i] is not None]
+        if active_channels:
+            dims = [(self.channel_data[i].shape[1:3] if len(self.channel_data[i].shape) >= 3 else 
+                    self.channel_data[i].shape) for i in active_channels]
+            min_height = min(d[0] for d in dims)
+            min_width = min(d[1] for d in dims)
+        else:
+            return None
+        
+        # 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
+
+        # 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:
-                # Grayscale
-                return image[::factor, ::factor]
+                cropped = image[y_start:y_end, x_start:x_end]
             elif len(image.shape) == 3:
-                # RGB/RGBA
-                return image[::factor, ::factor, :]
+                cropped = image[y_start:y_end, x_start:x_end, :]
             else:
-                return image
+                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
+
+        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 = int((x_max - x_min)/2)
+        box_height = int((y_max - y_min)/2)
+        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 = max(2, int(np.ceil(size/(2000 * 2000))))
+        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)
+
+        display_height = (y_max_padded - y_min_padded) // downsample_factor
+        display_width = (x_max_padded - x_min_padded) // downsample_factor
         
         # Create a blank RGBA composite to accumulate all channels (using display dimensions)
         composite = np.zeros((display_height, display_width, 4), dtype=np.float32)
@@ -3195,8 +3491,10 @@ class ImageViewerWindow(QMainWindow):
                 else:
                     current_image = self.channel_data[channel]
 
-                # Downsample the image for rendering
-                display_image = downsample_image(current_image, downsample_factor)
+                # 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] == 3:
                     # RGB image - convert to RGBA and blend
@@ -3251,12 +3549,12 @@ class ImageViewerWindow(QMainWindow):
         
         # Add highlight overlays if they exist (with downsampling)
         if self.mini_overlay and self.highlight and self.machine_window is None:
-            display_overlay = downsample_image(self.mini_overlay_data, downsample_factor)
+            display_overlay = crop_and_downsample_image(self.mini_overlay_data, y_min_padded, y_max_padded, x_min_padded, x_max_padded, 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)
+            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_rgba = self.create_highlight_rgba(display_highlight, yellow=True)
             else:
@@ -3266,7 +3564,6 @@ class ImageViewerWindow(QMainWindow):
         # Convert to 0-255 range for display
         return (composite * 255).astype(np.uint8)
 
-
     def apply_machine_colormap(self, image):
         """Apply the special machine window colormap for channel 2"""
         rgba = np.zeros((*image.shape, 4), dtype=np.float32)
@@ -3368,18 +3665,6 @@ class ImageViewerWindow(QMainWindow):
                 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
 
@@ -3389,8 +3674,8 @@ class ImageViewerWindow(QMainWindow):
             y_min = max(0, int(np.floor(current_ylim[1] + 0.5)))  # Note: y is flipped
             y_max = min(min_height, int(np.ceil(current_ylim[0] + 0.5)))
 
-            box_len = x_max - x_min
-            box_height = y_max - y_min
+            box_len = int((x_max - x_min)/2)
+            box_height = int((y_max - y_min)/2)
             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)
@@ -3418,11 +3703,6 @@ class ImageViewerWindow(QMainWindow):
             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, 
@@ -3430,7 +3710,7 @@ class ImageViewerWindow(QMainWindow):
 
             # Display the composite background with preserved zoom
             # Use extent to stretch downsampled image back to original coordinate space
-            self.ax.imshow(display_image, 
+            self.ax.imshow(self.pan_background_image, 
                           extent=crop_extent,
                           aspect='equal')
             
@@ -3490,11 +3770,17 @@ class ImageViewerWindow(QMainWindow):
             # 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(preserve_zoom = (current_xlim, current_ylim))
+            self.setEnabled(False)
+            
+            try:
+                self.create_pan_background()
+                current_xlim = self.ax.get_xlim()
+                current_ylim = self.ax.get_ylim()
                 self.update_display_pan_mode(current_xlim, current_ylim)
-            else:            
-                self.update_display(preserve_zoom=(current_xlim, current_ylim))
+            finally:
+                # Re-enable the widget when done
+                self.setEnabled(True)
             
             self.panning = False
             self.pan_start = None
@@ -3561,8 +3847,9 @@ class ImageViewerWindow(QMainWindow):
                             self.create_highlight_overlay(node_indices=self.clicked_values['nodes'])
                         
                         # Try to highlight the last selected value in tables
-                        if self.clicked_values['nodes']:
+                        if len(self.clicked_values['nodes']) == 1:
                             self.highlight_value_in_tables(self.clicked_values['nodes'][-1])
+                            self.handle_info('node')
                             
                     elif self.active_channel == 1:  # Edges
                         if not ctrl_pressed:
@@ -3577,8 +3864,9 @@ class ImageViewerWindow(QMainWindow):
                             self.create_highlight_overlay(edge_indices=self.clicked_values['edges'])
                         
                         # Try to highlight the last selected value in tables
-                        if self.clicked_values['edges']:
+                        if len(self.clicked_values['edges']):
                             self.highlight_value_in_tables(self.clicked_values['edges'][-1])
+                            self.handle_info('edge')
             
             elif not self.selecting and self.selection_start:  # If we had a click but never started selection
                 # Handle as a normal click
@@ -3957,9 +4245,10 @@ class ImageViewerWindow(QMainWindow):
         load_action.triggered.connect(lambda: self.load_misc('Edge Centroids'))
         load_action = misc_menu.addAction("Load Node Communities")
         load_action.triggered.connect(lambda: self.load_misc('Communities'))
-        load_action = misc_menu.addAction("Merge Nodes")
+        node_identities = file_menu.addMenu('Images -> Node Identities')
+        load_action = node_identities.addAction("Merge Labeled Images Into Nodes")
         load_action.triggered.connect(lambda: self.load_misc('Merge Nodes'))
-        load_action = misc_menu.addAction("Merge Node IDs from Images")
+        load_action = node_identities.addAction("Assign Node Identities From Overlap With Other Images")
         load_action.triggered.connect(self.show_merge_node_id_dialog)
 
         
@@ -4012,8 +4301,6 @@ class ImageViewerWindow(QMainWindow):
         id_code_action.triggered.connect(lambda: self.show_code_dialog(sort = 'Identity'))
         umap_action = overlay_menu.addAction("Centroid UMAP")
         umap_action.triggered.connect(self.handle_centroid_umap)
-        iden_umap_action = overlay_menu.addAction("Identity UMAP (If any nodes were assigned multiple identities)")
-        iden_umap_action.triggered.connect(self.handle_iden_umap)
 
         rand_menu = analysis_menu.addMenu("Randomize")
         random_action = rand_menu.addAction("Generate Equivalent Random Network")
@@ -4080,10 +4367,10 @@ class ImageViewerWindow(QMainWindow):
         gennodes_action.triggered.connect(self.show_gennodes_dialog)
         branch_action = generate_menu.addAction("Label Branches")
         branch_action.triggered.connect(lambda: self.show_branch_dialog())
-        genvor_action = generate_menu.addAction("Generate Voronoi Diagram (From Node Centroids) - goes in Overlay2")
+        genvor_action = generate_menu.addAction("Generate Voronoi Diagram - goes in Overlay2")
         genvor_action.triggered.connect(self.voronoi)
 
-        modify_action = process_menu.addAction("Modify Network")
+        modify_action = process_menu.addAction("Modify Network/Properties")
         modify_action.triggered.connect(self.show_modify_dialog)
 
         
@@ -4102,8 +4389,6 @@ class ImageViewerWindow(QMainWindow):
         idoverlay_action.triggered.connect(self.show_idoverlay_dialog)
         coloroverlay_action = overlay_menu.addAction("Color Nodes (or Edges)")
         coloroverlay_action.triggered.connect(self.show_coloroverlay_dialog)
-        #searchoverlay_action = overlay_menu.addAction("Show Search Regions")
-        #searchoverlay_action.triggered.connect(self.show_search_dialog)
         shuffle_action = overlay_menu.addAction("Shuffle")
         shuffle_action.triggered.connect(self.show_shuffle_dialog)
         arbitrary_action = image_menu.addAction("Select Objects")
@@ -4433,6 +4718,12 @@ class ImageViewerWindow(QMainWindow):
            # Create new table
            table = CustomTableView(self)
            table.setModel(PandasModel(df))
+
+           try:
+               first_column_name = table.model()._data.columns[0]
+               table.sort_table(first_column_name, ascending=True)
+           except:
+                pass
            
            # Add to tabbed widget
            if title is None:
@@ -4440,17 +4731,27 @@ class ImageViewerWindow(QMainWindow):
            else:
                self.tabbed_data.add_table(f"{title}", table)
            
+
+
            # Adjust column widths to content
            for column in range(table.model().columnCount(None)):
                table.resizeColumnToContents(column)
 
        except:
-           pass
+            pass
 
     def show_merge_node_id_dialog(self):
 
-        dialog = MergeNodeIdDialog(self)
-        dialog.exec()
+        if my_network.nodes is None:
+            QMessageBox.critical(
+                self,
+                "Error",
+                "Please load your segmented cells into 'Nodes' channel first"
+            )
+            return
+        else:
+            dialog = MergeNodeIdDialog(self)
+            dialog.exec()
 
     def show_gray_water_dialog(self):
         """Show the gray watershed parameter dialog."""
@@ -4686,18 +4987,7 @@ class ImageViewerWindow(QMainWindow):
 
         try:
 
-            if my_network.nodes is not None:
-                shape = my_network.nodes.shape
-            else:
-                shape = None
-
-            if my_network.node_centroids is None:
-                self.show_centroid_dialog()
-                if my_network.node_centroids is None:
-                    print("Node centroids must be set")
-                    return
-
-            array = pxt.create_voronoi_3d_kdtree(my_network.node_centroids, shape)
+            array = sdl.smart_dilate(self.channel_data[self.active_channel], dilate_xy = np.max(self.shape), dilate_z = np.max(self.shape), use_dt_dil_amount = np.max(self.shape), fast_dil = False)
             self.load_channel(3, array, True)
 
         except Exception as e:
@@ -4753,10 +5043,6 @@ class ImageViewerWindow(QMainWindow):
         dialog = ColorOverlayDialog(self)
         dialog.exec()
 
-    def show_search_dialog(self):
-        """Show the search dialog"""
-        dialog = SearchOverlayDialog(self)
-        dialog.exec()
 
     def show_shuffle_dialog(self):
         """Show the shuffle dialog"""
@@ -4832,29 +5118,6 @@ class ImageViewerWindow(QMainWindow):
                     if sort == 'Node Identities':
                         my_network.load_node_identities(file_path = filename)
 
-                        """
-                        first_value = list(my_network.node_identities.values())[0]  # Check that there are not multiple IDs
-                        if isinstance(first_value, (list, tuple)):
-                            trump_value, ok = QInputDialog.getText(
-                                self,
-                                'Multiple IDs Detected',
-                                'The node identities appear to contain multiple ids per node in a list.\n'
-                                'If you desire one node ID to trump all others, enter it here.\n'
-                                '(Enter "-" to have the first IDs trump all others)\n'
-                                '(Enter "/" to have multi-ID nodes be split into many nodes sharing a centroid)\n'
-                                '(Close this window to continue with multi-ID nodes)'
-                            )
-                            if not ok or trump_value.strip() == '':
-                                trump_value = None
-                            elif trump_value.upper() == '-':
-                                trump_value = '-'
-                            elif trump_value.upper() == "/":
-                                trump_value = '/'
-                            my_network.node_identities = uncork(my_network.node_identities, trump_value)
-                        else:
-                            trump_value = None
-                            my_network.node_identities = uncork(my_network.node_identities, trump_value)
-                        """
 
                         if hasattr(my_network, 'node_identities') and my_network.node_identities is not None:
                             try:
@@ -4903,6 +5166,14 @@ class ImageViewerWindow(QMainWindow):
         elif sort == 'Merge Nodes':
             try:
 
+                if my_network.nodes is None:
+                    QMessageBox.critical(
+                        self,
+                        "Error",
+                        "Please load your first set of nodes into the 'Nodes' channel first"
+                    )
+                    return
+
                 if len(np.unique(my_network.nodes)) < 3:
                     self.show_label_dialog()
 
@@ -4916,6 +5187,21 @@ class ImageViewerWindow(QMainWindow):
 
                 msg.exec()
 
+                # Also if they want centroids:
+                msg2 = QMessageBox()
+                msg2.setWindowTitle("Selection Type")
+                msg2.setText("Would you like to compute node centroids for each image prior to merging?")
+                yes_button = msg2.addButton("Yes", QMessageBox.ButtonRole.AcceptRole)
+                no_button = msg2.addButton("No", QMessageBox.ButtonRole.AcceptRole)
+                msg2.addButton("Cancel", QMessageBox.ButtonRole.RejectRole)
+
+                msg2.exec()
+
+                if msg2.clickedButton() == yes_button:
+                    centroids = True
+                else:
+                    centroids = False
+
                 if msg.clickedButton() == tiff_button:
                     # Code for selecting TIFF files
                     filename, _ = QFileDialog.getOpenFileName(
@@ -4938,7 +5224,7 @@ class ImageViewerWindow(QMainWindow):
                     if dialog.exec() == QFileDialog.DialogCode.Accepted:
                         selected_path = dialog.directory().absolutePath()
 
-                my_network.merge_nodes(selected_path, root_id = self.node_name)
+                my_network.merge_nodes(selected_path, root_id = self.node_name, centroids = centroids)
                 self.load_channel(0, my_network.nodes, True)
 
 
@@ -4947,8 +5233,12 @@ class ImageViewerWindow(QMainWindow):
                         self.format_for_upperright_table(my_network.node_identities, 'NodeID', 'Identity', 'Node Identities')
                     except Exception as e:
                         print(f"Error loading node identity table: {e}")
+                if centroids:
+                    self.format_for_upperright_table(my_network.node_centroids, 'NodeID', ['Z', 'Y', 'X'], 'Node Centroids')
+
 
             except Exception as e:
+
                 QMessageBox.critical(
                     self,
                     "Error Merging",
@@ -5448,12 +5738,8 @@ class ImageViewerWindow(QMainWindow):
             if all(not btn.isEnabled() for btn in self.channel_buttons[:channel_index]):
                 self.set_active_channel(channel_index)
 
-            if self.chan_load:
-                if not self.channel_buttons[channel_index].isChecked():
-                    self.channel_buttons[channel_index].click()
-            else:
-                if self.channel_buttons[channel_index].isChecked():
-                    self.channel_buttons[channel_index].click()
+            if not self.channel_buttons[channel_index].isChecked():
+                self.channel_buttons[channel_index].click()
 
             self.min_max[channel_index][0] = np.min(self.channel_data[channel_index])
             self.min_max[channel_index][1] = np.max(self.channel_data[channel_index])
@@ -5470,6 +5756,8 @@ class ImageViewerWindow(QMainWindow):
             except:
                 pass
 
+            if self.shape == self.channel_data[channel_index].shape:
+                preserve_zoom = (self.ax.get_xlim(), self.ax.get_ylim())
             self.shape = self.channel_data[channel_index].shape
             if self.shape[1] * self.shape[2] > 3000 * 3000 * self.downsample_factor:
                 self.throttle = True
@@ -5559,9 +5847,9 @@ class ImageViewerWindow(QMainWindow):
             
             if update:
                 # Update display
-                self.update_display()
+                self.update_display(preserve_zoom = (self.ax.get_xlim(), self.ax.get_ylim()))
 
-    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):
+    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, node_identities = False):
         """Method to flexibly reset certain fields to free up the RAM as desired"""
         
         # Set scales first before any clearing operations
@@ -5581,6 +5869,9 @@ class ImageViewerWindow(QMainWindow):
             # Clear selection table
             self.selection_table.setModel(PandasModel(empty_df))
 
+        if node_identities:
+            my_network.node_identities = None
+
         if nodes:
             self.delete_channel(0, False, update = update)
 
@@ -5691,6 +5982,9 @@ class ImageViewerWindow(QMainWindow):
     def toggle_channel(self, channel_index):
         """Toggle visibility of a channel."""
         # Store current zoom settings before toggling
+        if self.pan_mode:
+            self.pan_button.click()
+
         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
 
@@ -5728,7 +6022,9 @@ class ImageViewerWindow(QMainWindow):
                 # Now convert to real data
                 self.pm.convert_virtual_strokes_to_data()
             self.current_slice = slice_value
-            if self.mini_overlay == True: #If we are rendering the highlight overlay for selected values one at a time.
+            if self.preview:
+                 self.create_highlight_overlay_slice(self.targs, bounds=self.bounds)
+            elif 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'])
             if not self.hold_update:
                 self.update_display(preserve_zoom=view_settings)
@@ -5763,9 +6059,9 @@ class ImageViewerWindow(QMainWindow):
                 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:
+            if self.pan_background_image is not None and not self.pan_mode:
                 self.channel_visible = self.pre_pan_channel_state.copy()
                 self.is_pan_preview = False
                 self.pan_background_image = None
@@ -5774,7 +6070,6 @@ class ImageViewerWindow(QMainWindow):
                     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:
                 # Your existing virtual strokes conversion logic
@@ -5989,8 +6284,8 @@ class ImageViewerWindow(QMainWindow):
                                               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)
+            #if self.preview and not called:
+             #   self.create_highlight_overlay_slice(self.targs, bounds=self.bounds)
 
             # Overlay handling (optimized with cropping and downsampling)
             if self.mini_overlay and self.highlight and self.machine_window is None:
@@ -6204,12 +6499,6 @@ class ImageViewerWindow(QMainWindow):
 
         my_network.centroid_umap()
 
-    def handle_iden_umap(self):
-
-        if my_network.node_identities is None:
-            return
-
-        my_network.identity_umap()
 
     def closeEvent(self, event):
         """Override closeEvent to close all windows when main window closes"""
@@ -6226,6 +6515,8 @@ class ImageViewerWindow(QMainWindow):
         # Force quit the application
         QCoreApplication.quit()
 
+        exit()
+
 
 
 #TABLE RELATED: 
@@ -6468,11 +6759,7 @@ class CustomTableView(QTableView):
                 self.resizeColumnToContents(col)
                 
         except Exception as e:
-            QMessageBox.critical(
-                self,
-                "Error",
-                f"Error sorting table: {str(e)}"
-            )
+            pass
 
     def save_table_as(self, file_type):
         """Save the table data as either CSV or Excel file."""
@@ -6992,8 +7279,13 @@ class PropertiesDialog(QDialog):
         self.network.setChecked(self.check_checked(my_network.network))
         layout.addRow("Network Status", self.network)
 
+        self.node_identities = QPushButton("Node Identities")
+        self.node_identities.setCheckable(True)
+        self.node_identities.setChecked(self.check_checked(my_network.node_identities))
+        layout.addRow("Identities Status", self.node_identities)
+
         # Add Run button
-        run_button = QPushButton("Enter")
+        run_button = QPushButton("Enter (Erases Unchecked Properties)")
         run_button.clicked.connect(self.run_properties)
         layout.addWidget(run_button)
 
@@ -7030,8 +7322,9 @@ class PropertiesDialog(QDialog):
             id_overlay = not self.id_overlay.isChecked()
             search_region = not self.search_region.isChecked()
             network = not self.network.isChecked()
+            node_identities = not self.node_identities.isChecked()
 
-            self.parent().reset(nodes = nodes, edges = edges, search_region = search_region, network_overlay = network_overlay, id_overlay = id_overlay, network = network, xy_scale = xy_scale, z_scale = z_scale)
+            self.parent().reset(nodes = nodes, edges = edges, search_region = search_region, network_overlay = network_overlay, id_overlay = id_overlay, network = network, xy_scale = xy_scale, z_scale = z_scale, node_identities = node_identities)
             
             self.accept()
 
@@ -7239,7 +7532,7 @@ class ColorDialog(QDialog):
                 self.parent().base_colors[i] = new_color
         
         # Update the display
-        self.parent().update_display()
+        self.parent().update_display(preserve_zoom = (self.parent().ax.get_xlim(), self.parent().ax.get_ylim()))
         self.accept()
 
 class ArbitraryDialog(QDialog):
@@ -7459,78 +7752,252 @@ class ArbitraryDialog(QDialog):
         except Exception as e:
             QMessageBox.critical(self, "Error", f"Error processing selections: {str(e)}")
 
-class MergeNodeIdDialog(QDialog):
 
+class MergeNodeIdDialog(QDialog):
     def __init__(self, parent=None):
+
         super().__init__(parent)
+
         self.setWindowTitle("Merging Node Identities From Folder Dialog.\nNote that you should prelabel or prewatershed your current node objects before doing this. (See Process -> Image) It does not label them for you.")
         self.setModal(True)
         
         layout = QFormLayout(self)
-
         self.search = QLineEdit("")
         layout.addRow("Step-out distance (from current nodes image - ignore if you dilated them previously or don't want):", self.search)
-
         self.xy_scale = QLineEdit(f"{my_network.xy_scale}")
         layout.addRow("xy_scale:", self.xy_scale)
-
         self.z_scale = QLineEdit(f"{my_network.z_scale}")
         layout.addRow("z_scale:", self.z_scale)
+        self.mode_selector = QComboBox()
+        self.mode_selector.addItems(["Auto-Binarize(Otsu)/Presegmented", "Manual (Interactive Thresholder)"])
+        self.mode_selector.setCurrentIndex(1)  # Default to Mode 1
+        layout.addRow("Binarization Strategy:", self.mode_selector)
 
-        # Add Run button
-        self.include = QPushButton("Include Negative Gates?")
+        self.umap = QPushButton("If using manual threshold: Also generate identity UMAP?")
+        self.umap.setCheckable(True)
+        self.umap.setChecked(True)
+        layout.addWidget(self.umap)
+        
+        self.include = QPushButton("Include When a Node is Negative for an ID?")
         self.include.setCheckable(True)
-        self.include.setChecked(True)
+        self.include.setChecked(False)
         layout.addWidget(self.include)
-
-        # Add Run button
+        
         run_button = QPushButton("Get Directory")
         run_button.clicked.connect(self.run)
         layout.addWidget(run_button)
 
-    def run(self):
+    def wait_for_threshold_processing(self):
+        """
+        Opens ThresholdWindow and waits for user to process the image.
+        Returns True if completed, False if cancelled.
+        The thresholded image will be available in the main window after completion.
+        """
+        # Create event loop to wait for user
+        loop = QEventLoop()
+        result = {'completed': False}
+        
+        # Create the threshold window
+        thresh_window = ThresholdWindow(self.parent(), 4)
+        
+        # Connect signals
+        def on_processing_complete():
+            result['completed'] = True
+            loop.quit()
+            
+        def on_processing_cancelled():
+            result['completed'] = False
+            loop.quit()
+        
+        thresh_window.processing_complete.connect(on_processing_complete)
+        thresh_window.processing_cancelled.connect(on_processing_cancelled)
+        
+        # Show window and wait
+        thresh_window.show()
+        thresh_window.raise_()
+        thresh_window.activateWindow()
+        
+        # Block until user clicks "Apply Threshold & Continue" or "Cancel"
+        loop.exec()
+        
+        # Clean up
+        thresh_window.deleteLater()
+        
+        return result['completed']
 
+    def run(self):
         try:
 
             search = float(self.search.text()) if self.search.text().strip() else 0
             xy_scale = float(self.xy_scale.text()) if self.xy_scale.text().strip() else 1
             z_scale = float(self.z_scale.text()) if self.z_scale.text().strip() else 1
-
-
             data = self.parent().channel_data[0]
             include = self.include.isChecked()
-
+            umap = self.umap.isChecked()
+            
             if data is None:
                 return
-
-
-
+                
             dialog = QFileDialog(self)
             dialog.setOption(QFileDialog.Option.DontUseNativeDialog)
             dialog.setOption(QFileDialog.Option.ReadOnly)
             dialog.setFileMode(QFileDialog.FileMode.Directory)
             dialog.setViewMode(QFileDialog.ViewMode.Detail)
-
+            
             if dialog.exec() == QFileDialog.DialogCode.Accepted:
                 selected_path = dialog.directory().absolutePath()
-
+            else:
+                return  # User cancelled directory selection
+                
             if search > 0:
-                data = sdl.smart_dilate(data, 1, 1, GPU = False, fast_dil = False, use_dt_dil_amount = search, xy_scale = xy_scale, z_scale = z_scale)
+                data = sdl.smart_dilate(data, 1, 1, GPU=False, fast_dil=False, 
+                                      use_dt_dil_amount=search, xy_scale=xy_scale, z_scale=z_scale)
+            
+            # Check if manual mode is selected
+            if self.mode_selector.currentIndex() == 1:  # Manual mode
 
-            my_network.merge_node_ids(selected_path, data, include)
+                if my_network.node_identities is None: # Prepare modular dict
 
-            self.parent().format_for_upperright_table(my_network.node_identities, 'NodeID', 'Identity')
+                    my_network.node_identities = {}
 
-            QMessageBox.information(
-                self,
-                "Success",
-                "Node Identities Merged. New IDs represent presence of corresponding img foreground with +, absence with -. Please save your new identities as csv, then use File -> Load -> Load From Excel Helper to bulk search and rename desired combinations. (Press Help [above] for more info)"
-            )
+                    nodes = list(np.unique(data))
+                    if 0 in nodes:
+                        del nodes[0]
+                    for node in nodes:
+
+                        my_network.node_identities[node] = [] # Assign to lists at first
+                else:
+                    for node, iden in my_network.node_identities.items():
+                        try:
+                            my_network.node_identities[node] = ast.literal_eval(iden)
+                        except:
+                            my_network.node_identities[node] = [iden]
+
+                id_dicts = my_network.get_merge_node_dictionaries(selected_path, data)
+
+                # For loop example - get threshold for multiple images/data
+                results = []
+
+                img_list = n3d.directory_info(selected_path)
+                data_backup = copy.deepcopy(data)
+                self.parent().load_channel(0, data, data = True)
+                self.hide()
+                self.parent().highlight_overlay = None
+
+                good_list = []
+                
+                for i, img in enumerate(img_list):
+
+                    if img.endswith('.tiff') or img.endswith('.tif'):
+
+                        print(f"Please threshold {img}")
+
+
+                        mask = tifffile.imread(f'{selected_path}/{img}')
+                        self.parent().load_channel(2, mask, data = True)
+
+                        # Wait for user to threshold this data
+                        self.parent().special_dict = id_dicts[i]
+                        processing_completed = self.wait_for_threshold_processing()
+                        
+                        if not processing_completed:
+                            # User cancelled, ask if they want to continue
+                            reply = QMessageBox.question(self, 'Continue?', 
+                                                       f'Threshold cancelled for item {i+1}. Continue with remaining items?',
+                                                       QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No)
+                            if reply == QMessageBox.StandardButton.No:
+                                break
+                            continue
+                        
+                        # At this point, the thresholded image is in the main window's memory
+                        # Get the processed/thresholded data from wherever ThresholdWindow stored it
+                        thresholded_vals = list(np.unique(self.parent().channel_data[0]))
+                        if 0 in thresholded_vals:
+                            del thresholded_vals[0]
+
+                        if img.endswith('.tiff'):
+                            base_name = img[:-5]
+                        elif img.endswith('.tif'):
+                            base_name = img[:-4]
+                        else:
+                            base_name = img
+
+                        assigned = {}
+
+                        for node in my_network.node_identities.keys():
+
+                            try:
+
+                                if int(node) in thresholded_vals:
+
+                                    my_network.node_identities[node].append(f'{base_name}+')
+
+                                elif include:
+
+                                    my_network.node_identities[node].append(f'{base_name}-')
+
+                            except:
+                                pass
+                        
+                        # Process the thresholded data
+                        self.parent().highlight_overlay = None
+                        self.parent().load_channel(0, data_backup, data = True)
+                        good_list.append(base_name)
+
+                modify_dict = copy.deepcopy(my_network.node_identities)
+
+                for node, iden in my_network.node_identities.items():
+
+                    try:
+
+                        if len(iden) == 1:
+
+                            modify_dict[node] = str(iden[0]) # Singleton lists become bare strings
+                        elif len(iden) == 0:
+                            del modify_dict[node]
+                        else:
+                            modify_dict[node] = str(iden) # We hold multi element lists as strings for compatibility
+
+                    except:
+                        pass
+
+                my_network.node_identities = modify_dict
+                
+                self.parent().format_for_upperright_table(my_network.node_identities, 'NodeID', 'Identity')
+
+                all_keys = id_dicts[0].keys()
+                result = {key: np.array([d[key] for d in id_dicts]) for key in all_keys}
+
+
+                self.parent().format_for_upperright_table(result, 'NodeID', good_list, 'Mean Intensity')
+                if umap:
+                    my_network.identity_umap(result)
 
-            self.accept()
+
+                QMessageBox.information(
+                    self,
+                    "Success",
+                    "Node Identities Merged. New IDs represent presence of corresponding img foreground with +, absence with -. Please save your new identities as csv, then use File -> Load -> Load From Excel Helper to bulk search and rename desired combinations. (Press Help [above] for more info)"
+                )
+
+                self.accept()
+            else:
+                my_network.merge_node_ids(selected_path, data, include)
+
+                self.parent().format_for_upperright_table(my_network.node_identities, 'NodeID', 'Identity')
+
+                QMessageBox.information(
+                    self,
+                    "Success",
+                    "Node Identities Merged. New IDs represent presence of corresponding img foreground with +, absence with -. Please save your new identities as csv, then use File -> Load -> Load From Excel Helper to bulk search and rename desired combinations. (Press Help [above] for more info)"
+                )
+
+                self.accept()
 
         except Exception as e:
-            print(f"Error: {e}")
+            import traceback
+            print(traceback.format_exc())
+            #print(f"Error: {e}")
 
 
 class Show3dDialog(QDialog):
@@ -7643,7 +8110,7 @@ class NetOverlayDialog(QDialog):
 
             my_network.network_overlay = my_network.draw_network()
 
-            self.parent().load_channel(2, channel_data = my_network.network_overlay, data = True)
+            self.parent().load_channel(2, channel_data = my_network.network_overlay, data = True, preserve_zoom = (self.parent().ax.get_xlim(), self.parent().ax.get_ylim()))
 
             self.accept()
 
@@ -7651,34 +8118,6 @@ class NetOverlayDialog(QDialog):
 
             print(f"Error with Overlay Generation: {e}")
 
-class SearchOverlayDialog(QDialog):
-
-    def __init__(self, parent=None):
-
-        super().__init__(parent)
-        self.setWindowTitle("Generate Search Region Overlay?")
-        self.setModal(True)
-
-        layout = QFormLayout(self)
-
-        # Add Run button
-        run_button = QPushButton("Generate (Will go to Overlay 2)")
-        run_button.clicked.connect(self.searchoverlay)
-        layout.addWidget(run_button)
-
-    def searchoverlay(self):
-
-        try:
-
-            my_network.id_overlay = my_network.search_region
-
-            self.parent().load_channel(3, channel_data = my_network.search_region, data = True)
-
-            self.accept()
-
-        except Exception as e:
-
-            print(f"Error with Overlay Generation: {e}")
 
 class IdOverlayDialog(QDialog):
 
@@ -7732,7 +8171,7 @@ class IdOverlayDialog(QDialog):
             my_network.id_overlay = my_network.draw_edge_indices()
 
 
-        self.parent().load_channel(3, channel_data = my_network.id_overlay, data = True)
+        self.parent().load_channel(3, channel_data = my_network.id_overlay, data = True, preserve_zoom = (self.parent().ax.get_xlim(), self.parent().ax.get_ylim()))
 
         self.accept()
 
@@ -7781,7 +8220,7 @@ class ColorOverlayDialog(QDialog):
             self.parent().format_for_upperright_table(legend, f'{self.sort} Id', f'Encoding Val: {self.sort}', 'Legend')
 
 
-            self.parent().load_channel(3, channel_data = result, data = True)
+            self.parent().load_channel(3, channel_data = result, data = True, preserve_zoom = (self.parent().ax.get_xlim(), self.parent().ax.get_ylim()))
 
             self.accept()
 
@@ -7849,7 +8288,7 @@ class ShuffleDialog(QDialog):
                     except:
                         self.parent().highlight_overay = None
                 else:
-                    self.parent().load_channel(accepted_mode, channel_data = target_data, data = True)
+                    self.parent().load_channel(accepted_mode, channel_data = target_data, data = True, preserve_zoom = (self.parent().ax.get_xlim(), self.parent().ax.get_ylim()))
             except:
                 pass
 
@@ -7861,14 +8300,14 @@ class ShuffleDialog(QDialog):
                     except:
                         self.parent().highlight_overlay = None
                 else:
-                    self.parent().load_channel(accepted_target, channel_data = active_data, data = True)
+                    self.parent().load_channel(accepted_target, channel_data = active_data, data = True, preserve_zoom = (self.parent().ax.get_xlim(), self.parent().ax.get_ylim()))
             except:
                 pass
 
 
 
 
-            self.parent().update_display()
+            self.parent().update_display(preserve_zoom = (self.parent().ax.get_xlim(), self.parent().ax.get_ylim()))
 
             self.accept()
 
@@ -8476,10 +8915,10 @@ class NearNeighDialog(QDialog):
                 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, 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)
+                self.parent().load_channel(3, overlay, data = True, preserve_zoom = (self.parent().ax.get_xlim(), self.parent().ax.get_ylim()))
 
             if quant_overlay is not None:
-                self.parent().load_channel(2, quant_overlay, data = True)
+                self.parent().load_channel(2, quant_overlay, data = True, preserve_zoom = (self.parent().ax.get_xlim(), self.parent().ax.get_ylim()))
 
             avg = {header:avg}
 
@@ -8595,6 +9034,8 @@ class NeighborIdentityDialog(QDialog):
 
             self.accept()
         except Exception as e:
+            import traceback
+            print(traceback.format_exc())
             print(f"Error: {e}")
 
 
@@ -8826,7 +9267,7 @@ class HeatmapDialog(QDialog):
             else:
 
                 heat_dict, overlay = my_network.community_heatmap(num_nodes = nodecount, is3d = is3d, numpy = True)
-                self.parent().load_channel(3, overlay, data = True)
+                self.parent().load_channel(3, overlay, data = True, preserve_zoom = (self.parent().ax.get_xlim(), self.parent().ax.get_ylim()))
 
 
             self.parent().format_for_upperright_table(heat_dict, metric='Community', value='ln(Predicted Community Nodecount/Actual)', title="Community Heatmap")
@@ -9183,7 +9624,7 @@ class DegreeDialog(QDialog):
                 nodes = n3d.upsample_with_padding(nodes, down_factor, original_shape)
 
             if accepted_mode > 0:
-                self.parent().load_channel(3, channel_data = nodes, data = True)
+                self.parent().load_channel(3, channel_data = nodes, data = True, preserve_zoom = (self.parent().ax.get_xlim(), self.parent().ax.get_ylim()))
 
 
             self.accept()
@@ -9246,7 +9687,7 @@ class HubDialog(QDialog):
 
             if img is not None:
 
-                self.parent().load_channel(3, channel_data = img, data = True)
+                self.parent().load_channel(3, channel_data = img, data = True, preserve_zoom = (self.parent().ax.get_xlim(), self.parent().ax.get_ylim()))
 
 
             self.accept()
@@ -9305,7 +9746,7 @@ class MotherDialog(QDialog):
                 G = my_network.isolate_mothers(self, ret_nodes = True, called = True)
             else:
                 G, result = my_network.isolate_mothers(self, ret_nodes = False, called = True)
-                self.parent().load_channel(2, channel_data = result, data = True)
+                self.parent().load_channel(2, channel_data = result, data = True, preserve_zoom = (self.parent().ax.get_xlim(), self.parent().ax.get_ylim()))
 
             degree_dict = {}
 
@@ -9380,8 +9821,7 @@ class CodeDialog(QDialog):
 
             self.parent().format_for_upperright_table(output, f'{self.sort} Id', f'Encoding Val: {self.sort}', 'Legend')
 
-
-            self.parent().load_channel(3, image, True)
+            self.parent().load_channel(3, image, True, preserve_zoom = (self.parent().ax.get_xlim(), self.parent().ax.get_ylim()))
             self.accept()
 
         except Exception as e:
@@ -9794,7 +10234,7 @@ class BinarizeDialog(QDialog):
                 # Update the corresponding property in my_network
                 setattr(my_network, network_properties[self.parent().active_channel], result)
 
-                self.parent().update_display()
+                self.parent().update_display(preserve_zoom = (self.parent().ax.get_xlim(), self.parent().ax.get_ylim()))
                 self.accept()
                 
             except Exception as e:
@@ -9846,7 +10286,7 @@ class LabelDialog(QDialog):
                 # Update the corresponding property in my_network
                 setattr(my_network, network_properties[self.parent().active_channel], result)
 
-                self.parent().update_display()
+                self.parent().update_display(preserve_zoom = (self.parent().ax.get_xlim(), self.parent().ax.get_ylim()))
                 self.accept()
                 
             except Exception as e:
@@ -9929,7 +10369,7 @@ class SLabelDialog(QDialog):
 
                 binary_array = binary_array * label_array
 
-                self.parent().load_channel(accepted_target, binary_array, True)
+                self.parent().load_channel(accepted_target, binary_array, True, preserve_zoom = (self.parent().ax.get_xlim(), self.parent().ax.get_ylim()))
 
                 self.accept()
                 
@@ -10613,6 +11053,10 @@ class MachineWindow(QMainWindow):
 
     def start_segmentation(self):
 
+        if self.parent().pan_mode:
+            self.parent().pan_button.click()
+
+
         self.parent().static_background = None
 
         self.kill_segmentation()
@@ -10934,11 +11378,15 @@ class SegmentationWorker(QThread):
 
 
 class ThresholdWindow(QMainWindow):
+    processing_complete = pyqtSignal()  # Emitted when user finishes and images are modified
+    processing_cancelled = pyqtSignal()  # Emitted when user cancels
+
     def __init__(self, parent=None, accepted_mode=0):
         super().__init__(parent)
         self.setWindowTitle("Threshold")
 
         self.accepted_mode = accepted_mode
+        self.preview = True
         
         # Create central widget and layout
         central_widget = QWidget()
@@ -10970,6 +11418,10 @@ class ThresholdWindow(QMainWindow):
             self.histo_list = list(self.parent().degree_dict.values())
             self.bounds = False
             self.parent().bounds = False
+        elif accepted_mode == 4:
+            self.histo_list = list(self.parent().special_dict.values())
+            self.bounds = False
+            self.parent().bounds = False
 
         elif accepted_mode == 0:
             targ_shape = self.parent().channel_data[self.parent().active_channel].shape
@@ -11041,16 +11493,39 @@ class ThresholdWindow(QMainWindow):
         self.preview.clicked.connect(self.preview_mode)
         form_layout.addRow("Show Preview:", self.preview)
 
-        run_button = QPushButton("Apply Threshold")
-        run_button.clicked.connect(self.thresh)
-        form_layout.addRow(run_button)
+        button_layout = QHBoxLayout()
+
+
+        # Keep your existing Apply Threshold button, but modify its behavior
+        run_button = QPushButton("Apply Threshold/Continue")
+        run_button.clicked.connect(self.apply_and_continue)  # New method
+        button_layout.addWidget(run_button)
         
-        layout.addLayout(form_layout)
+        # Add Cancel button for external dialog use
+        cancel_button = QPushButton("Cancel/Skip")
+        cancel_button.clicked.connect(self.cancel_processing)
+        button_layout.addWidget(cancel_button)
         
+        form_layout.addRow(button_layout)
+        layout.addLayout(form_layout)
+                
         # Set a reasonable default size
         self.setMinimumWidth(400)
         self.setMinimumHeight(400)
 
+    def apply_and_continue(self):
+        """Apply threshold, modify main window images, then signal completion"""
+        self.thresh()  # This should modify the main window images
+        
+        # Signal that processing is complete
+        self.processing_complete.emit()
+        self.close()
+    
+    def cancel_processing(self):
+        """Cancel without applying changes"""
+        self.processing_cancelled.emit()
+        self.close()
+
     def closeEvent(self, event):
         self.parent().preview = False
         self.parent().targs = None
@@ -11102,6 +11577,10 @@ class ThresholdWindow(QMainWindow):
             for node, vol in self.parent().degree_dict.items():
                 if min_val <= vol <= max_val:
                     output.append(node)
+        elif self.accepted_mode == 4:
+            for node, vol in self.parent().special_dict.items():
+                if min_val <= vol <= max_val:
+                    output.append(node)
         return output
 
     def get_values_in_range(self, lst, min_val, max_val):
@@ -11119,11 +11598,18 @@ class ThresholdWindow(QMainWindow):
             for item in self.parent().degree_dict:
                 if self.parent().degree_dict[item] in values:
                     output.append(item)
+        elif self.accepted_mode == 4:
+            for item in self.parent().special_dict:
+                if self.parent().special_dict[item] in values:
+                    output.append(item)
+
         return output
 
 
     def min_value_changed(self):
         try:
+            if not self.preview.isChecked():
+                self.preview.click()
             text = self.min.text()
             if not text:  # If empty, ignore
                 return
@@ -11171,6 +11657,8 @@ class ThresholdWindow(QMainWindow):
 
     def max_value_changed(self):
         try:
+            if not self.preview.isChecked():
+                self.preview.click()
             text = self.max.text()
             if not text:  # If empty, ignore
                 return
@@ -11294,7 +11782,6 @@ class ThresholdWindow(QMainWindow):
                 f"Error running threshold: {str(e)}"
             )
 
-
 class SmartDilateDialog(QDialog):
     def __init__(self, parent, params):
         super().__init__(parent)
@@ -11336,7 +11823,7 @@ class SmartDilateDialog(QDialog):
 
         result = sdl.smart_dilate(active_data, dilate_xy, dilate_z, GPU = GPU, predownsample = down_factor, fast_dil = predt, use_dt_dil_amount = amount, xy_scale = xy_scale, z_scale = z_scale)
 
-        self.parent().load_channel(self.parent().active_channel, result, True)
+        self.parent().load_channel(self.parent().active_channel, result, True, preserve_zoom = (self.parent().ax.get_xlim(), self.parent().ax.get_ylim()))
         self.accept()
 
 
@@ -11477,7 +11964,7 @@ class ErodeDialog(QDialog):
 
         # Add mode selection dropdown
         self.mode_selector = QComboBox()
-        self.mode_selector.addItems(["Pseudo3D Binary Kernels (For Fast, small erosions)", "Distance Transform-Based (Slower but more accurate at larger dilations)"])
+        self.mode_selector.addItems(["Pseudo3D Binary Kernels (For Fast, small erosions)", "Distance Transform-Based (Slower but more accurate at larger dilations)", "Preserve Labels (Slower)"])
         self.mode_selector.setCurrentIndex(0)  # Default to Mode 1
         layout.addRow("Execution Mode:", self.mode_selector)
 
@@ -11513,6 +12000,12 @@ class ErodeDialog(QDialog):
                 z_scale = 1
 
             mode = self.mode_selector.currentIndex()
+
+            if mode == 2:
+                mode = 1
+                preserve_labels = True
+            else:
+                preserve_labels = False
             
             # Get the active channel data from parent
             active_data = self.parent().channel_data[self.parent().active_channel]
@@ -11525,14 +12018,13 @@ class ErodeDialog(QDialog):
                 amount,
                 xy_scale = xy_scale,
                 z_scale = z_scale,
-                mode = mode
+                mode = mode,
+                preserve_labels = preserve_labels
             )
 
 
-            self.parent().load_channel(self.parent().active_channel, result, True)
-
+            self.parent().load_channel(self.parent().active_channel, result, True, preserve_zoom = (self.parent().ax.get_xlim(), self.parent().ax.get_ylim()))
 
-            self.parent().update_display(preserve_zoom=(current_xlim, current_ylim))
             self.accept()
             
         except Exception as e:
@@ -11598,7 +12090,7 @@ class HoleDialog(QDialog):
                 self.parent().load_channel(3, active_data - result, True)
 
 
-            self.parent().update_display()
+            self.parent().update_display(preserve_zoom = (self.parent().ax.get_xlim(), self.parent().ax.get_ylim()))
             self.accept()
             
         except Exception as e:
@@ -11676,9 +12168,9 @@ class MaskDialog(QDialog):
 
 
                     # Update both the display data and the network object
-                    self.parent().load_channel(output_target, channel_data = result, data = True)
+                    self.parent().load_channel(output_target, channel_data = result, data = True,)
 
-                self.parent().update_display()
+                self.parent().update_display(preserve_zoom = (self.parent().ax.get_xlim(), self.parent().ax.get_ylim()))
 
                 self.accept()
 
@@ -11911,7 +12403,7 @@ class TypeDialog(QDialog):
 
                 active_data = active_data.astype(np.float64)
 
-            self.parent().load_channel(self.active_chan, active_data, True)
+            self.parent().load_channel(self.active_chan, active_data, True, preserve_zoom = (self.parent().ax.get_xlim(), self.parent().ax.get_ylim()))
 
 
             print(f"Channel {self.active_chan}) dtype now: {self.parent().channel_data[self.active_chan].dtype}")
@@ -11972,6 +12464,8 @@ class SkeletonizeDialog(QDialog):
 
             if remove > 0:
                 result = n3d.remove_branches_new(result, remove)
+                result = n3d.dilate_3D(result, 3, 3, 3)
+                result = n3d.skeletonize(result)
 
 
             # Update both the display data and the network object
@@ -11981,7 +12475,7 @@ class SkeletonizeDialog(QDialog):
             # Update the corresponding property in my_network
             setattr(my_network, network_properties[self.parent().active_channel], result)
 
-            self.parent().update_display()
+            self.parent().update_display(preserve_zoom = (self.parent().ax.get_xlim(), self.parent().ax.get_ylim()))
             self.accept()
             
         except Exception as e:
@@ -12012,7 +12506,7 @@ class DistanceDialog(QDialog):
 
             data = sdl.compute_distance_transform_distance(data, sampling = [my_network.z_scale, my_network.xy_scale, my_network.xy_scale])
 
-            self.parent().load_channel(self.parent().active_channel, data, data = True)
+            self.parent().load_channel(self.parent().active_channel, data, data = True, preserve_zoom = (self.parent().ax.get_xlim(), self.parent().ax.get_ylim()))
 
         except Exception as e:
 
@@ -12050,7 +12544,7 @@ class GrayWaterDialog(QDialog):
 
             data = n3d.gray_watershed(data, min_peak_distance, min_intensity)
 
-            self.parent().load_channel(self.parent().active_channel, data, data = True)
+            self.parent().load_channel(self.parent().active_channel, data, data = True, preserve_zoom = (self.parent().ax.get_xlim(), self.parent().ax.get_ylim()))
 
             self.accept()
 
@@ -12175,7 +12669,7 @@ class WatershedDialog(QDialog):
             # Update the corresponding property in my_network
             setattr(my_network, network_properties[self.parent().active_channel], result)
 
-            self.parent().update_display()
+            self.parent().update_display(preserve_zoom = (self.parent().ax.get_xlim(), self.parent().ax.get_ylim()))
             self.accept()
             
         except Exception as e:
@@ -12228,7 +12722,7 @@ class InvertDialog(QDialog):
                 # Update the corresponding property in my_network
                 setattr(my_network, network_properties[self.parent().active_channel], result)
 
-                self.parent().update_display()
+                self.parent().update_display(preserve_zoom = (self.parent().ax.get_xlim(), self.parent().ax.get_ylim()))
                 self.accept()
                 
             except Exception as e:
@@ -12272,7 +12766,7 @@ class ZDialog(QDialog):
         for i in range(len(self.parent().channel_data)):
             try:
                 self.parent().channel_data[i] = n3d.z_project(self.parent().channel_data[i], mode)
-                self.parent().load_channel(i, self.parent().channel_data[i], True)
+                self.parent().load_channel(i, self.parent().channel_data[i], True, preserve_zoom = (self.parent().ax.get_xlim(), self.parent().ax.get_ylim()))
             except:
                 pass
 
@@ -12775,7 +13269,7 @@ class BranchDialog(QDialog):
 
                 self.parent().load_channel(1, channel_data = output, data = True)
 
-            self.parent().update_display()
+            self.parent().update_display(preserve_zoom = (self.parent().ax.get_xlim(), self.parent().ax.get_ylim()))
             self.accept()
 
         except Exception as e:
@@ -12946,6 +13440,12 @@ class ModifyDialog(QDialog):
         self.revid.setChecked(False)
         layout.addRow("Remove Unassigned IDs from Centroid List?:", self.revid)
 
+        self.revdupeid = QPushButton("Make Singleton IDs")
+        self.revdupeid.setCheckable(True)
+        self.revdupeid.setChecked(False)
+        layout.addRow("Force Any Multiple IDs to Pick a Random Single ID?:", self.revdupeid)
+
+
         self.remove = QPushButton("Remove Missing")
         self.remove.setCheckable(True)
         self.remove.setChecked(False)
@@ -13024,6 +13524,7 @@ class ModifyDialog(QDialog):
         try:
 
             revid = self.revid.isChecked()
+            revdupeid = self.revdupeid.isChecked()
             trunk = self.trunk.isChecked()
             if not trunk:
                 trunknode = self.trunknode.isChecked()
@@ -13048,6 +13549,20 @@ class ModifyDialog(QDialog):
                 except:
                     pass
 
+            if revdupeid:
+                try:
+                    for node, iden in my_network.node_identities.items():
+                        try:
+                            import ast
+                            import random
+                            iden = ast.literal_eval(iden)
+                            my_network.node_identities[node] = random.choice(iden)
+                        except:
+                            pass
+                    self.parent().format_for_upperright_table(my_network.node_identities, 'NodeID', 'Identity', 'Node Identities')
+                except:
+                    pass
+
 
             if remove:
                 my_network.purge_properties()
@@ -13155,6 +13670,11 @@ class CentroidDialog(QDialog):
         self.mode_selector.setCurrentIndex(0)  # Default to Mode 1
         layout.addRow("Execution Mode:", self.mode_selector)
 
+        self.ignore_empty = QPushButton("Skip ID-less?")
+        self.ignore_empty.setCheckable(True)
+        self.ignore_empty.setChecked(False)
+        layout.addRow("Skip Node Centroids Without Identity Property?:", self.ignore_empty)
+
         # Add Run button
         run_button = QPushButton("Run Calculate Centroids")
         run_button.clicked.connect(self.run_centroids)
@@ -13167,6 +13687,7 @@ class CentroidDialog(QDialog):
             print("Calculating centroids...")
 
             chan = self.mode_selector.currentIndex()
+            ignore_empty = self.ignore_empty.isChecked()
 
             # Get directory (None if empty)
             directory = self.directory.text() if self.directory.text() else None
@@ -13227,6 +13748,12 @@ class CentroidDialog(QDialog):
                 except Exception as e:
                     print(f"Error loading edge centroid table: {e}")
 
+            if ignore_empty:
+                try:
+                    my_network.remove_ids()
+                    self.parent().format_for_upperright_table(my_network.node_centroids, 'NodeID', ['Z', 'Y', 'X'], 'Node Centroids')
+                except:
+                    pass
 
             self.parent().update_display()
             self.accept()