nettracer3d 0.8.9__py3-none-any.whl → 0.9.1__py3-none-any.whl

nettracer3d/nettracer_gui.py

@@ -102,7 +102,7 @@ class ImageViewerWindow(QMainWindow):
         "WHITE": (1, 1, 1),
         "GRAY": (0.5, 0.5, 0.5),
         "LIGHT_GRAY": (0.8, 0.8, 0.8),
-        "DARK_GRAY": (0.2, 0.2, 0.2)
+        "DARK_GRAY": (0.2, 0.2, 0.2),
         }
 
         self.base_colors = [ #Channel colors
@@ -466,6 +466,8 @@ class ImageViewerWindow(QMainWindow):
 
         self.resume = False
 
+        self.hold_update = False
+
     def start_left_scroll(self):
         """Start scrolling left when left arrow is pressed."""
         # Single increment first
@@ -500,7 +502,6 @@ class ImageViewerWindow(QMainWindow):
             self.slice_slider.setValue(new_value)
         elif self.scroll_direction > 0 and new_value <= self.slice_slider.maximum():
             self.slice_slider.setValue(new_value)
-        
 
     def create_highlight_overlay(self, node_indices=None, edge_indices=None, overlay1_indices = None, overlay2_indices = None, bounds = False):
         """
@@ -514,6 +515,17 @@ class ImageViewerWindow(QMainWindow):
         self.mini_overlay = False #If this method is ever being called, it means we are rendering the entire overlay so mini overlay needs to reset.
         self.mini_overlay_data = None
 
+
+        if not self.high_button.isChecked():
+
+            if len(self.clicked_values['edges']) > 0:
+                self.format_for_upperright_table(self.clicked_values['edges'], title = 'Selected Edges')
+            if len(self.clicked_values['nodes']) > 0:
+                self.format_for_upperright_table(self.clicked_values['nodes'], title = 'Selected Nodes')
+
+            return
+
+
         def process_chunk(chunk_data, indices_to_check):
             """Process a single chunk of the array to create highlight mask"""
             mask = np.isin(chunk_data, indices_to_check)
@@ -550,7 +562,7 @@ class ImageViewerWindow(QMainWindow):
         current_xlim = self.ax.get_xlim() if hasattr(self, 'ax') and self.ax.get_xlim() != (0, 1) else None
         current_ylim = self.ax.get_ylim() if hasattr(self, 'ax') and self.ax.get_ylim() != (0, 1) else None
         
-        if not node_indices and not edge_indices and not overlay1_indices and not overlay2_indices:
+        if not node_indices and not edge_indices and not overlay1_indices and not overlay2_indices and self.machine_window is None:
             self.highlight_overlay = None
             self.highlight_bounds = None
             self.update_display(preserve_zoom=(current_xlim, current_ylim))
@@ -623,7 +635,7 @@ class ImageViewerWindow(QMainWindow):
             self.highlight_overlay = np.maximum(self.highlight_overlay, overlay1_overlay)
         if overlay2_overlay is not None:
             self.highlight_overlay = np.maximum(self.highlight_overlay, overlay2_overlay)
-                
+        
         # Update display
         self.update_display(preserve_zoom=(current_xlim, current_ylim))
 
@@ -822,10 +834,6 @@ class ImageViewerWindow(QMainWindow):
 
 
 
-        
-
-
-
 #METHODS RELATED TO RIGHT CLICK:
     
     def create_context_menu(self, event):
@@ -1991,7 +1999,10 @@ class ImageViewerWindow(QMainWindow):
                             del my_network.network_lists[0][i]
                             del my_network.network_lists[1][i]
                             del my_network.network_lists[2][i]
-
+                    for node in self.clicked_values['nodes']:
+                        del my_network.node_centroids[node]
+                        del my_network.node_identities[node]
+                        del my_network.communities[node]
 
 
             if len(self.clicked_values['edges']) > 0:
@@ -2006,6 +2017,8 @@ class ImageViewerWindow(QMainWindow):
                             del my_network.network_lists[0][i]
                             del my_network.network_lists[1][i]
                             del my_network.network_lists[2][i]
+                    for node in self.clicked_values['edges']:
+                        del my_network.edge_centroids[edge]
 
             my_network.network_lists = my_network.network_lists
 
@@ -2021,7 +2034,7 @@ class ImageViewerWindow(QMainWindow):
                 for column in range(model.columnCount(None)):
                     self.network_table.resizeColumnToContents(column)
 
-            self.show_centroid_dialog()
+            #self.show_centroid_dialog()
         except Exception as e:
             print(f"Error: {e}")
 
@@ -2147,11 +2160,16 @@ class ImageViewerWindow(QMainWindow):
         current_xlim = self.ax.get_xlim() if hasattr(self, 'ax') and self.ax.get_xlim() != (0, 1) else None
         current_ylim = self.ax.get_ylim() if hasattr(self, 'ax') and self.ax.get_ylim() != (0, 1) else None
 
-        if self.high_button.isChecked():
+        if self.high_button.isChecked() and self.machine_window is None:
             if self.highlight_overlay is None and ((len(self.clicked_values['nodes']) + len(self.clicked_values['edges'])) > 0):
                 if self.needs_mini:
                     self.create_mini_overlay(node_indices = self.clicked_values['nodes'], edge_indices = self.clicked_values['edges'])
                     self.needs_mini = False
+                else:
+                    self.create_highlight_overlay(node_indices = self.clicked_values['nodes'], edge_indices = self.clicked_values['edges'])
+            else:
+                self.create_highlight_overlay(node_indices = self.clicked_values['nodes'], edge_indices = self.clicked_values['edges'])
+
         
         self.update_display(preserve_zoom=(current_xlim, current_ylim))
 
@@ -2233,6 +2251,11 @@ class ImageViewerWindow(QMainWindow):
                 
                 # Store current channel visibility state
                 self.pre_pan_channel_state = self.channel_visible.copy()
+
+                self.prev_down = self.downsample_factor
+                if self.throttle:
+                    if self.downsample_factor < 3:
+                        self.validate_downsample_input(text = 3)
                 
                 # Create static background from currently visible channels
                 self.create_pan_background()
@@ -2782,7 +2805,7 @@ class ImageViewerWindow(QMainWindow):
         self.pan_zoom_state = (current_xlim, current_ylim)
 
     def create_composite_for_pan(self):
-        """Create a properly rendered composite image for panning"""
+        """Create a properly rendered composite image for panning with downsample support"""
         # Get active channels and dimensions (copied from update_display)
         active_channels = [i for i in range(4) if self.channel_data[i] is not None]
         if active_channels:
@@ -2793,8 +2816,33 @@ class ImageViewerWindow(QMainWindow):
         else:
             return None
         
-        # Create a blank RGBA composite to accumulate all channels
-        composite = np.zeros((min_height, min_width, 4), dtype=np.float32)
+        # Store original dimensions for coordinate mapping
+        self.original_dims = (min_height, min_width)
+        
+        # Get current downsample factor
+        downsample_factor = getattr(self, 'downsample_factor', 1)
+        
+        # Calculate display dimensions (downsampled)
+        display_height = min_height // downsample_factor
+        display_width = min_width // downsample_factor
+        
+        # Helper function to downsample image (same as in update_display)
+        def downsample_image(image, factor):
+            if factor == 1:
+                return image
+            
+            # Handle different image types
+            if len(image.shape) == 2:
+                # Grayscale
+                return image[::factor, ::factor]
+            elif len(image.shape) == 3:
+                # RGB/RGBA
+                return image[::factor, ::factor, :]
+            else:
+                return image
+        
+        # Create a blank RGBA composite to accumulate all channels (using display dimensions)
+        composite = np.zeros((display_height, display_width, 4), dtype=np.float32)
         
         # Process each visible channel exactly like update_display does
         for channel in range(4):
@@ -2811,24 +2859,27 @@ class ImageViewerWindow(QMainWindow):
                 else:
                     current_image = self.channel_data[channel]
 
+                # Downsample the image for rendering
+                display_image = downsample_image(current_image, downsample_factor)
+
                 if is_rgb and self.channel_data[channel].shape[-1] == 3:
                     # RGB image - convert to RGBA and blend
-                    rgb_alpha = np.ones((*current_image.shape[:2], 4), dtype=np.float32)
-                    rgb_alpha[:, :, :3] = current_image.astype(np.float32) / 255.0
+                    rgb_alpha = np.ones((*display_image.shape[:2], 4), dtype=np.float32)
+                    rgb_alpha[:, :, :3] = display_image.astype(np.float32) / 255.0
                     rgb_alpha[:, :, 3] = 0.7  # Same alpha as update_display
                     composite = self.blend_layers(composite, rgb_alpha)
                     
                 elif is_rgb and self.channel_data[channel].shape[-1] == 4:
                     # RGBA image - blend directly
-                    rgba_image = current_image.astype(np.float32) / 255.0
+                    rgba_image = display_image.astype(np.float32) / 255.0
                     composite = self.blend_layers(composite, rgba_image)
                     
                 else:
                     # Regular channel processing (same logic as update_display)
                     if self.min_max[channel][0] == None:
-                        self.min_max[channel][0] = np.min(current_image)
+                        self.min_max[channel][0] = np.min(self.channel_data[channel])
                     if self.min_max[channel][1] == None:
-                        self.min_max[channel][1] = np.max(current_image)
+                        self.min_max[channel][1] = np.max(self.channel_data[channel])
 
                     img_min = self.min_max[channel][0]
                     img_max = self.min_max[channel][1]
@@ -2840,16 +2891,16 @@ class ImageViewerWindow(QMainWindow):
                         vmin = img_min + (img_max - img_min) * self.channel_brightness[channel]['min']
                         vmax = img_min + (img_max - img_min) * self.channel_brightness[channel]['max']
                     
-                    # Normalize the image
+                    # Normalize the downsampled image
                     if vmin == vmax:
-                        normalized_image = np.zeros_like(current_image)
+                        normalized_image = np.zeros_like(display_image)
                     else:
-                        normalized_image = np.clip((current_image - vmin) / (vmax - vmin), 0, 1)
+                        normalized_image = np.clip((display_image - vmin) / (vmax - vmin), 0, 1)
                     
                     # Apply channel color and alpha
                     if channel == 2 and self.machine_window is not None:
                         # Special case for machine window channel 2
-                        channel_rgba = self.apply_machine_colormap(current_image)
+                        channel_rgba = self.apply_machine_colormap(display_image)
                     else:
                         # Regular channel with custom color
                         color = self.base_colors[channel]
@@ -2862,16 +2913,18 @@ class ImageViewerWindow(QMainWindow):
                     # Blend this channel into the composite
                     composite = self.blend_layers(composite, channel_rgba)
         
-        # Add highlight overlays if they exist (same logic as update_display)
+        # Add highlight overlays if they exist (with downsampling)
         if self.mini_overlay and self.highlight and self.machine_window is None:
-            highlight_rgba = self.create_highlight_rgba(self.mini_overlay_data, yellow=True)
+            display_overlay = downsample_image(self.mini_overlay_data, downsample_factor)
+            highlight_rgba = self.create_highlight_rgba(display_overlay, yellow=True)
             composite = self.blend_layers(composite, highlight_rgba)
         elif self.highlight_overlay is not None and self.highlight:
             highlight_slice = self.highlight_overlay[self.current_slice]
+            display_highlight = downsample_image(highlight_slice, downsample_factor)
             if self.machine_window is None:
-                highlight_rgba = self.create_highlight_rgba(highlight_slice, yellow=True)
+                highlight_rgba = self.create_highlight_rgba(display_highlight, yellow=True)
             else:
-                highlight_rgba = self.create_highlight_rgba(highlight_slice, yellow=False)
+                highlight_rgba = self.create_highlight_rgba(display_highlight, yellow=False)
             composite = self.blend_layers(composite, highlight_rgba)
         
         # Convert to 0-255 range for display
@@ -2902,7 +2955,7 @@ class ImageViewerWindow(QMainWindow):
         if yellow:
             # Yellow highlight
             mask = highlight_data > 0
-            rgba[mask] = [1, 1, 0, 0.5]  # Yellow with alpha 0.5
+            rgba[mask] = [1, 1, 0, 0.8]  # Yellow with alpha 0.5
         else:
             # Multi-color highlight for machine window
             mask_1 = (highlight_data == 1)
@@ -2914,7 +2967,31 @@ class ImageViewerWindow(QMainWindow):
 
     def blend_layers(self, base, overlay):
         """Alpha blend two RGBA layers"""
-        # Standard alpha blending formula
+        
+        def resize_overlay_to_base(overlay_arr, base_arr):
+            base_height, base_width = base_arr.shape[:2]
+            overlay_height, overlay_width = overlay_arr.shape[:2]
+            
+            # First crop if overlay is larger
+            cropped_overlay = overlay_arr[:base_height, :base_width]
+            
+            # Then pad if still smaller after cropping
+            current_height, current_width = cropped_overlay.shape[:2]
+            pad_height = base_height - current_height
+            pad_width = base_width - current_width
+            
+            if pad_height > 0 or pad_width > 0:
+                cropped_overlay = np.pad(cropped_overlay,
+                                        ((0, pad_height), (0, pad_width), (0, 0)),
+                                        mode='constant', constant_values=0)
+            
+            return cropped_overlay
+        
+        # Resize the ENTIRE overlay array to match base dimensions
+        if overlay.shape[:2] != base.shape[:2]:
+            overlay = resize_overlay_to_base(overlay, base)
+        
+        # Now extract alpha channels (they should be the same size)
         alpha_overlay = overlay[:, :, 3:4]
         alpha_base = base[:, :, 3:4]
         
@@ -2936,17 +3013,26 @@ class ImageViewerWindow(QMainWindow):
         return result
 
     def update_display_pan_mode(self):
-        """Lightweight display update for pan preview mode"""
+        """Lightweight display update for pan preview mode with downsample support"""
 
         if self.is_pan_preview and self.pan_background_image is not None:
             # Clear and setup axes
             self.ax.clear()
             self.ax.set_facecolor('black')
             
-            # Get dimensions
-            height, width = self.pan_background_image.shape[:2]
+            # Get original dimensions (before downsampling)
+            if hasattr(self, 'original_dims') and self.original_dims:
+                height, width = self.original_dims
+            else:
+                # Fallback to pan background image dimensions
+                height, width = self.pan_background_image.shape[:2]
+                # If we have downsample factor, scale back up
+                downsample_factor = getattr(self, 'downsample_factor', 1)
+                height *= downsample_factor
+                width *= downsample_factor
             
             # Display the composite background with preserved zoom
+            # Use extent to stretch downsampled image back to original coordinate space
             self.ax.imshow(self.pan_background_image, 
                           extent=(-0.5, width-0.5, height-0.5, -0.5),
                           aspect='equal')
@@ -2956,10 +3042,16 @@ class ImageViewerWindow(QMainWindow):
                 self.ax.set_xlim(self.pan_zoom_state[0])
                 self.ax.set_ylim(self.pan_zoom_state[1])
             
+            # Get downsample factor for title display
+            downsample_factor = getattr(self, 'downsample_factor', 1)
+            
             # Style the axes (same as update_display)
             self.ax.set_xlabel('X')
-            self.ax.set_ylabel('Y') 
-            self.ax.set_title(f'Slice {self.current_slice}')
+            self.ax.set_ylabel('Y')
+            if downsample_factor > 1:
+                self.ax.set_title(f'Slice {self.current_slice} (DS: {downsample_factor}x)')
+            else:
+                self.ax.set_title(f'Slice {self.current_slice}')
             self.ax.xaxis.label.set_color('black')
             self.ax.yaxis.label.set_color('black')
             self.ax.title.set_color('black')
@@ -2967,7 +3059,7 @@ class ImageViewerWindow(QMainWindow):
             for spine in self.ax.spines.values():
                 spine.set_color('black')
                 
-            # Add measurement points if they exist (same as update_display)
+            # Add measurement points if they exist (coordinates remain in original space)
             for point in self.measurement_points:
                 x1, y1, z1 = point['point1']
                 x2, y2, z2 = point['point2']
@@ -3093,7 +3185,10 @@ class ImageViewerWindow(QMainWindow):
                 except:
                     pass
                 self.selection_rect = None
-                self.canvas.draw()
+                current_xlim = self.ax.get_xlim() if hasattr(self, 'ax') and self.ax.get_xlim() != (0, 1) else None
+                current_ylim = self.ax.get_ylim() if hasattr(self, 'ax') and self.ax.get_ylim() != (0, 1) else None
+                self.update_display(preserve_zoom=(current_xlim, current_ylim))  
+                #self.canvas.draw()
 
         elif self.zoom_mode:
             # Handle zoom mode press
@@ -3126,11 +3221,13 @@ class ImageViewerWindow(QMainWindow):
                 
                 new_xlim = [xdata - x_range, xdata + x_range]
                 new_ylim = [ydata - y_range, ydata + y_range]
+
+                shift_pressed = 'shift' in event.modifiers
                 
-                if (new_xlim[0] <= self.original_xlim[0] or 
-                    new_xlim[1] >= self.original_xlim[1] or
-                    new_ylim[0] <= self.original_ylim[0] or
-                    new_ylim[1] >= self.original_ylim[1]):
+                if (new_xlim[0] <= 0 or 
+                    new_xlim[1] >= self.shape[2] or
+                    new_ylim[0] <= 0 or
+                    new_ylim[1] >= self.shape[1]) or shift_pressed:
                     self.ax.set_xlim(self.original_xlim)
                     self.ax.set_ylim(self.original_ylim)
                 else:
@@ -3142,7 +3239,10 @@ class ImageViewerWindow(QMainWindow):
                     if not hasattr(self, 'zoom_changed'):
                         self.zoom_changed = False
 
-            self.canvas.draw()
+            current_xlim = self.ax.get_xlim() if hasattr(self, 'ax') and self.ax.get_xlim() != (0, 1) else None
+            current_ylim = self.ax.get_ylim() if hasattr(self, 'ax') and self.ax.get_ylim() != (0, 1) else None
+            self.update_display(preserve_zoom=(current_xlim, current_ylim))    
+            #self.canvas.draw()
 
         #  Handle brush mode cleanup with paint session management
         if self.brush_mode and hasattr(self, 'painting') and self.painting:
@@ -3277,7 +3377,7 @@ class ImageViewerWindow(QMainWindow):
                 
                 if not hasattr(self, 'zoom_changed'):
                     self.zoom_changed = False
-                
+
             elif event.button == 3:  # Right click - zoom out
                 x_range = (current_xlim[1] - current_xlim[0])
                 y_range = (current_ylim[1] - current_ylim[0])
@@ -3296,10 +3396,11 @@ class ImageViewerWindow(QMainWindow):
                     self.ax.set_ylim(new_ylim)
 
 
-                self.zoom_changed = False  # Flag that zoom has changed
-                
-            
-            self.canvas.draw()
+            current_xlim = self.ax.get_xlim() if hasattr(self, 'ax') and self.ax.get_xlim() != (0, 1) else None
+            current_ylim = self.ax.get_ylim() if hasattr(self, 'ax') and self.ax.get_ylim() != (0, 1) else None
+            self.update_display(preserve_zoom=(current_xlim, current_ylim))                
+
+            #self.canvas.draw()
         
         elif event.button == 3:  # Right click
             self.create_context_menu(event)
@@ -3471,12 +3572,10 @@ class ImageViewerWindow(QMainWindow):
         stats_menu = analysis_menu.addMenu("Stats")
         allstats_action = stats_menu.addAction("Calculate Generic Network Stats")
         allstats_action.triggered.connect(self.stats)
-        histos_action = stats_menu.addAction("Calculate Generic Network Histograms")
+        histos_action = stats_menu.addAction("Network Statistic Histograms")
         histos_action.triggered.connect(self.histos)
         radial_action = stats_menu.addAction("Radial Distribution Analysis")
         radial_action.triggered.connect(self.show_radial_dialog)
-        degree_dist_action = stats_menu.addAction("Degree Distribution Analysis")
-        degree_dist_action.triggered.connect(self.show_degree_dist_dialog)
         neighbor_id_action = stats_menu.addAction("Identity Distribution of Neighbors")
         neighbor_id_action.triggered.connect(self.show_neighbor_id_dialog)
         ripley_action = stats_menu.addAction("Ripley Clustering Analysis")
@@ -3515,7 +3614,7 @@ class ImageViewerWindow(QMainWindow):
 
         # Process menu
         process_menu = menubar.addMenu("Process")
-        calculate_menu = process_menu.addMenu("Calculate")
+        calculate_menu = process_menu.addMenu("Calculate Network")
         calc_all_action = calculate_menu.addAction("Calculate Connectivity Network (Find Node-Edge-Node Network)")
         calc_all_action.triggered.connect(self.show_calc_all_dialog)
         calc_prox_action = calculate_menu.addAction("Calculate Proximity Network (connect nodes by distance)")
@@ -3608,53 +3707,189 @@ class ImageViewerWindow(QMainWindow):
         help_button = menubar.addAction("Help")
         help_button.triggered.connect(self.help_me)
 
+        # Initialize downsample factor
+        self.downsample_factor = 1
+        
+        """
+        # Create container widget for corner controls
+        corner_widget = QWidget()
+        corner_layout = QHBoxLayout(corner_widget)
+        corner_layout.setContentsMargins(5, 0, 5, 0)
+        
+        # Add downsample control
+        downsample_label = QLabel("Downsample Display:")
+        downsample_label.setStyleSheet("color: black; font-size: 11px;")
+        corner_layout.addWidget(downsample_label)
+        
+        self.downsample_input = QLineEdit("1")
+        self.downsample_input.setFixedWidth(40)
+        self.downsample_input.setFixedHeight(25)
+        self.downsample_input.setStyleSheet("""
+            #QLineEdit {
+                #border: 1px solid gray;
+                #border-radius: 2px;
+                #padding: 1px;
+                #font-size: 11px;
+            #}
+        """)
+        self.downsample_input.textChanged.connect(self.on_downsample_changed)
+        self.downsample_input.editingFinished.connect(self.validate_downsample_input)
+        corner_layout.addWidget(self.downsample_input)
+        
+        # Add some spacing
+        corner_layout.addSpacing(10)
+
+        # Add camera button
+        cam_button = QPushButton("📷")
+        cam_button.setFixedSize(40, 40)
+        cam_button.setStyleSheet("font-size: 24px;")
+        cam_button.clicked.connect(self.snap)
+        corner_layout.addWidget(cam_button)
+        
+        # Set as corner widget
+        menubar.setCornerWidget(corner_widget, Qt.Corner.TopRightCorner)
+        """
         cam_button = QPushButton("📷")
         cam_button.setFixedSize(40, 40)
         cam_button.setStyleSheet("font-size: 24px;")  # Makes emoji larger
         cam_button.clicked.connect(self.snap)
         menubar.setCornerWidget(cam_button, Qt.Corner.TopRightCorner)
 
-    def snap(self):
-
+    def on_downsample_changed(self, text):
+        """Called whenever the text in the downsample input changes"""
         try:
+            if text.strip() == "":
+                self.downsample_factor = 1
+            else:
+                value = float(text)
+                if value <= 0:
+                    self.downsample_factor = 1
+                else:
+                    self.downsample_factor = int(value) if value == int(value) else value
+        except (ValueError, TypeError):
+            self.downsample_factor = 1
+
+    def validate_downsample_input(self, text = None, update = True):
+        """Called when user finishes editing (loses focus or presses Enter)"""
+        if text:
+            self.downsample_factor = text
+        else:
+            try: # If enabled for manual display downsampling
+                text = self.downsample_input.text().strip()
+                if text == "":
+                    # Empty input - set to default
+                    self.downsample_factor = 1
+                    self.downsample_input.setText("1")
+                else:
+                    value = int(text)
+                    if value < 1:
+                        # Invalid value - reset to default
+                        self.downsample_factor = 1
+                        self.downsample_input.setText("1")
+                    else:
+                        # Valid value - use it (prefer int if possible)
+                        if value == int(value):
+                            self.downsample_factor = int(value)
+                            self.downsample_input.setText(str(int(value)))
+                        else:
+                            self.downsample_factor = value
+                            self.downsample_input.setText(f"{value:.1f}")
+            except:
+                # Invalid input - reset to default
+                self.downsample_factor = 1
 
+        self.throttle = self.shape[1] * self.shape[2] > 3000 * 3000 * self.downsample_factor
+        if self.machine_window is not None:
+            if self.throttle: #arbitrary throttle for large arrays.
+                self.machine_window.update_interval = 10
+            else:
+                self.machine_window.update_interval = 1  # Increased to 1s
+        
+        # Optional: Trigger display update if you want immediate effect
+        if update:
+            current_xlim = self.ax.get_xlim() if hasattr(self, 'ax') and self.ax.get_xlim() != (0, 1) else None
+            current_ylim = self.ax.get_ylim() if hasattr(self, 'ax') and self.ax.get_ylim() != (0, 1) else None
+            self.update_display(preserve_zoom=(current_xlim, current_ylim))
+
+    def snap(self):
+        try:
+            # Check if we have any data to save
+            data = False
             for thing in self.channel_data:
                 if thing is not None:
                     data = True
+                    break
             if not data:
                 return
-
-            snap = self.create_composite_for_pan()
-
+            
+            # Get filename from user
             filename, _ = QFileDialog.getSaveFileName(
                 self,
                 f"Save Image As",
-                "",  # Default directory
-                "TIFF Files (*.tif *.tiff);;All Files (*)"  # File type filter
+                "",
+                "PNG Files (*.png);;TIFF Files (*.tif *.tiff);;JPEG Files (*.jpg *.jpeg);;All Files (*)"
             )
             
-            if filename:  # Only proceed if user didn't cancel
-                # If user didn't type an extension, add .tif
-                if not filename.endswith(('.tif', '.tiff')):
-                    filename += '.tif'
+            if filename:
+                # Determine file extension
+                if filename.lower().endswith(('.tif', '.tiff')):
+                    format_type = 'tiff'
+                elif filename.lower().endswith(('.jpg', '.jpeg')):
+                    format_type = 'jpeg'
+                elif filename.lower().endswith('.png'):
+                    format_type = 'png'
+                else:
+                    filename += '.png'
+                    format_type = 'png'
+                
+                if self.downsample_factor > 1:
+                    self.pan_mode = True # Update display will ignore downsamples if this is true so we can just use it here
+                    self.downsample_factor = 1
+                    current_xlim = self.ax.get_xlim() if hasattr(self, 'ax') and self.ax.get_xlim() != (0, 1) else None
+                    current_ylim = self.ax.get_ylim() if hasattr(self, 'ax') and self.ax.get_ylim() != (0, 1) else None
+                    self.update_display(preserve_zoom=(current_xlim, current_ylim))
 
-            import tifffile
-            tifffile.imwrite(filename, snap)
+                # Save with axes bbox
+                bbox = self.ax.get_window_extent().transformed(self.figure.dpi_scale_trans.inverted())
+                self.figure.savefig(filename,
+                                  dpi=300,
+                                  bbox_inches=bbox,
+                                  facecolor='black',
+                                  edgecolor='none',
+                                  format=format_type,
+                                  pad_inches=0)
+                
+                print(f"Axes snapshot saved: {filename}")
 
-        except:
-            pass
+                self.toggle_pan_mode() # Assesses pan state since we messed with its vars potentially
+                
+        except Exception as e:
+            print(f"Error saving snapshot: {e}")
 
 
     def open_cellpose(self):
 
+        try:
+            if self.shape[0] == 1:
+                use_3d = False
+                print("Launching 2D cellpose GUI")
+            else:
+                use_3d = True
+                print("Launching 3D cellpose GUI")
+        except:
+            use_3d = True
+            print("Launching 3D cellpose GUI")
+
         try:
 
             from . import cellpose_manager
             self.cellpose_launcher = cellpose_manager.CellposeGUILauncher(parent_widget=self)
 
-            self.cellpose_launcher.launch_cellpose_gui()
+            self.cellpose_launcher.launch_cellpose_gui(use_3d = use_3d)
 
         except:
+            import traceback
+            print(traceback.format_exc())
             pass
 
 
@@ -3680,106 +3915,26 @@ class ImageViewerWindow(QMainWindow):
             print(f"Error finding stats: {e}")
 
     def histos(self):
-
-        """from networkx documentation"""
-
+        """
+        Show a PyQt6 window with buttons to select which histogram to generate.
+        Only calculates the histogram that the user selects.
+        """
         try:
-
-            G = my_network.network
-
-            shortest_path_lengths = dict(nx.all_pairs_shortest_path_length(G))
-            diameter = max(nx.eccentricity(G, sp=shortest_path_lengths).values())
-            # We know the maximum shortest path length (the diameter), so create an array
-            # to store values from 0 up to (and including) diameter
-            path_lengths = np.zeros(diameter + 1, dtype=int)
-
-
-
-            # Extract the frequency of shortest path lengths between two nodes
-            for pls in shortest_path_lengths.values():
-                pl, cnts = np.unique(list(pls.values()), return_counts=True)
-                path_lengths[pl] += cnts
-
-            # Express frequency distribution as a percentage (ignoring path lengths of 0)
-            freq_percent = 100 * path_lengths[1:] / path_lengths[1:].sum()
-
-            # Plot the frequency distribution (ignoring path lengths of 0) as a percentage
-            fig, ax = plt.subplots(figsize=(15, 8))
-            ax.bar(np.arange(1, diameter + 1), height=freq_percent)
-            ax.set_title(
-                "Distribution of shortest path length in G", fontdict={"size": 35}, loc="center"
-            )
-            ax.set_xlabel("Shortest Path Length", fontdict={"size": 22})
-            ax.set_ylabel("Frequency (%)", fontdict={"size": 22})
-
-            plt.show()
-            freq_dict = {freq: length for length, freq in enumerate(freq_percent, start=1)}
-            self.format_for_upperright_table(freq_dict, metric='Frequency (%)', value='Shortest Path Length', title="Distribution of shortest path length in G")
-
-            degree_centrality = nx.centrality.degree_centrality(G)
-            plt.figure(figsize=(15, 8))
-            plt.hist(degree_centrality.values(), bins=25)
-            plt.xticks(ticks=[0, 0.025, 0.05, 0.1, 0.15, 0.2])  # set the x axis ticks
-            plt.title("Degree Centrality Histogram ", fontdict={"size": 35}, loc="center")
-            plt.xlabel("Degree Centrality", fontdict={"size": 20})
-            plt.ylabel("Counts", fontdict={"size": 20})
-            plt.show()
-            self.format_for_upperright_table(degree_centrality, metric='Node', value='Degree Centrality', title="Degree Centrality Table")
-
-
-            betweenness_centrality = nx.centrality.betweenness_centrality(
-                G
-            )
-            plt.figure(figsize=(15, 8))
-            plt.hist(betweenness_centrality.values(), bins=100)
-            plt.xticks(ticks=[0, 0.02, 0.1, 0.2, 0.3, 0.4, 0.5])  # set the x axis ticks
-            plt.title("Betweenness Centrality Histogram ", fontdict={"size": 35}, loc="center")
-            plt.xlabel("Betweenness Centrality", fontdict={"size": 20})
-            plt.ylabel("Counts", fontdict={"size": 20})
-            plt.show()
-            self.format_for_upperright_table(betweenness_centrality, metric='Node', value='Betweenness Centrality', title="Betweenness Centrality Table")
-
-
-            closeness_centrality = nx.centrality.closeness_centrality(
-                G
-            )
-            plt.figure(figsize=(15, 8))
-            plt.hist(closeness_centrality.values(), bins=60)
-            plt.title("Closeness Centrality Histogram ", fontdict={"size": 35}, loc="center")
-            plt.xlabel("Closeness Centrality", fontdict={"size": 20})
-            plt.ylabel("Counts", fontdict={"size": 20})
-            plt.show()
-            self.format_for_upperright_table(closeness_centrality, metric='Node', value='Closeness Centrality', title="Closeness Centrality Table")
-
-
-            eigenvector_centrality = nx.centrality.eigenvector_centrality(
-                G
-            )
-            plt.figure(figsize=(15, 8))
-            plt.hist(eigenvector_centrality.values(), bins=60)
-            plt.xticks(ticks=[0, 0.01, 0.02, 0.04, 0.06, 0.08])  # set the x axis ticks
-            plt.title("Eigenvector Centrality Histogram ", fontdict={"size": 35}, loc="center")
-            plt.xlabel("Eigenvector Centrality", fontdict={"size": 20})
-            plt.ylabel("Counts", fontdict={"size": 20})
-            plt.show()
-            self.format_for_upperright_table(eigenvector_centrality, metric='Node', value='Eigenvector Centrality', title="Eigenvector Centrality Table")
-
-
-
-            clusters = nx.clustering(G)
-            plt.figure(figsize=(15, 8))
-            plt.hist(clusters.values(), bins=50)
-            plt.title("Clustering Coefficient Histogram ", fontdict={"size": 35}, loc="center")
-            plt.xlabel("Clustering Coefficient", fontdict={"size": 20})
-            plt.ylabel("Counts", fontdict={"size": 20})
-            plt.show()
-            self.format_for_upperright_table(clusters, metric='Node', value='Clustering Coefficient', title="Clustering Coefficient Table")
-
-            bridges = list(nx.bridges(G))
-            self.format_for_upperright_table(bridges, metric = 'Node Pair', title="Bridges")
-
+            # Create QApplication if it doesn't exist
+            app = QApplication.instance()
+            if app is None:
+                app = QApplication(sys.argv)
+            
+            # Create and show the histogram selector window
+            self.histogram_selector = HistogramSelector(self)
+            self.histogram_selector.show()
+            
+            # Keep the window open (you might want to handle this differently based on your application structure)
+            if not app.exec():
+                pass  # Window was closed
+                
         except Exception as e:
-            print(f"Error generating histograms: {e}")
+            print(f"Error creating histogram selector: {e}")
 
     def volumes(self):
 
@@ -4425,7 +4580,7 @@ class ImageViewerWindow(QMainWindow):
 
             if directory != "":
 
-                self.reset(network = True, xy_scale = 1, z_scale = 1, edges = True, network_overlay = True, id_overlay = True)
+                self.reset(network = True, xy_scale = 1, z_scale = 1, edges = True, network_overlay = True, id_overlay = True, update = False)
 
                 my_network.assemble(directory)
 
@@ -4738,6 +4893,7 @@ class ImageViewerWindow(QMainWindow):
         """Load a channel and enable active channel selection if needed."""
 
         try:
+            self.hold_update = True
             if not data:  # For solo loading
                 filename, _ = QFileDialog.getOpenFileName(
                     self,
@@ -4805,9 +4961,13 @@ class ImageViewerWindow(QMainWindow):
             try:
                 if len(self.channel_data[channel_index].shape) == 3:  # potentially 2D RGB
                     if self.channel_data[channel_index].shape[-1] in (3, 4):  # last dim is 3 or 4
-                        if self.confirm_rgb_dialog():
-                            # User confirmed it's 2D RGB, expand to 4D
+                        if not data and self.shape is None:
+                            if self.confirm_rgb_dialog():
+                                # User confirmed it's 2D RGB, expand to 4D
+                                self.channel_data[channel_index] = np.expand_dims(self.channel_data[channel_index], axis=0)
+                        elif self.shape[0] == 1: # this can only be true if the user already loaded in a 2d image
                             self.channel_data[channel_index] = np.expand_dims(self.channel_data[channel_index], axis=0)
+
             except:
                 pass
 
@@ -4914,6 +5074,11 @@ class ImageViewerWindow(QMainWindow):
                 pass
 
             self.shape = self.channel_data[channel_index].shape
+            if self.shape[1] * self.shape[2] > 3000 * 3000 * self.downsample_factor:
+                self.throttle = True
+            else:
+                self.throttle = False
+
 
             self.img_height, self.img_width = self.shape[1], self.shape[2]
             self.original_ylim, self.original_xlim = (self.shape[1] + 0.5, -0.5), (-0.5, self.shape[2] - 0.5)
@@ -4931,7 +5096,6 @@ class ImageViewerWindow(QMainWindow):
 
                 self.update_display(reset_resize = reset_resize, preserve_zoom = preserve_zoom)
 
-
                 
         except Exception as e:
 
@@ -4943,7 +5107,7 @@ class ImageViewerWindow(QMainWindow):
                     f"Failed to load tiff file: {str(e)}"
                 )
 
-    def delete_channel(self, channel_index, called = True):
+    def delete_channel(self, channel_index, called = True, update = True):
         """Delete the specified channel and update the display."""
         if called:
             # Confirm deletion
@@ -4989,11 +5153,13 @@ class ImageViewerWindow(QMainWindow):
                 else:
                     # If no channels are available, disable active channel selector
                     self.active_channel_combo.setEnabled(False)
+                    self.shape = None # Also there is not an active shape anymore
             
-            # Update display
-            self.update_display()
+            if update:
+                # Update display
+                self.update_display()
 
-    def reset(self, nodes = False, network = False, xy_scale = 1, z_scale = 1, edges = False, search_region = False, network_overlay = False, id_overlay = False):
+    def reset(self, nodes = False, network = False, xy_scale = 1, z_scale = 1, edges = False, search_region = False, network_overlay = False, id_overlay = False, update = True):
         """Method to flexibly reset certain fields to free up the RAM as desired"""
         
         # Set scales first before any clearing operations
@@ -5014,10 +5180,10 @@ class ImageViewerWindow(QMainWindow):
             self.selection_table.setModel(PandasModel(empty_df))
 
         if nodes:
-            self.delete_channel(0, False)
+            self.delete_channel(0, False, update = update)
 
         if edges:
-            self.delete_channel(1, False)
+            self.delete_channel(1, False, update = update)
         try:
             if search_region:
                 my_network.search_region = None
@@ -5025,10 +5191,10 @@ class ImageViewerWindow(QMainWindow):
             pass
 
         if network_overlay:
-            self.delete_channel(2, False)
+            self.delete_channel(2, False, update = update)
 
         if id_overlay:
-            self.delete_channel(3, False)
+            self.delete_channel(3, False, update = update)
 
 
 
@@ -5162,7 +5328,10 @@ class ImageViewerWindow(QMainWindow):
             self.current_slice = slice_value
             if self.mini_overlay == True: #If we are rendering the highlight overlay for selected values one at a time.
                 self.create_mini_overlay(node_indices = self.clicked_values['nodes'], edge_indices = self.clicked_values['edges'])
-            self.update_display(preserve_zoom=view_settings)
+            if not self.hold_update:
+                self.update_display(preserve_zoom=view_settings)
+            else:
+                self.hold_update = False
             #if self.machine_window is not None:
                 #self.machine_window.poke_segmenter()
             self.pending_slice = None
@@ -5180,51 +5349,59 @@ class ImageViewerWindow(QMainWindow):
         self.update_display(preserve_zoom = (current_xlim, current_ylim))
 
 
-
-    
-    def update_display(self, preserve_zoom=None, dims = None, called = False, reset_resize = False):
-        """Update the display with currently visible channels and highlight overlay."""
+    def update_display(self, preserve_zoom=None, dims=None, called=False, reset_resize=False, skip=False):
+        """Optimized display update with view-based cropping for performance."""
         try:
-            self.figure.clear()
+            # Initialize reusable components if they don't exist
+            if not hasattr(self, 'channel_images'):
+                self.channel_images = {}
+                self.highlight_image = None
+                self.measurement_artists = []
+                self.axes_initialized = False
+                self.original_dims = None
+            
+            # Handle special states (pan, static background)
             if self.pan_background_image is not None:
-                # Restore previously visible channels
                 self.channel_visible = self.pre_pan_channel_state.copy()
                 self.is_pan_preview = False
                 self.pan_background_image = None
                 if self.resume:
                     self.machine_window.segmentation_worker.resume()
                     self.resume = False
+                if self.prev_down != self.downsample_factor:
+                    self.validate_downsample_input(text = self.prev_down)
+                    return
+           
             if self.static_background is not None:
-                # NEW: Convert virtual strokes to real data before cleanup
+                # Your existing virtual strokes conversion logic
                 if (hasattr(self, 'virtual_draw_operations') and self.virtual_draw_operations) or \
                    (hasattr(self, 'virtual_erase_operations') and self.virtual_erase_operations) or \
                    (hasattr(self, 'current_operation') and self.current_operation):
-                    # Finish current operation first
                     if hasattr(self, 'current_operation') and self.current_operation:
                         self.pm.finish_current_virtual_operation()
-                    # Now convert to real data
                     self.pm.convert_virtual_strokes_to_data()
                 
-                # Restore hidden channels
                 try:
                     for i in self.restore_channels:
                         self.channel_visible[i] = True
                     self.restore_channels = []
                 except:
                     pass
-
                 self.static_background = None
-
+                
+                # Your existing machine_window logic
                 if self.machine_window is None:
                     try:
-                        self.channel_data[4][self.current_slice, :, :] = n3d.overlay_arrays_simple(self.channel_data[self.temp_chan][self.current_slice, :, :], self.channel_data[4][self.current_slice, :, :])
-                        self.load_channel(self.temp_chan, self.channel_data[4], data = True, end_paint = True)
+                        self.channel_data[4][self.current_slice, :, :] = n3d.overlay_arrays_simple(
+                            self.channel_data[self.temp_chan][self.current_slice, :, :], 
+                            self.channel_data[4][self.current_slice, :, :])
+                        self.load_channel(self.temp_chan, self.channel_data[4], data=True, end_paint=True)
                         self.channel_data[4] = None
                         self.channel_visible[4] = False
                     except:
                         pass
 
-            # Get active channels and their dimensions
+            # Get dimensions
             active_channels = [i for i in range(4) if self.channel_data[i] is not None]
             if dims is None:
                 if active_channels:
@@ -5233,230 +5410,258 @@ class ImageViewerWindow(QMainWindow):
                     min_height = min(d[0] for d in dims)
                     min_width = min(d[1] for d in dims)
                 else:
-                    min_height = 1
-                    min_width = 1
+                    min_height = min_width = 1
             else:
-                min_height = dims[0]
-                min_width = dims[1]
-
-            # Set axes limits before displaying any images
+                min_height, min_width = dims[:2]
+            
+            # Store original dimensions for pixel coordinate conversion
+            self.original_dims = (min_height, min_width)
+
+            # Initialize axes only once or when needed
+            if not self.axes_initialized or not hasattr(self, 'ax') or self.ax is None:
+                self.figure.clear()
+                self.figure.patch.set_facecolor('white')
+                self.ax = self.figure.add_subplot(111)
+                self.ax.set_facecolor('black')
+                self.axes_initialized = True
+                
+                # Style the axes once
+                self.ax.set_xlabel('X')
+                self.ax.set_ylabel('Y')
+                self.ax.xaxis.label.set_color('black')
+                self.ax.yaxis.label.set_color('black')
+                self.ax.tick_params(colors='black')
+                for spine in self.ax.spines.values():
+                    spine.set_color('black')
+            else:
+                # Clear only the image data, keep axes structure
+                for img in list(self.ax.get_images()):
+                    img.remove()
+                # Clear measurement points
+                for artist in self.measurement_artists:
+                    artist.remove()
+                self.measurement_artists.clear()
+
+            # Determine the current view bounds (either from preserve_zoom or current state)
+            if preserve_zoom:
+                current_xlim, current_ylim = preserve_zoom
+            else:
+                current_xlim = (-0.5, self.shape[2] - 0.5)
+                current_ylim = (self.shape[1] - 0.5, -0.5)
+            
+            # Calculate the visible region in pixel coordinates
+            x_min = max(0, int(np.floor(current_xlim[0] + 0.5)))
+            x_max = min(min_width, int(np.ceil(current_xlim[1] + 0.5)))
+            y_min = max(0, int(np.floor(current_ylim[1] + 0.5)))  # Note: y is flipped
+            y_max = min(min_height, int(np.ceil(current_ylim[0] + 0.5)))
+
+            if not self.pan_mode: # If using image pyramids
+                size = (x_max - x_min) * (y_max - y_min)
+                if size < (3000 * 3000): # Smaller window
+                    val = 1
+                elif size > (3000 * 3000) and size < (6000 * 6000): # Med window
+                    val = 2
+                elif size > (6000 * 6000) and size < (9000 * 9000): # Large window
+                    val = 3
+                elif size > (9000 * 9000): # Very large window
+                    val = 3
+                self.validate_downsample_input(text = val, update = False)
+            downsample_factor = self.downsample_factor
+
+            # Add some padding to avoid edge artifacts during pan/zoom
+            padding = max(10, downsample_factor * 2)
+            x_min_padded = max(0, x_min - padding)
+            x_max_padded = min(min_width, x_max + padding)
+            y_min_padded = max(0, y_min - padding)
+            y_max_padded = min(min_height, y_max + padding)
+            
+            # Calculate the extent for the cropped region (in original coordinates)
+            crop_extent = (x_min_padded - 0.5, x_max_padded - 0.5, 
+                          y_max_padded - 0.5, y_min_padded - 0.5)
+
+            # Set limits to original dimensions (important for pixel queries)
             self.ax.set_xlim(-0.5, min_width - 0.5)
             self.ax.set_ylim(min_height - 0.5, -0.5)
+            self.ax.set_title(f'Slice {self.current_slice}')
+            self.ax.title.set_color('black')
             
-            # Create subplot with tight layout and white figure background
-            self.figure.patch.set_facecolor('white')
-            self.ax = self.figure.add_subplot(111)
-            
-            # Store current zoom limits if they exist and weren't provided
-     
-            current_xlim, current_ylim = preserve_zoom if preserve_zoom else (None, None)
-            
-            # Define base colors for each channel with increased intensity
             base_colors = self.base_colors
-            # Set only the axes (image area) background to black
-            self.ax.set_facecolor('black')
             
-            # Display each visible channel
+            # Helper function to crop and downsample image
+            def crop_and_downsample_image(image, y_start, y_end, x_start, x_end, factor):
+                # Crop first
+                if len(image.shape) == 2:
+                    cropped = image[y_start:y_end, x_start:x_end]
+                elif len(image.shape) == 3:
+                    cropped = image[y_start:y_end, x_start:x_end, :]
+                else:
+                    cropped = image
+                
+                # Then downsample if needed
+                if factor == 1:
+                    return cropped
+                
+                if len(cropped.shape) == 2:
+                    return cropped[::factor, ::factor]
+                elif len(cropped.shape) == 3:
+                    return cropped[::factor, ::factor, :]
+                else:
+                    return cropped
+            
+            # Update channel images efficiently with cropping and downsampling
             for channel in range(4):
-                if (self.channel_visible[channel] and 
-                    self.channel_data[channel] is not None):
-                    
-                    # Check if we're dealing with RGB data
-                    is_rgb = len(self.channel_data[channel].shape) == 4 and (self.channel_data[channel].shape[-1] == 3 or self.channel_data[channel].shape[-1] == 4)
+                if self.channel_visible[channel] and self.channel_data[channel] is not None:
+                    # Get current image data
+                    is_rgb = len(self.channel_data[channel].shape) == 4 and (
+                        self.channel_data[channel].shape[-1] in [3, 4])
                     
                     if len(self.channel_data[channel].shape) == 3 and not is_rgb:
                         current_image = self.channel_data[channel][self.current_slice, :, :]
                     elif is_rgb:
-                        current_image = self.channel_data[channel][self.current_slice]  # Already has RGB channels
+                        current_image = self.channel_data[channel][self.current_slice]
                     else:
                         current_image = self.channel_data[channel]
 
-                    if is_rgb and self.channel_data[channel].shape[-1] == 3:
-                        # For RGB images, just display directly without colormap
-                        self.ax.imshow(current_image,
-                                     alpha=0.7)
-                    elif is_rgb and self.channel_data[channel].shape[-1] == 4:
-                        self.ax.imshow(current_image) #For images that already have an alpha value and RGB, don't update alpha
-
+                    # Crop and downsample the image for rendering
+                    display_image = crop_and_downsample_image(
+                        current_image, y_min_padded, y_max_padded, 
+                        x_min_padded, x_max_padded, downsample_factor)
+
+                    if is_rgb and self.channel_data[channel].shape[-1] in [3, 4]:
+                        # RGB handling (keep your existing logic)
+                        brightness_min = self.channel_brightness[channel]['min']
+                        brightness_max = self.channel_brightness[channel]['max']
+                        alpha_range = brightness_max - brightness_min
+                        base_alpha = brightness_min
+                        final_alpha = np.clip(base_alpha + alpha_range, 0.0, 1.0)
+                        
+                        if display_image.shape[-1] == 4:
+                            img_with_alpha = display_image.copy()
+                            img_with_alpha[..., 3] = img_with_alpha[..., 3] * final_alpha
+                            # Use crop_extent to place in correct location
+                            im = self.ax.imshow(img_with_alpha, extent=crop_extent)
+                        else:
+                            im = self.ax.imshow(display_image, alpha=final_alpha, extent=crop_extent)
                     else:
-                        # Regular channel processing with colormap
-                        # Calculate brightness/contrast limits from entire volume
-                        if self.min_max[channel][0] == None:
-                            self.min_max[channel][0] = np.min(channel)
-                        if self.min_max[channel][1] == None:
-                            self.min_max[channel][1] = np.max(channel)
-
-                        img_min = self.min_max[channel][0]
-                        img_max = self.min_max[channel][1]
+                        # Regular channel processing with optimized normalization
+                        if self.min_max[channel][0] is None:
+                            # For very large arrays, consider sampling for min/max
+                            if self.channel_data[channel].size > 1000000:
+                                sample = self.channel_data[channel][::max(1, self.channel_data[channel].shape[0]//100)]
+                                self.min_max[channel] = [np.min(sample), np.max(sample)]
+                            else:
+                                self.min_max[channel] = [np.min(self.channel_data[channel]), 
+                                                       np.max(self.channel_data[channel])]
+                        
+                        img_min, img_max = self.min_max[channel]
                         
-                        # Calculate vmin and vmax, ensuring we don't get a zero range
                         if img_min == img_max:
-                            vmin = img_min
-                            vmax = img_min + 1
+                            vmin, vmax = img_min, img_min + 1
+                            normalized_image = np.zeros_like(display_image)
                         else:
                             vmin = img_min + (img_max - img_min) * self.channel_brightness[channel]['min']
                             vmax = img_min + (img_max - img_min) * self.channel_brightness[channel]['max']
-                        
-                        # Normalize the image safely
-                        if vmin == vmax:
-                            normalized_image = np.zeros_like(current_image)
-                        else:
-                            normalized_image = np.clip((current_image - vmin) / (vmax - vmin), 0, 1)
+                            
+                            if vmin == vmax:
+                                normalized_image = np.zeros_like(display_image)
+                            else:
+                                normalized_image = np.clip((display_image - vmin) / (vmax - vmin), 0, 1)
                         
                         if channel == 2 and self.machine_window is not None:
                             custom_cmap = LinearSegmentedColormap.from_list(
                                 f'custom_{channel}',
-                                [(0, 0, 0, 0),          # transparent for 0
-                                 (0.5, 1, 0.5, 1),      # light green for 1
-                                 (1, 0.5, 0.5, 1)]      # light red for 2
+                                [(0, 0, 0, 0), (0.5, 1, 0.5, 1), (1, 0.5, 0.5, 1)]
                             )
-                            self.ax.imshow(current_image,
-                                         cmap=custom_cmap,
-                                         vmin=0,
-                                         vmax=2,
-                                         alpha=0.7,
-                                         interpolation='nearest',
-                                         extent=(-0.5, min_width-0.5, min_height-0.5, -0.5))
+                            im = self.ax.imshow(display_image, cmap=custom_cmap, vmin=0, vmax=2,
+                                              alpha=0.7, interpolation='nearest', extent=crop_extent)
                         else:
-                            # Create custom colormap with higher intensity
                             color = base_colors[channel]
                             custom_cmap = LinearSegmentedColormap.from_list(
-                                f'custom_{channel}',
-                                [(0,0,0,0), (*color,1)]
-                            )
+                                f'custom_{channel}', [(0,0,0,0), (*color,1)])
                             
-                            # Display the image with slightly higher alpha
-                            self.ax.imshow(normalized_image,
-                                         alpha=0.7,
-                                         cmap=custom_cmap,
-                                         vmin=0,
-                                         vmax=1,
-                                         extent=(-0.5, min_width-0.5, min_height-0.5, -0.5))
+                            im = self.ax.imshow(normalized_image, alpha=0.7, cmap=custom_cmap,
+                                              vmin=0, vmax=1, extent=crop_extent)
 
+            # Handle preview, overlays, and measurements (apply cropping here too)
             if self.preview and not called:
-                self.create_highlight_overlay_slice(self.targs, bounds = self.bounds)
+                self.create_highlight_overlay_slice(self.targs, bounds=self.bounds)
 
-            # Add highlight overlay if it exists
+            # Overlay handling (optimized with cropping and downsampling)
             if self.mini_overlay and self.highlight and self.machine_window is None:
-                highlight_cmap = LinearSegmentedColormap.from_list(
-                    'highlight',
-                    [(0, 0, 0, 0), (1, 1, 0, 1)]  # yellow
-                )
-                self.ax.imshow(self.mini_overlay_data,
-                             cmap=highlight_cmap,
-                             alpha=0.5)
-            elif self.highlight_overlay is not None and self.highlight and self.machine_window is None:
-                highlight_slice = self.highlight_overlay[self.current_slice]
-                highlight_cmap = LinearSegmentedColormap.from_list(
-                    'highlight',
-                    [(0, 0, 0, 0), (1, 1, 0, 1)]  # yellow
-                )
-                self.ax.imshow(highlight_slice,
-                             cmap=highlight_cmap,
-                             alpha=0.5)
+                highlight_cmap = LinearSegmentedColormap.from_list('highlight', [(0, 0, 0, 0), (1, 1, 0, 1)])
+                display_overlay = crop_and_downsample_image(
+                    self.mini_overlay_data, y_min_padded, y_max_padded, 
+                    x_min_padded, x_max_padded, downsample_factor)
+                self.ax.imshow(display_overlay, cmap=highlight_cmap, alpha=0.8, extent=crop_extent)
             elif self.highlight_overlay is not None and self.highlight:
                 highlight_slice = self.highlight_overlay[self.current_slice]
-                highlight_cmap = LinearSegmentedColormap.from_list(
-                    'highlight',
-                    [(0, 0, 0, 0),          # transparent for 0
-                     (1, 1, 0, 1),          # bright yellow for 1
-                     (0, 0.7, 1, 1)]        # cool blue for 2
-                )
-                self.ax.imshow(highlight_slice,
-                             cmap=highlight_cmap,
-                             vmin=0,
-                             vmax=2,         # Important: set vmax to 2 to accommodate both values
-                             alpha=0.5)
-
-            if self.channel_data[4] is not None:
-
-                highlight_slice = self.channel_data[4][self.current_slice]
-                img_min = self.min_max[4][0]
-                img_max = self.min_max[4][1]
-                
-                # Calculate vmin and vmax, ensuring we don't get a zero range
-                if img_min == img_max:
-                    vmin = img_min
-                    vmax = img_min + 1
-                else:
-                    vmin = img_min + (img_max - img_min) * self.channel_brightness[4]['min']
-                    vmax = img_min + (img_max - img_min) * self.channel_brightness[4]['max']
-                
-                # Normalize the image safely
-                if vmin == vmax:
-                    normalized_image = np.zeros_like(highlight_slice)
+                display_highlight = crop_and_downsample_image(
+                    highlight_slice, y_min_padded, y_max_padded, 
+                    x_min_padded, x_max_padded, downsample_factor)
+                if self.machine_window is None:
+                    highlight_cmap = LinearSegmentedColormap.from_list('highlight', [(0, 0, 0, 0), (1, 1, 0, 1)])
+                    self.ax.imshow(display_highlight, cmap=highlight_cmap, alpha=0.8, extent=crop_extent)
                 else:
-                    normalized_image = np.clip((highlight_slice - vmin) / (vmax - vmin), 0, 1)
+                    highlight_cmap = LinearSegmentedColormap.from_list('highlight', 
+                        [(0, 0, 0, 0), (1, 1, 0, 1), (0, 0.7, 1, 1)])
+                    self.ax.imshow(display_highlight, cmap=highlight_cmap, vmin=0, vmax=2, alpha=0.3, extent=crop_extent)
 
-                color = base_colors[self.temp_chan]
-                custom_cmap = LinearSegmentedColormap.from_list(
-                    f'custom_{4}',
-                    [(0,0,0,0), (*color,1)]
-                )
-                
-
-                self.ax.imshow(normalized_image,
-                             alpha=0.7,
-                             cmap=custom_cmap,
-                             vmin=0,
-                             vmax=1)
-
-            # Style the axes
-            self.ax.set_xlabel('X')
-            self.ax.set_ylabel('Y')
-            self.ax.set_title(f'Slice {self.current_slice}')
-
-            # Make axis labels and ticks black for visibility against white background
-            self.ax.xaxis.label.set_color('black')
-            self.ax.yaxis.label.set_color('black')
-            self.ax.title.set_color('black')
-            self.ax.tick_params(colors='black')
-            for spine in self.ax.spines.values():
-                spine.set_color('black')
-
-            # Adjust the layout to ensure the plot fits well in the figure
-            self.figure.tight_layout()
-
-            # Redraw measurement points and their labels
+            # Redraw measurement points efficiently (no cropping needed - these are vector graphics)
+            # Only draw points that are within the visible region for additional performance
             for point in self.measurement_points:
                 x1, y1, z1 = point['point1']
                 x2, y2, z2 = point['point2']
                 pair_idx = point['pair_index']
                 
-                # Draw points and labels if they're on current slice
-                if z1 == self.current_slice:
-                    self.ax.plot(x1, y1, 'yo', markersize=8)
-                    self.ax.text(x1, y1+5, str(pair_idx), 
-                                color='white', ha='center', va='bottom')
-                if z2 == self.current_slice:
-                    self.ax.plot(x2, y2, 'yo', markersize=8)
-                    self.ax.text(x2, y2+5, str(pair_idx), 
-                                color='white', ha='center', va='bottom')
+                # Check if points are in visible region
+                point1_visible = (z1 == self.current_slice and 
+                                current_xlim[0] <= x1 <= current_xlim[1] and 
+                                current_ylim[1] <= y1 <= current_ylim[0])
+                point2_visible = (z2 == self.current_slice and 
+                                current_xlim[0] <= x2 <= current_xlim[1] and 
+                                current_ylim[1] <= y2 <= current_ylim[0])
+                
+                if point1_visible:
+                    pt1 = self.ax.plot(x1, y1, 'yo', markersize=8)[0]
+                    txt1 = self.ax.text(x1, y1+5, str(pair_idx), color='white', ha='center', va='bottom')
+                    self.measurement_artists.extend([pt1, txt1])
                     
-                # Draw line if both points are on current slice
-                if z1 == z2 == self.current_slice:
-                    self.ax.plot([x1, x2], [y1, y2], 'r--', alpha=0.5)
-        
-            if active_channels:
-                self.ax.set_xlim(-0.5, min_width - 0.5)
-                self.ax.set_ylim(min_height - 0.5, -0.5)
+                if point2_visible:
+                    pt2 = self.ax.plot(x2, y2, 'yo', markersize=8)[0]
+                    txt2 = self.ax.text(x2, y2+5, str(pair_idx), color='white', ha='center', va='bottom')
+                    self.measurement_artists.extend([pt2, txt2])
+                    
+                if z1 == z2 == self.current_slice and (point1_visible or point2_visible):
+                    line = self.ax.plot([x1, x2], [y1, y2], 'r--', alpha=0.5)[0]
+                    self.measurement_artists.append(line)
 
+            # Store current view limits for next update
+            self.ax._current_xlim = current_xlim
+            self.ax._current_ylim = current_ylim
+
+            # Handle resizing
             if self.resizing:
                 self.original_xlim = self.ax.get_xlim()
                 self.original_ylim = self.ax.get_ylim()
-            # Restore zoom limits if they existed
+                
+            # Restore zoom (this sets the final view, not the data extent)
             if current_xlim is not None and current_ylim is not None:
                 self.ax.set_xlim(current_xlim)
                 self.ax.set_ylim(current_ylim)
+                
             if reset_resize:
                 self.resizing = False
             
-            self.canvas.draw()
+            # Use draw_idle for better performance
+            self.canvas.draw_idle()
+
+        except Exception as e:
+            pass
+            #import traceback
+            #print(traceback.format_exc())
+
 
 
-        except:
-            import traceback
-            print(traceback.format_exc())
 
     def get_channel_image(self, channel):
         """Find the matplotlib image object for a specific channel."""
@@ -5488,7 +5693,10 @@ class ImageViewerWindow(QMainWindow):
             stats['num_nodes'] = my_network.network.number_of_nodes()
             stats['num_edges'] = my_network.network.number_of_edges()
         except:
-            pass
+            try:
+                stats['num_nodes'] = len(np.unique(my_network.nodes)) - 1
+            except:
+                pass
 
         try:
             idens = invert_dict(my_network.node_identities)
@@ -5534,10 +5742,6 @@ class ImageViewerWindow(QMainWindow):
         dialog = RadialDialog(self)
         dialog.exec()
 
-    def show_degree_dist_dialog(self):
-        dialog = DegreeDistDialog(self)
-        dialog.exec()
-
     def show_neighbor_id_dialog(self):
         dialog = NeighborIdentityDialog(self)
         dialog.exec()
@@ -7122,6 +7326,15 @@ class ColorOverlayDialog(QDialog):
 
         layout = QFormLayout(self)
 
+        # Add mode selection dropdown
+        self.mode_selector = QComboBox()
+        self.mode_selector.addItems(["Nodes", "Edges"])
+        if self.parent().active_channel == 0 and self.parent().channel_data[0] is not None:
+            self.mode_selector.setCurrentIndex(0)  # Default to Mode 1
+        else:
+            self.mode_selector.setCurrentIndex(1)  # Default to Mode 1
+        layout.addRow("Execution Mode:", self.mode_selector)
+
         self.down_factor = QLineEdit("")
         layout.addRow("down_factor (for speeding up overlay generation - optional):", self.down_factor)
 
@@ -7136,11 +7349,10 @@ class ColorOverlayDialog(QDialog):
 
             down_factor = float(self.down_factor.text()) if self.down_factor.text().strip() else None
 
-            if self.parent().active_channel == 0:
-                mode = 0
+            mode = self.mode_selector.currentIndex()
+            if mode == 0:
                 self.sort = 'Node'
             else:
-                mode = 1
                 self.sort = 'Edge'
 
 
@@ -7410,11 +7622,10 @@ class ComIdDialog(QDialog):
         self.umap.setChecked(True)
         layout.addRow("Generate UMAP?:", self.umap)
 
-        # weighted checkbox (default True)
-        self.label = QPushButton("Label")
-        self.label.setCheckable(True)
-        self.label.setChecked(False)
-        layout.addRow("If using above - label UMAP points?:", self.label)
+        self.label = QComboBox()
+        self.label.addItems(["No Label", "By Community", "By Neighborhood (If already calculated via 'Analyze -> Network -> Convert Network Communities...')"])
+        self.label.setCurrentIndex(0)
+        layout.addRow("Label UMAP Points How?:", self.label)
 
         self.limit = QLineEdit("")
         layout.addRow("Min Community Size for UMAP (Smaller communities will be ignored in graph, does not apply if empty)", self.limit)
@@ -7434,6 +7645,12 @@ class ComIdDialog(QDialog):
 
         try:
 
+            if self.parent().prev_coms is not None:
+                temp = my_network.communities
+                my_network.communities = self.parent().prev_coms
+            else:
+                temp = None
+
             if my_network.node_identities is None:
                 print("Node identities must be set")
 
@@ -7446,7 +7663,9 @@ class ComIdDialog(QDialog):
             mode = self.mode.currentIndex()
 
             umap = self.umap.isChecked()
-            label = self.label.isChecked()
+
+            label = self.label.currentIndex()
+
             proportional = self.proportional.isChecked()
             limit = int(self.limit.text()) if self.limit.text().strip() else 0
 
@@ -7459,10 +7678,13 @@ class ComIdDialog(QDialog):
 
             else:
 
-                info, names = my_network.community_id_info_per_com(umap = umap, label = label, limit = limit, proportional = proportional)
+                info, names = my_network.community_id_info_per_com(umap = umap, label = label, limit = limit, proportional = proportional, neighbors = temp)
 
                 self.parent().format_for_upperright_table(info, 'Community', names, 'Average of Community Makeup')
 
+            if self.parent().prev_coms is not None:
+                my_network.communities = temp
+
             self.accept()
 
         except Exception as e:
@@ -7658,39 +7880,6 @@ class RadialDialog(QDialog):
         except Exception as e:
             print(f"An error occurred: {e}")
 
-class DegreeDistDialog(QDialog):
-
-    def __init__(self, parent=None):
-
-        super().__init__(parent)
-        self.setWindowTitle("Degree Distribution Parameters")
-        self.setModal(True)
-
-        layout = QFormLayout(self)
-
-        self.directory = QLineEdit("")
-        layout.addRow("Output Directory:", self.directory)
-
-        # Add Run button
-        run_button = QPushButton("Get Degree Distribution")
-        run_button.clicked.connect(self.degreedist)
-        layout.addWidget(run_button)
-
-    def degreedist(self):
-
-        try:
-
-            directory = str(self.distance.text()) if self.directory.text().strip() else None
-
-            degrees = my_network.degree_distribution(directory = directory)
-
-
-            self.parent().format_for_upperright_table(degrees, 'Degree (k)', 'Proportion of nodes with degree (p(k))', title = 'Degree Distribution Analysis')
-
-            self.accept()
-
-        except Exception as e:
-            print(f"An error occurred: {e}")
 
 class NearNeighDialog(QDialog):
     def __init__(self, parent=None):
@@ -7725,9 +7914,12 @@ class NearNeighDialog(QDialog):
         self.num = QLineEdit("1")
         identities_layout.addRow("Number of Nearest Neighbors to Evaluate Per Node?:", self.num)
 
-        
-        main_layout.addWidget(identities_group)
+        self.centroids = QPushButton("Centroids")
+        self.centroids.setCheckable(True)
+        self.centroids.setChecked(True)
+        identities_layout.addRow("Use Centroids? (Recommended for spheroids) Deselecting finds true nearest neighbors for mask but will be slower, and will only support a single nearest neighbor calculation for each root (rather than an avg)", self.centroids)
 
+        main_layout.addWidget(identities_group)
         
         # Optional Heatmap group box
         heatmap_group = QGroupBox("Optional Heatmap")
@@ -7761,39 +7953,71 @@ class NearNeighDialog(QDialog):
 
         main_layout.addWidget(quant_group)
         
-        # Get Distribution group box
+        # Get Distribution group box - ENHANCED STYLING
         distribution_group = QGroupBox("Get Distribution")
         distribution_layout = QVBoxLayout(distribution_group)
         
-        run_button = QPushButton("Get Average Nearest Neighbor (Plus Distribution)")
+        run_button = QPushButton("🔍 Get Average Nearest Neighbor (Plus Distribution)")
+        # Style for primary action - blue with larger font
+        run_button.setStyleSheet("""
+            QPushButton {
+                background-color: #2196F3;
+                color: white;
+                border: none;
+                padding: 12px 20px;
+                font-size: 14px;
+                font-weight: bold;
+                border-radius: 6px;
+            }
+            QPushButton:hover {
+                background-color: #1976D2;
+            }
+            QPushButton:pressed {
+                background-color: #0D47A1;
+            }
+        """)
         run_button.clicked.connect(self.run)
         distribution_layout.addWidget(run_button)
         
         main_layout.addWidget(distribution_group)
         
-        # Get All Averages group box (only if node_identities exists)
+        # Get All Averages group box - ENHANCED STYLING (only if node_identities exists)
         if my_network.node_identities is not None:
             averages_group = QGroupBox("Get All Averages")
             averages_layout = QVBoxLayout(averages_group)
             
-            run_button2 = QPushButton("Get Average Nearest All ID Combinations (No Distribution, No Heatmap)")
+            run_button2 = QPushButton("📊 Get Average Nearest All ID Combinations (No Distribution, No Heatmap)")
+            # Style for secondary action - green with different styling
+            run_button2.setStyleSheet("""
+                QPushButton {
+                    background-color: #4CAF50;
+                    color: white;
+                    border: 2px solid #45a049;
+                    padding: 10px 16px;
+                    font-size: 13px;
+                    font-weight: normal;
+                    border-radius: 8px;
+                }
+                QPushButton:hover {
+                    background-color: #45a049;
+                    border-color: #3d8b40;
+                }
+                QPushButton:pressed {
+                    background-color: #3d8b40;
+                }
+            """)
             run_button2.clicked.connect(self.run2)
             averages_layout.addWidget(run_button2)
             
             main_layout.addWidget(averages_group)
 
     def toggle_map(self):
-
         if self.numpy.isChecked():
-
             if not self.map.isChecked():
-
                 self.map.click()
 
     def run(self):
-
         try:
-
             try:
                 root = self.root.currentText()
             except:
@@ -7808,31 +8032,43 @@ class NearNeighDialog(QDialog):
             numpy = self.numpy.isChecked()
             num = int(self.num.text()) if self.num.text().strip() else 1
             quant = self.quant.isChecked()
+            centroids = self.centroids.isChecked()
+            if not centroids:
+                num = 1
 
             if root is not None and targ is not None:
                 title = f"Nearest {num} Neighbor(s) Distance of {targ} from {root}"
                 header = f"Shortest Distance to Closest {num} {targ}(s)"
                 header2 = f"{root} Node ID"
+                header3 = f'Theoretical Uniform Distance to Closest {num} {targ}(s)'
             else:
                 title = f"Nearest {num} Neighbor(s) Distance Between Nodes"
                 header = f"Shortest Distance to Closest {num} Nodes"
                 header2 = "Root Node ID"
+                header3 = f'Simulated Theoretical Uniform Distance to Closest {num} Nodes'
 
-            if my_network.node_centroids is None:
+            if centroids and my_network.node_centroids is None:
                 self.parent().show_centroid_dialog()
                 if my_network.node_centroids is None:
                     return
 
             if not numpy:
-                avg, output, quant_overlay = my_network.nearest_neighbors_avg(root, targ, my_network.xy_scale, my_network.z_scale, num = num, heatmap = heatmap, threed = threed, quant = quant)
+                avg, output, quant_overlay, pred = my_network.nearest_neighbors_avg(root, targ, my_network.xy_scale, my_network.z_scale, num = num, heatmap = heatmap, threed = threed, quant = quant, centroids = centroids)
             else:
-                avg, output, overlay, quant_overlay = my_network.nearest_neighbors_avg(root, targ, my_network.xy_scale, my_network.z_scale, num = num, heatmap = heatmap, threed = threed, numpy = True, quant = quant)
+                avg, output, overlay, quant_overlay, pred = my_network.nearest_neighbors_avg(root, targ, my_network.xy_scale, my_network.z_scale, num = num, heatmap = heatmap, threed = threed, numpy = True, quant = quant, centroids = centroids)
                 self.parent().load_channel(3, overlay, data = True)
 
             if quant_overlay is not None:
                 self.parent().load_channel(2, quant_overlay, data = True)
+
+            avg = {header:avg}
+
+            if pred is not None:
+
+                avg[header3] = pred
+
             
-            self.parent().format_for_upperright_table([avg], metric = f'Avg {title}', title = f'Avg {title}')
+            self.parent().format_for_upperright_table(avg, 'Category', 'Value', title = f'Avg {title}')
             self.parent().format_for_upperright_table(output, header2, header, title = title)
 
             self.accept()
@@ -7840,27 +8076,24 @@ class NearNeighDialog(QDialog):
         except Exception as e:
             import traceback
             print(traceback.format_exc())
-
             print(f"Error: {e}")
 
     def run2(self):
-
         try:
-
             available = list(set(my_network.node_identities.values()))
-
             num = int(self.num.text()) if self.num.text().strip() else 1
 
+            centroids = self.centroids.isChecked()
+            if not centroids:
+                num = 1
+
             output_dict = {}
 
             while len(available) > 1:
-
                 root = available[0]
 
                 for targ in available:
-
-                    avg, _, _ = my_network.nearest_neighbors_avg(root, targ, my_network.xy_scale, my_network.z_scale, num = num)
-
+                    avg, _, _, _ = my_network.nearest_neighbors_avg(root, targ, my_network.xy_scale, my_network.z_scale, num = num, centroids = centroids)
                     output_dict[f"{root} vs {targ}"] = avg
 
                 del available[0]
@@ -7870,7 +8103,6 @@ class NearNeighDialog(QDialog):
             self.accept()
 
         except Exception as e:
-
             print(f"Error: {e}")
 
 
@@ -8773,15 +9005,6 @@ class ResizeDialog(QDialog):
             undo_button.clicked.connect(lambda: self.run_resize(undo = True))
             layout.addRow(undo_button)
 
-        if my_network.xy_scale != my_network.z_scale:
-            norm_button_upsize = QPushButton(f"Normalize Scaling with Upsample")
-            norm_button_upsize.clicked.connect(lambda: self.run_resize(upsize = True, special = True))
-            layout.addRow(norm_button_upsize)
-
-            norm_button_downsize = QPushButton("Normalize Scaling with Downsample")
-            norm_button_downsize.clicked.connect(lambda: self.run_resize(upsize = False, special = True))
-            layout.addRow(norm_button_downsize)
-
         run_button = QPushButton("Run Resize")
         run_button.clicked.connect(self.run_resize)
         layout.addRow(run_button)
@@ -8795,7 +9018,7 @@ class ResizeDialog(QDialog):
 
     def run_resize(self, undo = False, upsize = True, special = False):
         try:
-            self.parent().resizing = True
+            self.parent().resizing = False
             # Get parameters
             try:
                 resize = float(self.resize.text()) if self.resize.text() else None
@@ -8809,6 +9032,12 @@ class ResizeDialog(QDialog):
             
             resize = resize if resize is not None else (zsize, ysize, xsize)
 
+            if (self.parent().shape[1] * resize) < 1 or (self.parent().shape[2] * resize) < 1:
+                print("Incompatible x/y dimensions")
+                return
+            elif (self.parent().shape[0] * resize) < 1:
+                resize = (1, resize, resize)
+
             if special:
                 if upsize:
                     if (my_network.z_scale > my_network.xy_scale):
@@ -8850,11 +9079,7 @@ class ResizeDialog(QDialog):
                 new_shape = tuple(int(dim * resize) for dim in array_shape)
             else:
                 new_shape = tuple(int(dim * factor) for dim, factor in zip(array_shape, resize))
-                
-            #if any(dim < 1 for dim in new_shape):
-                #QMessageBox.critical(self, "Error", f"Resize would result in invalid dimensions: {new_shape}")
-                #self.reset_fields()
-                #return
+
 
             cubic = self.cubic.isChecked()
             order = 3 if cubic else 0
@@ -8868,7 +9093,7 @@ class ResizeDialog(QDialog):
                 for channel in range(4):
                     if self.parent().channel_data[channel] is not None:
                         resized_data = n3d.resize(self.parent().channel_data[channel], resize, order)
-                        self.parent().load_channel(channel, channel_data=resized_data, data=True, assign_shape = False)
+                        self.parent().load_channel(channel, channel_data=resized_data, data=True)
 
 
                 
@@ -8889,7 +9114,7 @@ class ResizeDialog(QDialog):
                 for channel in range(4):
                     if self.parent().channel_data[channel] is not None:
                         resized_data = n3d.upsample_with_padding(self.parent().channel_data[channel], original_shape = self.parent().original_shape)
-                        self.parent().load_channel(channel, channel_data=resized_data, data=True, assign_shape = False)
+                        self.parent().load_channel(channel, channel_data=resized_data, data=True)
 
                 if self.parent().mini_overlay_data is not None:
 
@@ -10203,7 +10428,7 @@ class SegmentationWorker(QThread):
         self.mem_lock = mem_lock
         self._stop = False
         self._paused = False  # Add pause flag
-        if self.machine_window.parent().shape[1] * self.machine_window.parent().shape[2] > 3000 * 3000: #arbitrary throttle for large arrays.
+        if self.machine_window.parent().shape[1] * self.machine_window.parent().shape[2] > 3000 * 3000 * self.machine_window.parent().downsample_factor: #arbitrary throttle for large arrays.
             self.update_interval = 10
         else:
             self.update_interval = 1  # Increased to 1s
@@ -10249,11 +10474,14 @@ class SegmentationWorker(QThread):
                 if self._stop:
                     break
                 
-                for z,y,x in foreground_coords:
-                    self.overlay[z,y,x] = 1
-                for z,y,x in background_coords:
-                    self.overlay[z,y,x] = 2
-                
+                if foreground_coords:
+                    fg_array = np.array(list(foreground_coords))
+                    self.overlay[fg_array[:, 0], fg_array[:, 1], fg_array[:, 2]] = 1
+
+                if background_coords:
+                    bg_array = np.array(list(background_coords))
+                    self.overlay[bg_array[:, 0], bg_array[:, 1], bg_array[:, 2]] = 2
+
                 self.chunks_since_update += 1
                 current_time = time.time()
                 if (self.chunks_since_update >= self.chunks_per_update and 
@@ -10264,34 +10492,20 @@ class SegmentationWorker(QThread):
                     self.chunks_since_update = 0
                     self.last_update = current_time 
             
+            current_xlim = self.machine_window.parent().ax.get_xlim()
+
+            current_ylim = self.machine_window.parent().ax.get_ylim()
+
+            self.machine_window.parent().update_display(preserve_zoom=(current_xlim, current_ylim))
+
             self.finished.emit()
+
             
         except Exception as e:
             print(f"Error in segmentation: {e}")
             import traceback
             traceback.print_exc()
 
-    def run_batch(self):
-        try:
-            foreground_coords, _ = self.segmenter.segment_volume()
-            
-            # Modify the array directly
-            self.overlay.fill(False)
-            for z,y,x in foreground_coords:
-                # Check for pause/stop during batch processing too
-                self._check_pause()
-                if self._stop:
-                    break
-                self.overlay[z,y,x] = True
-                
-            self.finished.emit()
-            
-        except Exception as e:
-            print(f"Error in segmentation: {e}")
-            raise
-            
-
-
 
 class ThresholdWindow(QMainWindow):
     def __init__(self, parent=None, accepted_mode=0):
@@ -11331,7 +11545,7 @@ class SkeletonizeDialog(QDialog):
             )
 
             if remove > 0:
-                result = n3d.remove_branches(result, remove)
+                result = n3d.remove_branches_new(result, remove)
 
 
             # Update both the display data and the network object
@@ -13128,6 +13342,409 @@ class ProxDialog(QDialog):
             print(traceback.format_exc())
 
 
+class HistogramSelector(QWidget):
+    def __init__(self, network_analysis_instance):
+        super().__init__()
+        self.network_analysis = network_analysis_instance
+        self.G = my_network.network 
+        self.init_ui()
+        
+    def init_ui(self):
+        self.setWindowTitle('Network Analysis - Histogram Selector')
+        self.setGeometry(300, 300, 400, 700)  # Increased height for more buttons
+        
+        layout = QVBoxLayout()
+        
+        # Title label
+        title_label = QLabel('Select Histogram to Generate:')
+        title_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        title_label.setStyleSheet("font-size: 16px; font-weight: bold; margin: 10px;")
+        layout.addWidget(title_label)
+        
+        # Create buttons for each histogram type
+        self.create_button(layout, "Shortest Path Length Distribution", self.shortest_path_histogram)
+        self.create_button(layout, "Degree Centrality", self.degree_centrality_histogram)
+        self.create_button(layout, "Betweenness Centrality", self.betweenness_centrality_histogram)
+        self.create_button(layout, "Closeness Centrality", self.closeness_centrality_histogram)
+        self.create_button(layout, "Eigenvector Centrality", self.eigenvector_centrality_histogram)
+        self.create_button(layout, "Clustering Coefficient", self.clustering_coefficient_histogram)
+        self.create_button(layout, "Degree Distribution", self.degree_distribution_histogram)
+        self.create_button(layout, "Node Connectivity", self.node_connectivity_histogram)
+        self.create_button(layout, "Eccentricity", self.eccentricity_histogram)
+        self.create_button(layout, "K-Core Decomposition", self.kcore_histogram)
+        self.create_button(layout, "Triangle Count", self.triangle_count_histogram)
+        self.create_button(layout, "Load Centrality", self.load_centrality_histogram)
+        self.create_button(layout, "Communicability Betweenness Centrality", self.communicability_centrality_histogram)
+        self.create_button(layout, "Harmonic Centrality", self.harmonic_centrality_histogram)
+        self.create_button(layout, "Current Flow Betweenness", self.current_flow_betweenness_histogram)
+        self.create_button(layout, "Dispersion", self.dispersion_histogram)
+        self.create_button(layout, "Network Bridges", self.bridges_analysis)
+        
+        # Close button
+        close_button = QPushButton('Close')
+        close_button.clicked.connect(self.close)
+        close_button.setStyleSheet("QPushButton { background-color: #f44336; color: white; font-weight: bold; }")
+        layout.addWidget(close_button)
+        
+        self.setLayout(layout)
+
+    def create_button(self, layout, text, callback):
+        button = QPushButton(text)
+        button.clicked.connect(callback)
+        button.setMinimumHeight(40)
+        button.setStyleSheet("""
+            QPushButton {
+                background-color: #4CAF50;
+                color: white;
+                border: none;
+                padding: 10px;
+                font-size: 14px;
+                font-weight: bold;
+                border-radius: 5px;
+            }
+            QPushButton:hover {
+                background-color: #45a049;
+            }
+            QPushButton:pressed {
+                background-color: #3d8b40;
+            }
+        """)
+        layout.addWidget(button)
+
+    def shortest_path_histogram(self):
+        try:
+            shortest_path_lengths = dict(nx.all_pairs_shortest_path_length(self.G))
+            diameter = max(nx.eccentricity(self.G, sp=shortest_path_lengths).values())
+            path_lengths = np.zeros(diameter + 1, dtype=int)
+
+            for pls in shortest_path_lengths.values():
+                pl, cnts = np.unique(list(pls.values()), return_counts=True)
+                path_lengths[pl] += cnts
+
+            freq_percent = 100 * path_lengths[1:] / path_lengths[1:].sum()
+
+            fig, ax = plt.subplots(figsize=(15, 8))
+            ax.bar(np.arange(1, diameter + 1), height=freq_percent)
+            ax.set_title(
+                "Distribution of shortest path length in G", fontdict={"size": 35}, loc="center"
+            )
+            ax.set_xlabel("Shortest Path Length", fontdict={"size": 22})
+            ax.set_ylabel("Frequency (%)", fontdict={"size": 22})
+            plt.show()
+            
+            freq_dict = {freq: length for length, freq in enumerate(freq_percent, start=1)}
+            self.network_analysis.format_for_upperright_table(freq_dict, metric='Frequency (%)', 
+                                                            value='Shortest Path Length', 
+                                                            title="Distribution of shortest path length in G")
+        except Exception as e:
+            print(f"Error generating shortest path histogram: {e}")
+    
+    def degree_centrality_histogram(self):
+        try:
+            degree_centrality = nx.centrality.degree_centrality(self.G)
+            plt.figure(figsize=(15, 8))
+            plt.hist(degree_centrality.values(), bins=25)
+            plt.xticks(ticks=[0, 0.025, 0.05, 0.1, 0.15, 0.2])
+            plt.title("Degree Centrality Histogram ", fontdict={"size": 35}, loc="center")
+            plt.xlabel("Degree Centrality", fontdict={"size": 20})
+            plt.ylabel("Counts", fontdict={"size": 20})
+            plt.show()
+            self.network_analysis.format_for_upperright_table(degree_centrality, metric='Node', 
+                                                            value='Degree Centrality', 
+                                                            title="Degree Centrality Table")
+        except Exception as e:
+            print(f"Error generating degree centrality histogram: {e}")
+    
+    def betweenness_centrality_histogram(self):
+        try:
+            betweenness_centrality = nx.centrality.betweenness_centrality(self.G)
+            plt.figure(figsize=(15, 8))
+            plt.hist(betweenness_centrality.values(), bins=100)
+            plt.xticks(ticks=[0, 0.02, 0.1, 0.2, 0.3, 0.4, 0.5])
+            plt.title("Betweenness Centrality Histogram ", fontdict={"size": 35}, loc="center")
+            plt.xlabel("Betweenness Centrality", fontdict={"size": 20})
+            plt.ylabel("Counts", fontdict={"size": 20})
+            plt.show()
+            self.network_analysis.format_for_upperright_table(betweenness_centrality, metric='Node', 
+                                                            value='Betweenness Centrality', 
+                                                            title="Betweenness Centrality Table")
+        except Exception as e:
+            print(f"Error generating betweenness centrality histogram: {e}")
+    
+    def closeness_centrality_histogram(self):
+        try:
+            closeness_centrality = nx.centrality.closeness_centrality(self.G)
+            plt.figure(figsize=(15, 8))
+            plt.hist(closeness_centrality.values(), bins=60)
+            plt.title("Closeness Centrality Histogram ", fontdict={"size": 35}, loc="center")
+            plt.xlabel("Closeness Centrality", fontdict={"size": 20})
+            plt.ylabel("Counts", fontdict={"size": 20})
+            plt.show()
+            self.network_analysis.format_for_upperright_table(closeness_centrality, metric='Node', 
+                                                            value='Closeness Centrality', 
+                                                            title="Closeness Centrality Table")
+        except Exception as e:
+            print(f"Error generating closeness centrality histogram: {e}")
+    
+    def eigenvector_centrality_histogram(self):
+        try:
+            eigenvector_centrality = nx.centrality.eigenvector_centrality(self.G)
+            plt.figure(figsize=(15, 8))
+            plt.hist(eigenvector_centrality.values(), bins=60)
+            plt.xticks(ticks=[0, 0.01, 0.02, 0.04, 0.06, 0.08])
+            plt.title("Eigenvector Centrality Histogram ", fontdict={"size": 35}, loc="center")
+            plt.xlabel("Eigenvector Centrality", fontdict={"size": 20})
+            plt.ylabel("Counts", fontdict={"size": 20})
+            plt.show()
+            self.network_analysis.format_for_upperright_table(eigenvector_centrality, metric='Node', 
+                                                            value='Eigenvector Centrality', 
+                                                            title="Eigenvector Centrality Table")
+        except Exception as e:
+            print(f"Error generating eigenvector centrality histogram: {e}")
+    
+    def clustering_coefficient_histogram(self):
+        try:
+            clusters = nx.clustering(self.G)
+            plt.figure(figsize=(15, 8))
+            plt.hist(clusters.values(), bins=50)
+            plt.title("Clustering Coefficient Histogram ", fontdict={"size": 35}, loc="center")
+            plt.xlabel("Clustering Coefficient", fontdict={"size": 20})
+            plt.ylabel("Counts", fontdict={"size": 20})
+            plt.show()
+            self.network_analysis.format_for_upperright_table(clusters, metric='Node', 
+                                                            value='Clustering Coefficient', 
+                                                            title="Clustering Coefficient Table")
+        except Exception as e:
+            print(f"Error generating clustering coefficient histogram: {e}")
+    
+    def bridges_analysis(self):
+        try:
+            bridges = list(nx.bridges(self.G))
+            self.network_analysis.format_for_upperright_table(bridges, metric='Node Pair', 
+                                                            title="Bridges")
+        except Exception as e:
+            print(f"Error generating bridges analysis: {e}")
+    
+    def degree_distribution_histogram(self):
+        """Raw degree distribution - very useful for understanding network topology"""
+        try:
+            degrees = [self.G.degree(n) for n in self.G.nodes()]
+            plt.figure(figsize=(15, 8))
+            plt.hist(degrees, bins=max(30, int(np.sqrt(len(degrees)))), alpha=0.7)
+            plt.title("Degree Distribution", fontdict={"size": 35}, loc="center")
+            plt.xlabel("Degree", fontdict={"size": 20})
+            plt.ylabel("Frequency", fontdict={"size": 20})
+            plt.yscale('log')  # Often useful for degree distributions
+            plt.show()
+            
+            degree_dict = {node: deg for node, deg in self.G.degree()}
+            self.network_analysis.format_for_upperright_table(degree_dict, metric='Node', 
+                                                            value='Degree', title="Degree Distribution Table")
+        except Exception as e:
+            print(f"Error generating degree distribution histogram: {e}")
+    
+
+    def node_connectivity_histogram(self):
+        """Local node connectivity - minimum number of nodes that must be removed to disconnect neighbors"""
+        try:
+            if self.G.number_of_nodes() > 500:  # Skip for large networks (computationally expensive)
+                print("Note this analysis may be slow for large network (>500 nodes)")
+                #return
+                
+            connectivity = {}
+            for node in self.G.nodes():
+                neighbors = list(self.G.neighbors(node))
+                if len(neighbors) > 1:
+                    connectivity[node] = nx.node_connectivity(self.G, neighbors[0], neighbors[1])
+                else:
+                    connectivity[node] = 0
+            
+            plt.figure(figsize=(15, 8))
+            plt.hist(connectivity.values(), bins=20, alpha=0.7)
+            plt.title("Node Connectivity Distribution", fontdict={"size": 35}, loc="center")
+            plt.xlabel("Node Connectivity", fontdict={"size": 20})
+            plt.ylabel("Frequency", fontdict={"size": 20})
+            plt.show()
+            self.network_analysis.format_for_upperright_table(connectivity, metric='Node', 
+                                                            value='Connectivity', title="Node Connectivity Table")
+        except Exception as e:
+            print(f"Error generating node connectivity histogram: {e}")
+    
+    def eccentricity_histogram(self):
+        """Eccentricity - maximum distance from a node to any other node"""
+        try:
+            if not nx.is_connected(self.G):
+                print("Graph is not connected. Using largest connected component.")
+                largest_cc = max(nx.connected_components(self.G), key=len)
+                G_cc = self.G.subgraph(largest_cc)
+                eccentricity = nx.eccentricity(G_cc)
+            else:
+                eccentricity = nx.eccentricity(self.G)
+            
+            plt.figure(figsize=(15, 8))
+            plt.hist(eccentricity.values(), bins=20, alpha=0.7)
+            plt.title("Eccentricity Distribution", fontdict={"size": 35}, loc="center")
+            plt.xlabel("Eccentricity", fontdict={"size": 20})
+            plt.ylabel("Frequency", fontdict={"size": 20})
+            plt.show()
+            self.network_analysis.format_for_upperright_table(eccentricity, metric='Node', 
+                                                            value='Eccentricity', title="Eccentricity Table")
+        except Exception as e:
+            print(f"Error generating eccentricity histogram: {e}")
+    
+    def kcore_histogram(self):
+        """K-core decomposition - identifies cohesive subgroups"""
+        try:
+            kcore = nx.core_number(self.G)
+            plt.figure(figsize=(15, 8))
+            plt.hist(kcore.values(), bins=max(5, max(kcore.values())), alpha=0.7)
+            plt.title("K-Core Distribution", fontdict={"size": 35}, loc="center")
+            plt.xlabel("K-Core Number", fontdict={"size": 20})
+            plt.ylabel("Frequency", fontdict={"size": 20})
+            plt.show()
+            self.network_analysis.format_for_upperright_table(kcore, metric='Node', 
+                                                            value='K-Core', title="K-Core Table")
+        except Exception as e:
+            print(f"Error generating k-core histogram: {e}")
+    
+    def triangle_count_histogram(self):
+        """Number of triangles each node participates in"""
+        try:
+            triangles = nx.triangles(self.G)
+            plt.figure(figsize=(15, 8))
+            plt.hist(triangles.values(), bins=30, alpha=0.7)
+            plt.title("Triangle Count Distribution", fontdict={"size": 35}, loc="center")
+            plt.xlabel("Number of Triangles", fontdict={"size": 20})
+            plt.ylabel("Frequency", fontdict={"size": 20})
+            plt.show()
+            self.network_analysis.format_for_upperright_table(triangles, metric='Node', 
+                                                            value='Triangle Count', title="Triangle Count Table")
+        except Exception as e:
+            print(f"Error generating triangle count histogram: {e}")
+    
+    def load_centrality_histogram(self):
+        """Load centrality - fraction of shortest paths passing through each node"""
+        try:
+            if self.G.number_of_nodes() > 1000:  # Skip for very large networks
+                print("Note this analysis may be slow for large network (>1000 nodes)")
+                #return
+                
+            load_centrality = nx.load_centrality(self.G)
+            plt.figure(figsize=(15, 8))
+            plt.hist(load_centrality.values(), bins=50, alpha=0.7)
+            plt.title("Load Centrality Distribution", fontdict={"size": 35}, loc="center")
+            plt.xlabel("Load Centrality", fontdict={"size": 20})
+            plt.ylabel("Frequency", fontdict={"size": 20})
+            plt.show()
+            self.network_analysis.format_for_upperright_table(load_centrality, metric='Node', 
+                                                            value='Load Centrality', title="Load Centrality Table")
+        except Exception as e:
+            print(f"Error generating load centrality histogram: {e}")
+    
+    def communicability_centrality_histogram(self):
+        """Communicability centrality - based on communicability between nodes"""
+        try:
+            if self.G.number_of_nodes() > 500:  # Skip for large networks (memory intensive)
+                print("Note this analysis may be slow for large network (>500 nodes)")
+                #return
+                
+            # Use the correct function name - it's in the communicability module
+            comm_centrality = nx.communicability_betweenness_centrality(self.G)
+            plt.figure(figsize=(15, 8))
+            plt.hist(comm_centrality.values(), bins=50, alpha=0.7)
+            plt.title("Communicability Betweenness Centrality Distribution", fontdict={"size": 35}, loc="center")
+            plt.xlabel("Communicability Betweenness Centrality", fontdict={"size": 20})
+            plt.ylabel("Frequency", fontdict={"size": 20})
+            plt.show()
+            self.network_analysis.format_for_upperright_table(comm_centrality, metric='Node', 
+                                                            value='Communicability Betweenness Centrality', 
+                                                            title="Communicability Betweenness Centrality Table")
+        except Exception as e:
+            print(f"Error generating communicability betweenness centrality histogram: {e}")
+    
+    def harmonic_centrality_histogram(self):
+        """Harmonic centrality - better than closeness for disconnected networks"""
+        try:
+            harmonic_centrality = nx.harmonic_centrality(self.G)
+            plt.figure(figsize=(15, 8))
+            plt.hist(harmonic_centrality.values(), bins=50, alpha=0.7)
+            plt.title("Harmonic Centrality Distribution", fontdict={"size": 35}, loc="center")
+            plt.xlabel("Harmonic Centrality", fontdict={"size": 20})
+            plt.ylabel("Frequency", fontdict={"size": 20})
+            plt.show()
+            self.network_analysis.format_for_upperright_table(harmonic_centrality, metric='Node', 
+                                                            value='Harmonic Centrality', 
+                                                            title="Harmonic Centrality Table")
+        except Exception as e:
+            print(f"Error generating harmonic centrality histogram: {e}")
+    
+    def current_flow_betweenness_histogram(self):
+        """Current flow betweenness - models network as electrical circuit"""
+        try:
+            if self.G.number_of_nodes() > 500:  # Skip for large networks (computationally expensive)
+                print("Note this analysis may be slow for large network (>500 nodes)")
+                #return
+                
+            current_flow = nx.current_flow_betweenness_centrality(self.G)
+            plt.figure(figsize=(15, 8))
+            plt.hist(current_flow.values(), bins=50, alpha=0.7)
+            plt.title("Current Flow Betweenness Centrality Distribution", fontdict={"size": 35}, loc="center")
+            plt.xlabel("Current Flow Betweenness Centrality", fontdict={"size": 20})
+            plt.ylabel("Frequency", fontdict={"size": 20})
+            plt.show()
+            self.network_analysis.format_for_upperright_table(current_flow, metric='Node', 
+                                                            value='Current Flow Betweenness', 
+                                                            title="Current Flow Betweenness Table")
+        except Exception as e:
+            print(f"Error generating current flow betweenness histogram: {e}")
+    
+    def dispersion_histogram(self):
+        """Dispersion - measures how scattered a node's neighbors are"""
+        try:
+            if self.G.number_of_nodes() > 300:  # Skip for large networks (very computationally expensive)
+                print("Note this analysis may be slow for large network (>300 nodes)")
+                #return
+                
+            # Calculate average dispersion for each node
+            dispersion_values = {}
+            nodes = list(self.G.nodes())
+            
+            for u in nodes:
+                if self.G.degree(u) < 2:  # Need at least 2 neighbors for dispersion
+                    dispersion_values[u] = 0
+                    continue
+                    
+                # Calculate dispersion for node u with all its neighbors
+                neighbors = list(self.G.neighbors(u))
+                if len(neighbors) < 2:
+                    dispersion_values[u] = 0
+                    continue
+                
+                # Get dispersion scores for this node with all neighbors
+                disp_scores = []
+                for v in neighbors:
+                    try:
+                        disp_score = nx.dispersion(self.G, u, v)
+                        disp_scores.append(disp_score)
+                    except:
+                        continue
+                
+                # Average dispersion for this node
+                dispersion_values[u] = sum(disp_scores) / len(disp_scores) if disp_scores else 0
+            
+            plt.figure(figsize=(15, 8))
+            plt.hist(dispersion_values.values(), bins=30, alpha=0.7)
+            plt.title("Average Dispersion Distribution", fontdict={"size": 35}, loc="center")
+            plt.xlabel("Average Dispersion", fontdict={"size": 20})
+            plt.ylabel("Frequency", fontdict={"size": 20})
+            plt.show()
+            self.network_analysis.format_for_upperright_table(dispersion_values, metric='Node', 
+                                                            value='Average Dispersion', 
+                                                            title="Average Dispersion Table")
+        except Exception as e:
+            print(f"Error generating dispersion histogram: {e}")
+
+
 
 # Initiating this program from the script line: