nettracer3d 0.9.3__py3-none-any.whl → 0.9.5__py3-none-any.whl

nettracer3d/nettracer_gui.py

@@ -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)
@@ -1979,6 +1976,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 +2016,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,12 +2462,11 @@ 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()
@@ -2471,7 +2492,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 +2569,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 +2596,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 +3084,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 +3113,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 +3160,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 +3189,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]
             
-            # Handle different image types
+            # 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)
+            
+            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:
+                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 image
+                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 +3483,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 +3541,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 +3556,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 +3657,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 +3666,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 +3695,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 +3702,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 +3762,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 +3839,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 +3856,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
@@ -4011,7 +4291,9 @@ class ImageViewerWindow(QMainWindow):
         id_code_action = overlay_menu.addAction("Code Identities")
         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_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")
@@ -4078,7 +4360,7 @@ 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")
@@ -4100,8 +4382,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")
@@ -4684,18 +4964,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:
@@ -4751,10 +5020,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"""
@@ -5446,12 +5711,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])
@@ -5557,7 +5818,7 @@ 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):
         """Method to flexibly reset certain fields to free up the RAM as desired"""
@@ -5689,6 +5950,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
 
@@ -5761,9 +6025,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
@@ -5772,7 +6036,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
@@ -5858,8 +6121,8 @@ class ImageViewerWindow(QMainWindow):
             y_max = min(min_height, int(np.ceil(current_ylim[0] + 0.5)))
 
             if self.pan_mode:
-                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)
@@ -6195,13 +6458,20 @@ class ImageViewerWindow(QMainWindow):
         dialog = CodeDialog(self, sort = sort)
         dialog.exec()
 
-    def handle_umap(self):
+    def handle_centroid_umap(self):
 
         if my_network.node_centroids is None:
             self.show_centroid_dialog()
 
         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"""
         
@@ -7230,7 +7500,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):
@@ -7468,6 +7738,12 @@ class MergeNodeIdDialog(QDialog):
         self.z_scale = QLineEdit(f"{my_network.z_scale}")
         layout.addRow("z_scale:", self.z_scale)
 
+        # Add Run button
+        self.include = QPushButton("Include Negative Gates?")
+        self.include.setCheckable(True)
+        self.include.setChecked(True)
+        layout.addWidget(self.include)
+
         # Add Run button
         run_button = QPushButton("Get Directory")
         run_button.clicked.connect(self.run)
@@ -7483,6 +7759,7 @@ class MergeNodeIdDialog(QDialog):
 
 
             data = self.parent().channel_data[0]
+            include = self.include.isChecked()
 
             if data is None:
                 return
@@ -7501,7 +7778,7 @@ class MergeNodeIdDialog(QDialog):
             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)
 
-            my_network.merge_node_ids(selected_path, data)
+            my_network.merge_node_ids(selected_path, data, include)
 
             self.parent().format_for_upperright_table(my_network.node_identities, 'NodeID', 'Identity')
 
@@ -7627,7 +7904,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()
 
@@ -7635,34 +7912,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):
 
@@ -7716,7 +7965,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()
 
@@ -7765,7 +8014,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()
 
@@ -7833,7 +8082,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
 
@@ -7845,14 +8094,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()
 
@@ -8460,10 +8709,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}
 
@@ -8579,6 +8828,8 @@ class NeighborIdentityDialog(QDialog):
 
             self.accept()
         except Exception as e:
+            import traceback
+            print(traceback.format_exc())
             print(f"Error: {e}")
 
 
@@ -8810,7 +9061,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")
@@ -9167,7 +9418,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()
@@ -9230,7 +9481,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()
@@ -9289,7 +9540,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 = {}
 
@@ -9364,8 +9615,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:
@@ -9778,7 +10028,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:
@@ -9830,7 +10080,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:
@@ -9913,7 +10163,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()
                 
@@ -10597,6 +10847,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()
@@ -11320,7 +11574,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()
 
 
@@ -11461,7 +11715,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)
 
@@ -11497,6 +11751,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]
@@ -11509,14 +11769,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:
@@ -11582,7 +11841,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:
@@ -11660,9 +11919,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()
 
@@ -11895,7 +12154,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}")
@@ -11956,6 +12215,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
@@ -11965,7 +12226,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:
@@ -11996,7 +12257,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:
 
@@ -12034,7 +12295,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()
 
@@ -12159,7 +12420,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:
@@ -12212,7 +12473,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:
@@ -12256,7 +12517,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
 
@@ -12759,7 +13020,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:
@@ -13139,6 +13400,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)
@@ -13151,6 +13417,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
@@ -13211,6 +13478,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()