microlive 1.0.12__py3-none-any.whl → 1.0.19__py3-none-any.whl

microlive/gui/app.py

@@ -101,6 +101,7 @@ from matplotlib.backends.backend_qt5agg import (
     FigureCanvasQTAgg as FigureCanvas,
     NavigationToolbar2QT as NavigationToolbar,)
 from mpl_toolkits.axes_grid1.inset_locator import inset_axes
+from mpl_toolkits.mplot3d import Axes3D  # For 3D intensity profile visualization
 from functools import partial
 from scipy.optimize import curve_fit
 from scipy.ndimage import gaussian_filter, label, center_of_mass, distance_transform_edt
@@ -2841,12 +2842,21 @@ class GUI(QMainWindow):
             if hasattr(self, 'time_slider_display'):
                 self.time_slider_display.setEnabled(False)
                 self.time_slider_display.setValue(0)
+                self.time_slider_display.setMaximum(0)
+            if hasattr(self, 'frame_label_display'):
+                self.frame_label_display.setText("0/0")
             if hasattr(self, 'play_button_display'):
                 self.play_button_display.setEnabled(False)
             if hasattr(self, 'time_slider_tracking'):
                 self.time_slider_tracking.setValue(0)
+                self.time_slider_tracking.setMaximum(0)
+            if hasattr(self, 'frame_label_tracking'):
+                self.frame_label_tracking.setText("0/0")
             if hasattr(self, 'time_slider_tracking_vis'):
                 self.time_slider_tracking_vis.setValue(0)
+                self.time_slider_tracking_vis.setMaximum(0)
+            if hasattr(self, 'frame_label_tracking_vis'):
+                self.frame_label_tracking_vis.setText("0/0")
             
             # Stop any playing timers
             self.stop_all_playback()
@@ -2937,12 +2947,21 @@ class GUI(QMainWindow):
         if hasattr(self, 'time_slider_display'):
             self.time_slider_display.setEnabled(False)
             self.time_slider_display.setValue(0)
+            self.time_slider_display.setMaximum(0)
+        if hasattr(self, 'frame_label_display'):
+            self.frame_label_display.setText("0/0")
         if hasattr(self, 'play_button_display'):
             self.play_button_display.setEnabled(False)
         if hasattr(self, 'time_slider_tracking'):
             self.time_slider_tracking.setValue(0)
+            self.time_slider_tracking.setMaximum(0)
+        if hasattr(self, 'frame_label_tracking'):
+            self.frame_label_tracking.setText("0/0")
         if hasattr(self, 'time_slider_tracking_vis'):
             self.time_slider_tracking_vis.setValue(0)
+            self.time_slider_tracking_vis.setMaximum(0)
+        if hasattr(self, 'frame_label_tracking_vis'):
+            self.frame_label_tracking_vis.setText("0/0")
         
         # Stop any playing timers
         self.stop_all_playback()
@@ -4164,6 +4183,19 @@ class GUI(QMainWindow):
         if hasattr(self, 'label_nuc_mask_status'):
             self.label_nuc_mask_status.setText("No nucleus mask loaded")
             self.label_nuc_mask_status.setStyleSheet("color: gray;")
+        # Reset Improve Segmentation checkboxes
+        if hasattr(self, 'chk_remove_border_cells'):
+            self.chk_remove_border_cells.blockSignals(True)
+            self.chk_remove_border_cells.setChecked(False)
+            self.chk_remove_border_cells.blockSignals(False)
+        if hasattr(self, 'chk_remove_unpaired_cells'):
+            self.chk_remove_unpaired_cells.blockSignals(True)
+            self.chk_remove_unpaired_cells.setChecked(False)
+            self.chk_remove_unpaired_cells.blockSignals(False)
+        if hasattr(self, 'chk_keep_center_cell'):
+            self.chk_keep_center_cell.blockSignals(True)
+            self.chk_keep_center_cell.setChecked(False)
+            self.chk_keep_center_cell.blockSignals(False)
         self.plot_cellpose_results()
 
     def clear_imported_masks(self):
@@ -4581,6 +4613,142 @@ class GUI(QMainWindow):
             new_masks[masks == old_id] = new_id
         return new_masks
 
+    def get_closest_cell_to_center(self, mask):
+        """Find the cell ID whose centroid is closest to the image center.
+        
+        Args:
+            mask: 2D array [Y, X] with cell labels (0=background, 1,2,3...=cells)
+        
+        Returns:
+            int: Cell ID closest to center, or None if no cells
+        """
+        if mask is None or np.max(mask) == 0:
+            return None
+        
+        # Get image center
+        center_y, center_x = mask.shape[0] / 2, mask.shape[1] / 2
+        
+        # Get unique cell IDs (exclude background)
+        cell_ids = np.unique(mask)
+        cell_ids = cell_ids[cell_ids > 0]
+        
+        if len(cell_ids) == 0:
+            return None
+        
+        min_distance = float('inf')
+        closest_cell_id = None
+        
+        for cell_id in cell_ids:
+            # Find centroid of this cell
+            coords = np.argwhere(mask == cell_id)
+            centroid_y = np.mean(coords[:, 0])
+            centroid_x = np.mean(coords[:, 1])
+            
+            # Calculate distance to image center
+            distance = np.sqrt((centroid_y - center_y)**2 + (centroid_x - center_x)**2)
+            
+            if distance < min_distance:
+                min_distance = distance
+                closest_cell_id = cell_id
+        
+        return closest_cell_id
+
+    def on_keep_center_cell_changed(self, state):
+        """Handle checkbox state change for keeping only the center cell.
+        
+        For TYX masks: Uses the FIRST frame to identify the center cell,
+        then keeps that cell ID across ALL frames for consistent tracking.
+        """
+        from PyQt5.QtCore import Qt
+        
+        if state == Qt.Checked:
+            # Check if we have any masks
+            has_cyto = False
+            has_nuc = False
+            
+            if getattr(self, 'use_tyx_masks', False):
+                has_cyto = self.cellpose_masks_cyto_tyx is not None and np.max(self.cellpose_masks_cyto_tyx) > 0
+                has_nuc = self.cellpose_masks_nuc_tyx is not None and np.max(self.cellpose_masks_nuc_tyx) > 0
+            else:
+                has_cyto = self.cellpose_masks_cyto is not None and np.max(self.cellpose_masks_cyto) > 0
+                has_nuc = self.cellpose_masks_nuc is not None and np.max(self.cellpose_masks_nuc) > 0
+            
+            if not has_cyto and not has_nuc:
+                QMessageBox.warning(self, "No Masks", 
+                    "No segmentation masks available to filter.")
+                self.chk_keep_center_cell.blockSignals(True)
+                self.chk_keep_center_cell.setChecked(False)
+                self.chk_keep_center_cell.blockSignals(False)
+                return
+            
+            # Determine which mask to use for finding center cell
+            # Prefer cytosol mask, fall back to nucleus
+            if getattr(self, 'use_tyx_masks', False):
+                # TYX mode: use first frame to find center cell
+                if has_cyto:
+                    reference_mask = self.cellpose_masks_cyto_tyx[0]
+                else:
+                    reference_mask = self.cellpose_masks_nuc_tyx[0]
+            else:
+                # Standard YX mode
+                if has_cyto:
+                    reference_mask = self.cellpose_masks_cyto
+                else:
+                    reference_mask = self.cellpose_masks_nuc
+            
+            # Find the cell closest to center
+            center_cell_id = self.get_closest_cell_to_center(reference_mask)
+            
+            if center_cell_id is None:
+                QMessageBox.warning(self, "No Cells", 
+                    "Could not find any cells in the mask.")
+                self.chk_keep_center_cell.blockSignals(True)
+                self.chk_keep_center_cell.setChecked(False)
+                self.chk_keep_center_cell.blockSignals(False)
+                return
+            
+            # Remove all cells except the center cell
+            if getattr(self, 'use_tyx_masks', False):
+                # TYX mode: remove from all frames
+                if self.cellpose_masks_cyto_tyx is not None:
+                    all_cyto_ids = set(np.unique(self.cellpose_masks_cyto_tyx))
+                    all_cyto_ids.discard(0)
+                    ids_to_remove = all_cyto_ids - {center_cell_id}
+                    if ids_to_remove:
+                        self.cellpose_masks_cyto_tyx = self._remove_labels_from_tyx(
+                            self.cellpose_masks_cyto_tyx, ids_to_remove)
+                    # Update current frame YX mask
+                    self.cellpose_masks_cyto = self.cellpose_masks_cyto_tyx[self.segmentation_current_frame]
+                
+                if self.cellpose_masks_nuc_tyx is not None:
+                    all_nuc_ids = set(np.unique(self.cellpose_masks_nuc_tyx))
+                    all_nuc_ids.discard(0)
+                    ids_to_remove = all_nuc_ids - {center_cell_id}
+                    if ids_to_remove:
+                        self.cellpose_masks_nuc_tyx = self._remove_labels_from_tyx(
+                            self.cellpose_masks_nuc_tyx, ids_to_remove)
+                    # Update current frame YX mask
+                    self.cellpose_masks_nuc = self.cellpose_masks_nuc_tyx[self.segmentation_current_frame]
+            else:
+                # Standard YX mode
+                if self.cellpose_masks_cyto is not None:
+                    all_cyto_ids = set(np.unique(self.cellpose_masks_cyto))
+                    all_cyto_ids.discard(0)
+                    ids_to_remove = all_cyto_ids - {center_cell_id}
+                    if ids_to_remove:
+                        self.cellpose_masks_cyto = self.remove_labels_and_reindex(
+                            self.cellpose_masks_cyto, ids_to_remove)
+                
+                if self.cellpose_masks_nuc is not None:
+                    all_nuc_ids = set(np.unique(self.cellpose_masks_nuc))
+                    all_nuc_ids.discard(0)
+                    ids_to_remove = all_nuc_ids - {center_cell_id}
+                    if ids_to_remove:
+                        self.cellpose_masks_nuc = self.remove_labels_and_reindex(
+                            self.cellpose_masks_nuc, ids_to_remove)
+        
+        self.plot_cellpose_results()
+
     def plot_cellpose_results(self):
         """Plot Cellpose segmentation results on the shared segmentation canvas."""
         if self.image_stack is None:
@@ -4702,21 +4870,43 @@ class GUI(QMainWindow):
             self.segmentation_channel_buttons.append(btn)
 
     def update_segmentation_channel(self, channel_index):
+        # Don't clear mask when in Edit mode (we're editing, not creating new)
+        current_subtab = getattr(self, 'segmentation_method_tabs', None)
+        if current_subtab is not None and current_subtab.currentIndex() == 4:
+            # Just update channel for viewing, don't clear mask
+            self.segmentation_current_channel = channel_index
+            self.plot_edit_mode()
+            return
+        
         # Clear old mask when changing channel
         self.segmentation_mask = None
         self.segmentation_current_channel = channel_index
         
         # Refresh display based on active sub-tab
         if hasattr(self, 'segmentation_method_tabs'):
-            current_subtab = self.segmentation_method_tabs.currentIndex()
-            if current_subtab == 1 or current_subtab == 3:  # Cellpose or Import sub-tab
+            current_index = self.segmentation_method_tabs.currentIndex()
+            if current_index == 1 or current_index == 3:  # Cellpose or Import sub-tab
                 self.plot_cellpose_results()
+            elif current_index == 4:  # Edit sub-tab
+                self.plot_edit_mode()
             else:
                 self.plot_segmentation()
         else:
             self.plot_segmentation()
 
     def update_segmentation_frame(self, value):
+        # Don't clear mask when in Edit mode (we're editing, not creating new)
+        current_subtab = getattr(self, 'segmentation_method_tabs', None)
+        if current_subtab is not None and current_subtab.currentIndex() == 4:
+            # Just update frame for viewing, don't clear mask
+            self.segmentation_current_frame = value
+            # Update frame label
+            total_frames = getattr(self, 'total_frames', 1)
+            if hasattr(self, 'frame_label_segmentation'):
+                self.frame_label_segmentation.setText(f"{value}/{total_frames - 1}")
+            self.plot_edit_mode()
+            return
+        
         # Clear old manual/watershed mask when changing frame
         self.segmentation_mask = None
         self.segmentation_current_frame = value
@@ -4735,9 +4925,11 @@ class GUI(QMainWindow):
         
         # Refresh display based on active sub-tab
         if hasattr(self, 'segmentation_method_tabs'):
-            current_subtab = self.segmentation_method_tabs.currentIndex()
-            if current_subtab == 1 or current_subtab == 3:  # Cellpose or Import sub-tab
+            current_index = self.segmentation_method_tabs.currentIndex()
+            if current_index == 1 or current_index == 3:  # Cellpose or Import sub-tab
                 self.plot_cellpose_results()
+            elif current_index == 4:  # Edit sub-tab
+                self.plot_edit_mode()
             else:
                 self.plot_segmentation()
         else:
@@ -5683,7 +5875,7 @@ class GUI(QMainWindow):
             cellpose_cyto_* and cellpose_nuc_* inputs (model, channel, diameter)
             btn_run_cyto, btn_run_nuc (QPushButton)
             num_masks_slider, min_frames_slider, cell_expansion_slider, cell_shrink_slider
-            chk_remove_border_cells, chk_remove_unpaired_cells (QCheckBox)
+            chk_remove_border_cells, chk_remove_unpaired_cells, chk_keep_center_cell (QCheckBox)
             btn_clear_cellpose (QPushButton)
             cellpose_masks_cyto, cellpose_masks_nuc (Optional[np.ndarray])
             cellpose_masks_cyto_tyx, cellpose_masks_nuc_tyx (Optional[np.ndarray])
@@ -5703,7 +5895,7 @@ class GUI(QMainWindow):
             run_cellpose_cyto, run_cellpose_nuc, clear_cellpose_masks
             _on_num_masks_slider_changed, _on_min_frames_slider_changed
             _on_expansion_slider_changed, _on_shrink_slider_changed
-            on_remove_border_cells_changed, on_remove_unpaired_cells_changed
+            on_remove_border_cells_changed, on_remove_unpaired_cells_changed, on_keep_center_cell_changed
         """
 
         self.segmentation_current_frame = 0
@@ -5719,7 +5911,7 @@ class GUI(QMainWindow):
         main_layout = QHBoxLayout(self.segmentation_tab)
         # LEFT PANEL: Segmentation Figure & Controls
         left_layout = QVBoxLayout()
-        main_layout.addLayout(left_layout, stretch=3)
+        main_layout.addLayout(left_layout, stretch=5)
         
         # Create canvas + Z-slider layout (horizontal: canvas on left, Z-slider on right)
         canvas_z_layout = QHBoxLayout()
@@ -5802,12 +5994,15 @@ class GUI(QMainWindow):
         
         # RIGHT PANEL: Segmentation Methods & Source Toggle
         right_layout = QVBoxLayout()
-        main_layout.addLayout(right_layout, stretch=1)
+        main_layout.addLayout(right_layout, stretch=2)
         
         # =====================================================================
         # SEGMENTATION METHOD SUB-TABS
         # =====================================================================
         self.segmentation_method_tabs = QTabWidget()
+        # Enable scrollable tabs so all tabs are accessible when panel is narrow
+        self.segmentation_method_tabs.setUsesScrollButtons(True)
+        self.segmentation_method_tabs.setElideMode(Qt.ElideNone)
         
         # --- Manual Segmentation Tab ---
         manual_tab = QWidget()
@@ -6145,6 +6340,16 @@ class GUI(QMainWindow):
         self.chk_remove_unpaired_cells.stateChanged.connect(self.on_remove_unpaired_cells_changed)
         improve_layout.addRow(self.chk_remove_unpaired_cells)
         
+        self.chk_keep_center_cell = QCheckBox("Keep only center cell")
+        self.chk_keep_center_cell.setChecked(False)
+        self.chk_keep_center_cell.setToolTip(
+            "Keep only the cell whose centroid is closest to the image center.\n"
+            "Useful for single-cell analysis when multiple cells are detected.\n"
+            "Note: This filter is applied after 'Remove border' and 'Remove unpaired' filters."
+        )
+        self.chk_keep_center_cell.stateChanged.connect(self.on_keep_center_cell_changed)
+        improve_layout.addRow(self.chk_keep_center_cell)
+        
         improve_group.setLayout(improve_layout)
         cellpose_layout.addWidget(improve_group)
         
@@ -6215,9 +6420,154 @@ class GUI(QMainWindow):
         # Add Manual tab (Index 2) before Import
         self.segmentation_method_tabs.addTab(manual_tab, "Manual")
         
-        # Add Import tab last (Index 3)
+        # Add Import tab (Index 3)
         self.segmentation_method_tabs.addTab(import_tab, "Import")
         
+        # =====================================================================
+        # EDIT TAB (Index 4) - Edit existing masks from any method
+        # =====================================================================
+        edit_tab = QWidget()
+        edit_tab_layout = QVBoxLayout(edit_tab)
+        edit_tab_layout.setContentsMargins(10, 10, 10, 10)
+        edit_tab_layout.setSpacing(8)
+        
+        # Create scrollable area for edit controls
+        edit_scroll = QScrollArea()
+        edit_scroll.setWidgetResizable(True)
+        edit_scroll.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
+        edit_scroll_widget = QWidget()
+        edit_scroll_layout = QVBoxLayout(edit_scroll_widget)
+        edit_scroll_layout.setSpacing(8)
+        
+        # Instructions label
+        edit_instructions = QLabel(
+            "Edit existing masks from any segmentation method.\n"
+            "Select a mask and tool, then draw on the image.\n"
+            "Cell labels are preserved (erasing sets pixels to background)."
+        )
+        edit_instructions.setWordWrap(True)
+        edit_instructions.setStyleSheet("color: gray; font-size: 11px;")
+        edit_scroll_layout.addWidget(edit_instructions)
+        
+        # --- Mask to Edit Group ---
+        mask_select_group = QGroupBox("Mask to Edit")
+        mask_select_layout = QVBoxLayout()
+        
+        self.edit_mask_selector = QComboBox()
+        self.edit_mask_selector.addItem("-- Select Mask --")
+        self.edit_mask_selector.currentIndexChanged.connect(self.on_edit_mask_selector_changed)
+        mask_select_layout.addWidget(self.edit_mask_selector)
+        
+        self.edit_mask_info_label = QLabel("No mask selected")
+        self.edit_mask_info_label.setStyleSheet("color: gray; font-size: 10px;")
+        mask_select_layout.addWidget(self.edit_mask_info_label)
+        
+        mask_select_group.setLayout(mask_select_layout)
+        edit_scroll_layout.addWidget(mask_select_group)
+        
+        # --- Instructions Panel (shown when mask is selected) ---
+        self.edit_instructions_group = QGroupBox("How to Edit")
+        instructions_layout = QVBoxLayout()
+        
+        self.edit_instructions_label = QLabel(
+            "🖱️ Click and drag on the mask to erase regions.\n"
+            "   Erased areas become background (0).\n\n"
+            "💾 Click 'Apply & Save' when finished."
+        )
+        self.edit_instructions_label.setWordWrap(True)
+        self.edit_instructions_label.setStyleSheet("color: #88ccff; font-size: 11px;")
+        instructions_layout.addWidget(self.edit_instructions_label)
+        
+        self.edit_instructions_group.setLayout(instructions_layout)
+        self.edit_instructions_group.setVisible(False)  # Hidden until mask selected
+        edit_scroll_layout.addWidget(self.edit_instructions_group)
+        
+        # --- TYX Info Panel (shown for time-varying masks) ---
+        self.edit_tyx_info_group = QGroupBox("Time-Varying Mask")
+        tyx_info_layout = QVBoxLayout()
+        
+        self.edit_tyx_info_label = QLabel(
+            "ℹ️ Editing combined view (max projection).\n"
+            "Edits will apply to ALL frames when saved."
+        )
+        self.edit_tyx_info_label.setWordWrap(True)
+        self.edit_tyx_info_label.setStyleSheet("color: #6699ff; font-size: 10px;")
+        tyx_info_layout.addWidget(self.edit_tyx_info_label)
+        
+        self.edit_tyx_info_group.setLayout(tyx_info_layout)
+        self.edit_tyx_info_group.setVisible(False)  # Hidden until TYX mask selected
+        edit_scroll_layout.addWidget(self.edit_tyx_info_group)
+        
+        # --- Action Buttons Group ---
+        action_group = QGroupBox("Actions")
+        action_layout = QVBoxLayout()
+        
+        action_btn_layout = QHBoxLayout()
+        self.btn_undo_edit = QPushButton("Undo")
+        self.btn_undo_edit.setToolTip("Restore mask to state before last edit (max 10 steps)")
+        self.btn_undo_edit.clicked.connect(self.undo_edit)
+        self.btn_undo_edit.setEnabled(False)
+        action_btn_layout.addWidget(self.btn_undo_edit)
+        
+        self.btn_reset_edits = QPushButton("Reset")
+        self.btn_reset_edits.setToolTip("Discard all edits and restore the mask to its original state")
+        self.btn_reset_edits.clicked.connect(self.reset_edits)
+        self.btn_reset_edits.setEnabled(False)
+        action_btn_layout.addWidget(self.btn_reset_edits)
+        action_layout.addLayout(action_btn_layout)
+        
+        self.btn_apply_edits = QPushButton("Apply && Save")
+        self.btn_apply_edits.setToolTip("Apply edits to the active mask and use for downstream analysis")
+        self.btn_apply_edits.setStyleSheet("background-color: #336633; font-weight: bold;")
+        self.btn_apply_edits.clicked.connect(self.apply_and_save_edits)
+        self.btn_apply_edits.setEnabled(False)
+        action_layout.addWidget(self.btn_apply_edits)
+        
+        action_group.setLayout(action_layout)
+        edit_scroll_layout.addWidget(action_group)
+        
+        # --- Status Panel ---
+        status_group = QGroupBox("Edit Status")
+        status_layout = QVBoxLayout()
+        
+        self.edit_status_label = QLabel("⚠ Select a mask to begin editing")
+        self.edit_status_label.setWordWrap(True)
+        self.edit_status_label.setStyleSheet("color: #ffcc00;")
+        status_layout.addWidget(self.edit_status_label)
+        
+        status_group.setLayout(status_layout)
+        edit_scroll_layout.addWidget(status_group)
+        
+        edit_scroll_layout.addStretch()
+        edit_scroll.setWidget(edit_scroll_widget)
+        edit_tab_layout.addWidget(edit_scroll)
+        
+        # Add Edit tab (Index 4)
+        self.segmentation_method_tabs.addTab(edit_tab, "Edit")
+        
+        # =====================================================================
+        # EDIT MODE STATE VARIABLES
+        # =====================================================================
+        # Edit mode state
+        self.edit_mode_active = False
+        self.edit_current_mask_key = None  # 'watershed', 'cellpose_cyto', 'cellpose_nuc'
+        self.edit_working_mask = None  # 2D working copy (Y, X) - always 2D for editing
+        self.edit_original_mask = None  # Original mask before edits (for reset)
+        self.edit_original_2d = None  # Max projection of original (for computing diffs)
+        self.edit_source_is_tyx = False  # True if source mask is TYX (3D)
+        
+        # Undo system
+        self.edit_undo_stack = []
+        self.EDIT_MAX_UNDO_DEPTH = 10
+        
+        # Eraser brush state (only tool)
+        self.edit_brush_size = 10
+        self.edit_brush_shape = 'circle'
+        
+        # Mouse state for drawing
+        self.edit_last_mouse_pos = None
+        self.edit_is_drawing = False
+        
         # Initialize Cellpose/imported mask state variables
         # NOTE: Uses segmentation_current_frame and segmentation_current_channel (shared)
         self.cellpose_masks_cyto = None
@@ -6256,21 +6606,625 @@ class GUI(QMainWindow):
         self.plot_segmentation()
     
     def _on_segmentation_subtab_changed(self, index):
-        """Handle switching between segmentation method sub-tabs (Watershed, Cellpose, Manual, Import).
+        """Handle switching between segmentation method sub-tabs.
         
         Tab indices:
             0 = Watershed
             1 = Cellpose
             2 = Manual
             3 = Import (uses Cellpose-style display)
+            4 = Edit (edit existing masks)
         """
-        if index == 1 or index == 3:  # Cellpose or Import sub-tab
-            # Show Cellpose/imported masks on the shared segmentation canvas
+        if index == 4:  # Edit sub-tab
+            self.enter_edit_mode()
+        elif index == 1 or index == 3:  # Cellpose or Import sub-tab
+            self.exit_edit_mode()
             self.plot_cellpose_results()
         else:
-            # For Watershed and Manual, use the standard segmentation display
+            self.exit_edit_mode()
             self.plot_segmentation()
 
+    # =========================================================================
+    # EDIT TAB SIGNAL HANDLERS
+    # =========================================================================
+    
+    def enter_edit_mode(self):
+        """Initialize edit mode when Edit tab is selected."""
+        self.edit_mode_active = True
+        
+        # Connect mouse events for editing
+        self._connect_edit_mouse_events()
+        
+        # Populate mask selector with available masks
+        self._refresh_edit_mask_selector()
+        
+        # If a mask is already selected, load it
+        if self.edit_mask_selector.currentIndex() > 0:
+            self.on_edit_mask_selector_changed(self.edit_mask_selector.currentIndex())
+        else:
+            # Just show the current segmentation view
+            self.plot_edit_mode()
+    
+    def exit_edit_mode(self):
+        """Clean up edit mode when leaving Edit tab."""
+        if not self.edit_mode_active:
+            return
+            
+        # Check for unsaved edits
+        if self.edit_working_mask is not None and self.edit_undo_stack:
+            reply = QMessageBox.question(
+                self, "Unsaved Edits",
+                "You have unsaved edits. Discard them?",
+                QMessageBox.Yes | QMessageBox.No,
+                QMessageBox.No
+            )
+            if reply == QMessageBox.No:
+                # Switch back to Edit tab
+                self.segmentation_method_tabs.blockSignals(True)
+                self.segmentation_method_tabs.setCurrentIndex(4)
+                self.segmentation_method_tabs.blockSignals(False)
+                return
+        
+        # Clear edit state
+        self.edit_mode_active = False
+        self.edit_working_mask = None
+        self.edit_original_mask = None
+        self.edit_undo_stack = []
+        
+        # Disconnect mouse events
+        self._disconnect_edit_mouse_events()
+    
+    def _refresh_edit_mask_selector(self):
+        """Populate the mask selector dropdown with available masks."""
+        self.edit_mask_selector.blockSignals(True)
+        self.edit_mask_selector.clear()
+        self.edit_mask_selector.addItem("-- Select Mask --")
+        
+        # Check for Watershed/Manual mask
+        if self.segmentation_mask is not None:
+            n_cells = len(np.unique(self.segmentation_mask)) - 1  # Exclude 0
+            shape = self.segmentation_mask.shape
+            self.edit_mask_selector.addItem(
+                f"Watershed Mask ({n_cells} cells, {shape[1]}×{shape[0]})",
+                "watershed"
+            )
+        
+        # Check for Cellpose cytosol mask
+        if self.cellpose_masks_cyto is not None:
+            mask = self.cellpose_masks_cyto
+            n_cells = len(np.unique(mask)) - 1
+            if mask.ndim == 3:
+                shape_str = f"TYX: {mask.shape[0]}×{mask.shape[2]}×{mask.shape[1]}"
+            else:
+                shape_str = f"{mask.shape[1]}×{mask.shape[0]}"
+            self.edit_mask_selector.addItem(
+                f"Cellpose Cytosol ({n_cells} cells, {shape_str})",
+                "cellpose_cyto"
+            )
+        
+        # Check for Cellpose nucleus mask
+        if self.cellpose_masks_nuc is not None:
+            mask = self.cellpose_masks_nuc
+            n_cells = len(np.unique(mask)) - 1
+            if mask.ndim == 3:
+                shape_str = f"TYX: {mask.shape[0]}×{mask.shape[2]}×{mask.shape[1]}"
+            else:
+                shape_str = f"{mask.shape[1]}×{mask.shape[0]}"
+            self.edit_mask_selector.addItem(
+                f"Cellpose Nucleus ({n_cells} cells, {shape_str})",
+                "cellpose_nuc"
+            )
+        
+        self.edit_mask_selector.blockSignals(False)
+        
+        # Update status based on availability
+        if self.edit_mask_selector.count() <= 1:
+            self.edit_status_label.setText("⚠ No masks available - run segmentation first")
+            self.edit_status_label.setStyleSheet("color: #ff6666;")
+        else:
+            self.edit_status_label.setText("⚠ Select a mask to begin editing")
+            self.edit_status_label.setStyleSheet("color: #ffcc00;")
+    
+    def on_edit_mask_selector_changed(self, index):
+        """Handle switching between masks to edit."""
+        if index <= 0:
+            # No mask selected
+            self.edit_working_mask = None
+            self.edit_original_mask = None
+            self.edit_current_mask_key = None
+            self.edit_mask_info_label.setText("No mask selected")
+            self.edit_tyx_info_group.setVisible(False)
+            self.edit_instructions_group.setVisible(False)  # Hide instructions
+            self._update_edit_buttons_state()
+            self.plot_edit_mode()
+            return
+        
+        # Get the mask key from the item data
+        mask_key = self.edit_mask_selector.itemData(index)
+        
+        # Load the selected mask
+        if mask_key == "watershed":
+            source_mask = self.segmentation_mask
+        elif mask_key == "cellpose_cyto":
+            source_mask = self.cellpose_masks_cyto
+        elif mask_key == "cellpose_nuc":
+            source_mask = self.cellpose_masks_nuc
+        else:
+            return
+        
+        # Create working copy
+        self.edit_working_mask, self.edit_original_2d, self.edit_source_is_tyx = \
+            self._create_edit_working_copy(source_mask)
+        self.edit_original_mask = source_mask.copy()
+        self.edit_current_mask_key = mask_key
+        
+        # Clear undo stack for new mask
+        self.edit_undo_stack = []
+        
+        # Update info label
+        n_cells = len(np.unique(self.edit_working_mask)) - 1
+        shape = self.edit_working_mask.shape
+        self.edit_mask_info_label.setText(f"{n_cells} cells, {shape[1]}×{shape[0]} px")
+        self.edit_mask_info_label.setStyleSheet("color: #88ff88; font-size: 10px;")
+        
+        # Show TYX info if applicable
+        self.edit_tyx_info_group.setVisible(self.edit_source_is_tyx)
+        if self.edit_source_is_tyx:
+            n_frames = source_mask.shape[0]
+            self.edit_tyx_info_label.setText(
+                f"ℹ️ Editing combined view of {n_frames} frames.\n"
+                "Edits will apply to ALL frames when saved."
+            )
+        
+        # Show instructions panel
+        self.edit_instructions_group.setVisible(True)
+        
+        # Update buttons
+        self._update_edit_buttons_state()
+        
+        # Update status
+        self.edit_status_label.setText(f"✓ Ready to edit {mask_key.replace('_', ' ').title()}")
+        self.edit_status_label.setStyleSheet("color: #88ff88;")
+        
+        # Update display
+        self.plot_edit_mode()
+    
+    def _create_edit_working_copy(self, source_mask):
+        """Create a 2D working copy for editing.
+        
+        Args:
+            source_mask: The source mask array (YX or TYX)
+        
+        Returns:
+            tuple: (working_mask_2d, original_2d, is_tyx)
+        """
+        if source_mask.ndim == 3:  # TYX
+            # Max projection for editing
+            working_mask = np.max(source_mask, axis=0).copy()
+            original_2d = working_mask.copy()
+            is_tyx = True
+        else:  # YX
+            working_mask = source_mask.copy()
+            original_2d = working_mask.copy()
+            is_tyx = False
+        
+        return working_mask, original_2d, is_tyx
+    
+    
+    
+    def _update_edit_buttons_state(self):
+        """Update enabled state of edit action buttons."""
+        has_mask = self.edit_working_mask is not None
+        has_edits = len(self.edit_undo_stack) > 0
+        
+        self.btn_undo_edit.setEnabled(has_edits)
+        self.btn_reset_edits.setEnabled(has_edits)
+        self.btn_apply_edits.setEnabled(has_mask)
+    
+    # =========================================================================
+    # UNDO/RESET/APPLY
+    # =========================================================================
+    
+    def _push_undo(self, description="Edit"):
+        """Push current mask state to undo stack."""
+        if self.edit_working_mask is None:
+            return
+        
+        self.edit_undo_stack.append((self.edit_working_mask.copy(), description))
+        
+        # Limit stack size
+        if len(self.edit_undo_stack) > self.EDIT_MAX_UNDO_DEPTH:
+            self.edit_undo_stack.pop(0)
+    
+    def undo_edit(self):
+        """Pop last state from undo stack and restore."""
+        if not self.edit_undo_stack:
+            self.edit_status_label.setText("Nothing to undo")
+            self.edit_status_label.setStyleSheet("color: gray;")
+            return
+        
+        # Pop the last state
+        mask, description = self.edit_undo_stack.pop()
+        self.edit_working_mask = mask
+        
+        self.edit_status_label.setText(f"↩ Undid: {description}")
+        self.edit_status_label.setStyleSheet("color: #88ff88;")
+        
+        # Refresh dropdown
+        self._refresh_cell_label_dropdown()
+        
+        # Update buttons and display
+        self._update_edit_buttons_state()
+        self.plot_edit_mode()
+    
+    def reset_edits(self):
+        """Restore mask to original state before editing began."""
+        if self.edit_original_mask is None:
+            return
+        
+        # Confirm if many edits
+        if len(self.edit_undo_stack) > 3:
+            reply = QMessageBox.question(
+                self, "Reset All Edits",
+                f"This will discard {len(self.edit_undo_stack)} edits. Continue?",
+                QMessageBox.Yes | QMessageBox.No,
+                QMessageBox.No
+            )
+            if reply == QMessageBox.No:
+                return
+        
+        # Restore original
+        self.edit_working_mask, self.edit_original_2d, _ = \
+            self._create_edit_working_copy(self.edit_original_mask)
+        
+        # Clear undo stack
+        self.edit_undo_stack = []
+        
+        self.edit_status_label.setText("↺ Reset to original mask")
+        self.edit_status_label.setStyleSheet("color: #88ff88;")
+        
+        # Refresh dropdown
+        self._refresh_cell_label_dropdown()
+        
+        # Update buttons and display
+        self._update_edit_buttons_state()
+        self.plot_edit_mode()
+    
+    def apply_and_save_edits(self):
+        """Apply edits back to the source mask and set as active for downstream workflow."""
+        if self.edit_working_mask is None or self.edit_current_mask_key is None:
+            return
+        
+        source_key = self.edit_current_mask_key
+        
+        if source_key == 'watershed':
+            # Watershed is always YX
+            self.segmentation_mask = self.edit_working_mask.copy()
+            self._active_mask_source = 'segmentation'
+            
+        elif source_key == 'cellpose_cyto':
+            if self.edit_source_is_tyx:
+                # Apply 2D edits to all frames
+                self.cellpose_masks_cyto = self._apply_edits_to_tyx(
+                    self.edit_original_mask,
+                    self.edit_working_mask,
+                    self.edit_original_2d
+                )
+            else:
+                self.cellpose_masks_cyto = self.edit_working_mask.copy()
+            self._active_mask_source = 'cellpose'
+            
+        elif source_key == 'cellpose_nuc':
+            if self.edit_source_is_tyx:
+                self.cellpose_masks_nuc = self._apply_edits_to_tyx(
+                    self.edit_original_mask,
+                    self.edit_working_mask,
+                    self.edit_original_2d
+                )
+            else:
+                self.cellpose_masks_nuc = self.edit_working_mask.copy()
+            self._active_mask_source = 'cellpose'
+        
+        # Invalidate downstream calculations
+        self.corrected_image = None
+        self.photobleaching_calculated = False
+        if hasattr(self, 'df_tracking'):
+            self.df_tracking = pd.DataFrame()
+        if hasattr(self, 'multi_channel_tracking_data'):
+            self.multi_channel_tracking_data = {}
+        
+        # Clear edit state
+        self.edit_undo_stack = []
+        self.edit_original_mask = self.edit_working_mask.copy()
+        self.edit_original_2d = self.edit_working_mask.copy()
+        
+        # Update status
+        self.edit_status_label.setText(f"✓ Saved! Re-run Photobleaching/Tracking if needed.")
+        self.edit_status_label.setStyleSheet("color: #88ff88; font-weight: bold;")
+        self.statusBar().showMessage(f"✓ Edited mask saved ({source_key})")
+        
+        # Update mask selector to reflect changes
+        self._refresh_edit_mask_selector()
+        # Re-select the mask we just edited
+        for i in range(self.edit_mask_selector.count()):
+            if self.edit_mask_selector.itemData(i) == source_key:
+                self.edit_mask_selector.blockSignals(True)
+                self.edit_mask_selector.setCurrentIndex(i)
+                self.edit_mask_selector.blockSignals(False)
+                break
+        
+        self._update_edit_buttons_state()
+        self.plot_edit_mode()
+    
+    def _apply_edits_to_tyx(self, original_tyx, edited_2d, original_2d):
+        """Apply 2D edits to all frames of a TYX mask.
+        
+        Args:
+            original_tyx: Original TYX mask (T, Y, X)
+            edited_2d: Edited 2D mask (Y, X)
+            original_2d: Original max projection (Y, X)
+        
+        Returns:
+            Modified TYX mask with edits applied to all frames
+        """
+        result = original_tyx.copy()
+        
+        # Find erased pixels (were non-zero in original, now zero)
+        erased = (original_2d > 0) & (edited_2d == 0)
+        
+        # Find painted pixels (changed label)
+        painted = (edited_2d > 0) & (edited_2d != original_2d)
+        
+        # Apply to all frames
+        for t in range(result.shape[0]):
+            # Erase: set to 0 where erased in 2D
+            result[t][erased] = 0
+            
+            # Paint: set to new label where painted in 2D
+            result[t][painted] = edited_2d[painted]
+        
+        return result
+    
+    # =========================================================================
+    # EDIT MODE DISPLAY
+    # =========================================================================
+    
+    def plot_edit_mode(self):
+        """Display the mask being edited overlaid on the selected channel.
+        
+        Uses the same display logic as plot_segmentation() to ensure
+        consistent appearance with channel colors and display parameters.
+        """
+        # Use the figure's subplot instead of clearing the whole figure
+        # to avoid issues with the figure layout
+        self.figure_segmentation.clear()
+        self.ax_segmentation = self.figure_segmentation.add_subplot(111)
+        self.ax_segmentation.set_facecolor('black')
+        
+        if self.image_stack is None:
+            self.ax_segmentation.text(
+                0.5, 0.5, 'No image loaded.',
+                horizontalalignment='center', verticalalignment='center',
+                fontsize=12, color='white', transform=self.ax_segmentation.transAxes
+            )
+            self.ax_segmentation.axis('off')
+            self.canvas_segmentation.draw()
+            return
+        
+        # Get current channel and frame
+        ch = self.segmentation_current_channel
+        
+        # Use registered image if available (same as plot_segmentation)
+        image_to_use = self.get_current_image_source()
+        
+        # Choose image to display (temporal max projection vs current frame, then Z selection)
+        if self.use_max_proj_for_segmentation and self.segmentation_maxproj is not None:
+            # Temporal max projection (already max over T and Z)
+            image_to_display = self.segmentation_maxproj[..., ch]
+        else:
+            # Get current time frame's Z-stack for this channel
+            image_channel = image_to_use[self.segmentation_current_frame, :, :, :, ch]
+            # Apply Z selection
+            if getattr(self, 'segmentation_current_z', -1) == -1:
+                # Max Z-projection (default)
+                image_to_display = np.max(image_channel, axis=0)
+            else:
+                # Specific Z-slice
+                z_idx = min(self.segmentation_current_z, image_channel.shape[0] - 1)
+                image_to_display = image_channel[z_idx, :, :]
+        
+        # Get display parameters for channel (same as plot_segmentation)
+        params = self.channelDisplayParams.get(ch, {
+            'min_percentile': self.display_min_percentile,
+            'max_percentile': self.display_max_percentile,
+            'sigma': self.display_sigma,
+            'low_sigma': self.low_display_sigma
+        })
+        
+        # Convert using per-channel percentiles
+        rescaled_image = mi.Utilities().convert_to_int8(
+            image_to_display,
+            rescale=True,
+            min_percentile=params['min_percentile'],
+            max_percentile=params['max_percentile']
+        )
+        if params['low_sigma'] > 0:
+            rescaled_image = gaussian_filter(rescaled_image, sigma=params['low_sigma'])
+        if params['sigma'] > 0:
+            rescaled_image = gaussian_filter(rescaled_image, sigma=params['sigma'])
+        rescaled_image = mi.Utilities().convert_to_int8(rescaled_image, rescale=False)
+        normalized_image = rescaled_image.astype(np.float32) / 255.0
+        
+        # Use channel colormap (same as plot_segmentation)
+        cmap_used = cmap_list_imagej[ch % len(cmap_list_imagej)]
+        self.ax_segmentation.imshow(normalized_image[..., 0], cmap=cmap_used, vmin=0, vmax=1)
+        
+        # Overlay the working mask with contours
+        if self.edit_working_mask is not None:
+            mask = self.edit_working_mask
+            unique_labels = np.unique(mask)
+            unique_labels = unique_labels[unique_labels > 0]
+            
+            if len(unique_labels) > 0:
+                # Create semi-transparent colored overlay for cells
+                overlay = np.zeros((*mask.shape, 4))
+                
+                # Use tab10 colormap for different cell labels
+                colors = plt.cm.tab10.colors
+                
+                for i, label in enumerate(unique_labels):
+                    color = colors[i % len(colors)]
+                    cell_mask = mask == label
+                    overlay[cell_mask, :3] = color[:3]
+                    overlay[cell_mask, 3] = 0.3  # Alpha (slightly transparent)
+                
+                self.ax_segmentation.imshow(overlay)
+                
+                # Draw white contours around each cell
+                self.ax_segmentation.contour(mask, levels=[0.5], colors='white', linewidths=1.5)
+        
+        # Add axis labels in pixels (same as plot_segmentation)
+        height, width = image_to_display.shape[:2]
+        self.ax_segmentation.set_xlabel('X (pixels)', color='white', fontsize=10)
+        self.ax_segmentation.set_ylabel('Y (pixels)', color='white', fontsize=10)
+        
+        num_x_ticks = 5
+        x_tick_positions = np.linspace(0, width - 1, num_x_ticks)
+        self.ax_segmentation.set_xticks(x_tick_positions)
+        self.ax_segmentation.set_xticklabels([f'{int(pos)}' for pos in x_tick_positions], color='white', fontsize=8)
+        
+        num_y_ticks = 5
+        y_tick_positions = np.linspace(0, height - 1, num_y_ticks)
+        self.ax_segmentation.set_yticks(y_tick_positions)
+        self.ax_segmentation.set_yticklabels([f'{int(pos)}' for pos in y_tick_positions], color='white', fontsize=8)
+        
+        self.ax_segmentation.tick_params(axis='both', colors='white', direction='out', length=4)
+        self.ax_segmentation.spines['bottom'].set_color('white')
+        self.ax_segmentation.spines['left'].set_color('white')
+        self.ax_segmentation.spines['top'].set_visible(False)
+        self.ax_segmentation.spines['right'].set_visible(False)
+        
+        # Add subtle grid lines
+        self.ax_segmentation.grid(True, linewidth=0.3, alpha=0.3, color='white')
+        
+        # Set title
+        if self.edit_current_mask_key:
+            title = f"Editing: {self.edit_current_mask_key.replace('_', ' ').title()}"
+            if self.edit_source_is_tyx:
+                title += " (Max Projection)"
+        else:
+            title = "Select a mask to edit"
+        self.ax_segmentation.set_title(title, color='white', fontsize=10)
+        
+        self.figure_segmentation.tight_layout()
+        self.canvas_segmentation.draw()
+    
+    def _connect_edit_mouse_events(self):
+        """Connect mouse event handlers for edit mode."""
+        # Disconnect any existing handlers
+        self._disconnect_edit_mouse_events()
+        
+        # Connect press, release, and motion events
+        self._edit_cid_press = self.canvas_segmentation.mpl_connect(
+            'button_press_event', self._on_edit_mouse_press)
+        self._edit_cid_release = self.canvas_segmentation.mpl_connect(
+            'button_release_event', self._on_edit_mouse_release)
+        self._edit_cid_motion = self.canvas_segmentation.mpl_connect(
+            'motion_notify_event', self._on_edit_mouse_motion)
+    
+    def _disconnect_edit_mouse_events(self):
+        """Disconnect mouse event handlers for edit mode."""
+        if hasattr(self, '_edit_cid_press') and self._edit_cid_press:
+            self.canvas_segmentation.mpl_disconnect(self._edit_cid_press)
+            self._edit_cid_press = None
+        if hasattr(self, '_edit_cid_release') and self._edit_cid_release:
+            self.canvas_segmentation.mpl_disconnect(self._edit_cid_release)
+            self._edit_cid_release = None
+        if hasattr(self, '_edit_cid_motion') and self._edit_cid_motion:
+            self.canvas_segmentation.mpl_disconnect(self._edit_cid_motion)
+            self._edit_cid_motion = None
+    
+    def _on_edit_mouse_press(self, event):
+        """Handle mouse button press in edit mode (eraser brush only)."""
+        if event.inaxes != self.ax_segmentation:
+            return
+        if event.xdata is None or event.ydata is None:
+            return
+        if not self.edit_mode_active or self.edit_working_mask is None:
+            return
+        
+        x, y = int(event.xdata), int(event.ydata)
+        
+        # Start erasing
+        self.edit_is_drawing = True
+        self.edit_last_mouse_pos = (x, y)
+        
+        # Push undo state at start of stroke
+        self._push_undo("Erase")
+        
+        # Apply first point
+        self._apply_eraser_at(x, y)
+        self.plot_edit_mode()
+    
+    def _on_edit_mouse_release(self, event):
+        """Handle mouse button release in edit mode."""
+        if self.edit_is_drawing:
+            self.edit_is_drawing = False
+            self.edit_last_mouse_pos = None
+            self._update_edit_buttons_state()
+    
+    def _on_edit_mouse_motion(self, event):
+        """Handle mouse motion in edit mode (for eraser drawing)."""
+        if not self.edit_is_drawing:
+            return
+        if event.inaxes != self.ax_segmentation:
+            return
+        if event.xdata is None or event.ydata is None:
+            return
+        if self.edit_working_mask is None:
+            return
+        
+        x, y = int(event.xdata), int(event.ydata)
+        
+        # Apply eraser at new position
+        self._apply_eraser_at(x, y)
+        
+        # Draw line between last position and current for smooth strokes
+        if self.edit_last_mouse_pos:
+            self._apply_eraser_line(self.edit_last_mouse_pos[0], self.edit_last_mouse_pos[1], x, y)
+        
+        self.edit_last_mouse_pos = (x, y)
+        self.plot_edit_mode()
+    
+    def _apply_eraser_at(self, x, y):
+        """Apply eraser brush at given position (sets pixels to background 0).
+        
+        Uses a fixed 10px circular brush.
+        """
+        if self.edit_working_mask is None:
+            return
+        
+        mask = self.edit_working_mask
+        h, w = mask.shape
+        size = 10  # Fixed brush size
+        
+        # Create circular brush mask
+        yy, xx = np.ogrid[:h, :w]
+        brush_mask = ((xx - x) ** 2 + (yy - y) ** 2) <= (size / 2) ** 2
+        
+        # Erase: set pixels to background (0)
+        mask[brush_mask] = 0
+    
+    def _apply_eraser_line(self, x0, y0, x1, y1):
+        """Apply eraser along a line between two points for smooth strokes."""
+        from skimage.draw import line
+        
+        rr, cc = line(y0, x0, y1, x1)
+        
+        for r, c in zip(rr, cc):
+            self._apply_eraser_at(c, r)
+
+
 # =============================================================================
 # =============================================================================
 # PHOTOBLEACHING TAB
@@ -9054,7 +10008,7 @@ class GUI(QMainWindow):
         # Cluster radius
         self.cluster_radius_input = QSpinBox()
         self.cluster_radius_input.setMinimum(100)
-        self.cluster_radius_input.setMaximum(2000)
+        self.cluster_radius_input.setMaximum(6000)
         self.cluster_radius_input.setValue(self.cluster_radius_nm)
         self.cluster_radius_input.valueChanged.connect(self.update_cluster_radius)
         params_layout.addRow("Cluster radius (nm):", self.cluster_radius_input)
@@ -10691,7 +11645,7 @@ class GUI(QMainWindow):
         }
         
         if display_crop is not None and display_flags is not None:
-            self.display_colocalization_results(display_crop, crop_size, display_flags, ch1, ch2)
+            self.display_colocalization_results(display_crop, crop_size, display_flags, ch1, ch2, auto_columns=True)
         self.extract_colocalization_data(save_df=False)
     
     def _compute_coloc_flags(self, mean_crop, crop_size, ch2, method, threshold):
@@ -10776,20 +11730,34 @@ class GUI(QMainWindow):
 
 
 
-    def display_colocalization_results(self, mean_crop, crop_size, flag_vector, ch1, ch2):
-        """Display the colocalization result using provided crop data."""
+    def display_colocalization_results(self, mean_crop, crop_size, flag_vector, ch1, ch2, auto_columns=False):
+        """Display the colocalization result using provided crop data.
+        
+        Args:
+            mean_crop: Cropped spot images
+            crop_size: Size of each crop
+            flag_vector: Boolean vector indicating colocalization status
+            ch1: Reference channel index
+            ch2: Colocalize channel index
+            auto_columns: If True, auto-calculate optimal columns and update spinbox.
+                         If False (default), use current spinbox value.
+        """
         self.figure_colocalization.clear()
         title = f"Colocalization: {self.colocalization_results['colocalization_percentage']:.2f}%"
         
-        # Auto-calculate optimal number of columns based on spot count
-        n_spots = len(flag_vector) if flag_vector is not None else 0
-        optimal_cols = self._calculate_optimal_coloc_columns(n_spots)
-        
-        # Update the spinbox to reflect the auto-calculated value
-        if hasattr(self, 'columns_spinbox'):
-            self.columns_spinbox.blockSignals(True)
-            self.columns_spinbox.setValue(optimal_cols)
-            self.columns_spinbox.blockSignals(False)
+        # Determine number of columns to use
+        if auto_columns:
+            # Auto-calculate optimal number of columns based on spot count
+            n_spots = len(flag_vector) if flag_vector is not None else 0
+            num_cols = self._calculate_optimal_coloc_columns(n_spots)
+            # Update the spinbox to reflect the auto-calculated value
+            if hasattr(self, 'columns_spinbox'):
+                self.columns_spinbox.blockSignals(True)
+                self.columns_spinbox.setValue(num_cols)
+                self.columns_spinbox.blockSignals(False)
+        else:
+            # Use user's current spinbox value
+            num_cols = self.columns_spinbox.value() if hasattr(self, 'columns_spinbox') else 20
         
         self.plots.plot_matrix_pair_crops(
             mean_crop=mean_crop,
@@ -10798,7 +11766,7 @@ class GUI(QMainWindow):
             selected_channels=(ch1, ch2),
             figure=self.figure_colocalization,
             crop_spacing=5,
-            number_columns=optimal_cols,
+            number_columns=num_cols,
             plot_title=title
         )
         try:
@@ -10845,6 +11813,26 @@ class GUI(QMainWindow):
             optimal = min(200, 120 + int((n_spots - 5000) * 80 / 10000))
         
         return optimal
+    
+    def _on_coloc_columns_changed(self, value):
+        """Handle user change to the Crop Columns spinbox.
+        
+        Redraws the colocalization display with the new column count.
+        Only triggers if colocalization results exist.
+        """
+        if not self.colocalization_results:
+            return
+        
+        # Redraw with user's selected column count (auto_columns=False by default)
+        self.display_colocalization_results(
+            self.colocalization_results['mean_crop_filtered'],
+            self.colocalization_results['crop_size'],
+            self.colocalization_results['flag_vector'],
+            self.colocalization_results['ch1_index'],
+            self.colocalization_results['ch2_index'],
+            auto_columns=False
+        )
+        self.canvas_colocalization.draw()
 
 
     # Note: display_colocalization_manual() removed - replaced by separate 
@@ -11376,8 +12364,9 @@ class GUI(QMainWindow):
         columnsLayout.addWidget(QLabel("Columns:"))
         self.columns_spinbox = QSpinBox()
         self.columns_spinbox.setRange(4, 200)
-        self.columns_spinbox.setValue(20)  # Auto-adjusted when running
-        self.columns_spinbox.setToolTip("Auto-adjusted based on spot count (larger = wider image)")
+        self.columns_spinbox.setValue(20)  # Auto-adjusted on first run, then user-controlled
+        self.columns_spinbox.setToolTip("Adjust number of columns in crop display. Auto-set on first run.")
+        self.columns_spinbox.valueChanged.connect(self._on_coloc_columns_changed)
         columnsLayout.addWidget(self.columns_spinbox)
         top_layout.addWidget(columnsGroup)
         actionsGroup = QGroupBox("Actions")
@@ -11701,9 +12690,13 @@ class GUI(QMainWindow):
         layout = QVBoxLayout(self.coloc_verify_distance_widget)
         layout.setContentsMargins(10, 5, 10, 5)
         
-        # Info label
-        info_label = QLabel("Review and correct Distance-based colocalization results:")
+        # Info label explaining what is displayed
+        info_label = QLabel(
+            "Review unique particle tracks. Each row shows a time-averaged crop. "
+            "A track is marked colocalized (✓) if ANY frame is within the distance threshold."
+        )
         info_label.setStyleSheet("font-style: italic; color: #999;")
+        info_label.setWordWrap(True)
         layout.addWidget(info_label)
         
         # Top bar with stats and buttons
@@ -12553,6 +13546,9 @@ class GUI(QMainWindow):
             channels=(ch1, ch2)
         )
         
+        # Reset sorted flag so Sort button can be used
+        self._verify_visual_sorted = False
+        
         # Update stats label
         self._update_verify_visual_stats()
     
@@ -12570,20 +13566,76 @@ class GUI(QMainWindow):
         )
     
     def sort_verify_visual(self):
-        """Sort Verify Visual results by prediction value (lowest to highest)."""
+        """Sort Verify Visual results by prediction value (lowest to highest for review)."""
         if not hasattr(self, 'verify_visual_checkboxes') or len(self.verify_visual_checkboxes) == 0:
+            QMessageBox.information(self, "No Data", "No spots to sort. Please click Populate first.")
             return
         
-        values = self.colocalization_results.get('prediction_values_vector') if hasattr(self, 'colocalization_results') else None
+        if not hasattr(self, 'colocalization_results') or not self.colocalization_results:
+            QMessageBox.warning(self, "No Results", "No colocalization results available.")
+            return
+        
+        results = self.colocalization_results
+        values = results.get('prediction_values_vector')
+        mean_crop = results.get('mean_crop_filtered')
+        crop_size = results.get('crop_size', 15)
+        flag_vector = results.get('flag_vector')
+        ch1 = results.get('ch1_index', 0)
+        ch2 = results.get('ch2_index', 1)
+        
         if values is None or len(values) == 0:
             QMessageBox.information(self, "Cannot Sort", "No prediction values available for sorting.")
             return
         
-        # Re-populate with sorted order would require rebuilding crops
-        # For now, show a message that sorting is based on visual arrangement
-        QMessageBox.information(self, "Sort", 
-            "Spots are already displayed in their original detection order. "
-            "Lower prediction values indicate uncertain colocalization.")
+        if mean_crop is None:
+            QMessageBox.warning(self, "No Data", "Crop data not available for sorting.")
+            return
+        
+        # Check if already sorted (compare to original order)
+        if hasattr(self, '_verify_visual_sorted') and self._verify_visual_sorted:
+            QMessageBox.information(self, "Already Sorted", "Spots are already sorted by prediction value.")
+            return
+        
+        # Get current checkbox states before sorting
+        current_states = [chk.isChecked() for chk in self.verify_visual_checkboxes]
+        
+        # Create sorted indices (ascending by prediction value - uncertain first)
+        num_spots = len(values)
+        sorted_indices = np.argsort(values)
+        
+        # Re-order checkbox states to match new sort order
+        sorted_states = [current_states[i] if i < len(current_states) else False for i in sorted_indices]
+        
+        # Re-order crops - each spot is crop_size rows in the mean_crop array
+        num_crop_spots = mean_crop.shape[0] // crop_size
+        if num_crop_spots < num_spots:
+            num_spots = num_crop_spots
+            sorted_indices = sorted_indices[:num_spots]
+        
+        sorted_crop = np.zeros_like(mean_crop[:num_spots*crop_size])
+        for new_idx, old_idx in enumerate(sorted_indices[:num_spots]):
+            if old_idx < num_crop_spots:
+                sorted_crop[new_idx*crop_size:(new_idx+1)*crop_size] = \
+                    mean_crop[old_idx*crop_size:(old_idx+1)*crop_size]
+        
+        # Re-create verification crops with sorted data
+        self._create_verification_crops(
+            scroll_area=self.verify_visual_scroll_area,
+            checkboxes_list_attr='verify_visual_checkboxes',
+            mean_crop=sorted_crop,
+            crop_size=crop_size,
+            flag_vector=sorted_states,  # Use previously checked states after reorder
+            stats_label=self.verify_visual_stats_label,
+            num_channels=2,
+            channels=(ch1, ch2)
+        )
+        
+        # Mark as sorted
+        self._verify_visual_sorted = True
+        self._verify_visual_sort_indices = sorted_indices
+        
+        # Update stats
+        self._update_verify_visual_stats()
     
     def cleanup_verify_visual(self):
         """Clear all checkboxes in Verify Visual subtab."""
@@ -12630,7 +13682,11 @@ class GUI(QMainWindow):
     # === Verify Distance Subtab Methods ===
     
     def populate_verify_distance(self):
-        """Populate the Verify Distance subtab with Distance colocalization results."""
+        """Populate the Verify Distance subtab with Distance colocalization results.
+        
+        Calculates and stores the minimum distance from each reference channel spot
+        to its nearest partner in the target channel for sorting purposes.
+        """
         if not hasattr(self, 'distance_coloc_results') or not self.distance_coloc_results:
             QMessageBox.warning(self, "No Results", 
                 "Please run Distance colocalization first.")
@@ -12641,8 +13697,10 @@ class GUI(QMainWindow):
         ch0 = results.get('channel_0', 0)
         ch1 = results.get('channel_1', 1)
         df_coloc = results.get('df_colocalized', pd.DataFrame())
+        df_ch1_all = results.get('df_ch1_all', pd.DataFrame())
         threshold_px = results.get('threshold_distance_px', 2.0)
         threshold_nm = results.get('threshold_distance_nm', 130.0)
+        use_3d = results.get('use_3d', False)
         
         # We need to create crops from tracking data
         if not hasattr(self, 'df_tracking') or self.df_tracking.empty:
@@ -12684,28 +13742,129 @@ class GUI(QMainWindow):
         
         num_spots = mean_crop.shape[0] // crop_size
         
-        # Create flag vector based on distance colocalization
-        # Mark spots as colocalized if their coordinates match
-        coloc_coords = set()
+        # Build set of colocalized coordinates for matching
+        # Use a tolerance-based approach instead of exact coordinate matching
+        coloc_coords_array = np.empty((0, 4))  # z, y, x, cell_id
         if not df_coloc.empty:
-            for _, row in df_coloc.iterrows():
-                coord = (round(row.get('x', 0), 1), round(row.get('y', 0), 1))
-                coloc_coords.add(coord)
-        
+            if 'z' in df_coloc.columns and use_3d:
+                coloc_coords_array = df_coloc[['z', 'y', 'x', 'cell_id']].values
+            else:
+                # Add dummy z=0 for 2D matching
+                coloc_coords_array = np.column_stack([
+                    np.zeros(len(df_coloc)),
+                    df_coloc['y'].values,
+                    df_coloc['x'].values,
+                    df_coloc['cell_id'].values
+                ])
+        
+        # Calculate minimum distances for each spot in ch0 to nearest spot in ch1
+        # This will be used for sorting (ascending = closest to threshold = most uncertain)
+        distance_values = []
         flag_vector = []
-        for i, (_, row) in enumerate(df_ch0.drop_duplicates(subset=['particle']).iterrows()):
+        
+        # Get ch1 coordinates for distance calculation
+        ch1_coords = None
+        if not df_ch1_all.empty and 'x' in df_ch1_all.columns and 'y' in df_ch1_all.columns:
+            if use_3d and 'z' in df_ch1_all.columns:
+                ch1_coords = df_ch1_all[['z', 'y', 'x']].values
+            else:
+                ch1_coords = df_ch1_all[['y', 'x']].values
+        
+        # Get anisotropic scaling for 3D
+        voxel_z_nm = results.get('voxel_z_nm', 300.0)
+        voxel_xy_nm = results.get('voxel_xy_nm', 130.0)
+        z_scale = voxel_z_nm / voxel_xy_nm if use_3d and voxel_xy_nm > 0 else 1.0
+        
+        # Use the same particle column identification as CropArray
+        # This ensures our iteration matches the crop order
+        df_ch0_copy = df_ch0.copy()
+        if 'unique_particle' in df_ch0_copy.columns:
+            particle_col = 'unique_particle'
+        elif 'cell_id' in df_ch0_copy.columns:
+            if 'spot_type' in df_ch0_copy.columns:
+                df_ch0_copy['unique_particle'] = (
+                    df_ch0_copy['cell_id'].astype(str) + '_' +
+                    df_ch0_copy['spot_type'].astype(str) + '_' +
+                    df_ch0_copy['particle'].astype(str)
+                )
+            else:
+                df_ch0_copy['unique_particle'] = (
+                    df_ch0_copy['cell_id'].astype(str) + '_' +
+                    df_ch0_copy['particle'].astype(str)
+                )
+            particle_col = 'unique_particle'
+        else:
+            particle_col = 'particle'
+        
+        # Helper function to check if a spot coordinate is in the colocalized set
+        def is_coord_colocalized(z, y, x, cell_id, coloc_arr, tolerance=1.0):
+            """Check if a spot is in the colocalized set using coordinate tolerance."""
+            if len(coloc_arr) == 0:
+                return False
+            # Filter by cell_id first for efficiency
+            cell_mask = coloc_arr[:, 3].astype(int) == int(cell_id)
+            cell_coloc = coloc_arr[cell_mask]
+            if len(cell_coloc) == 0:
+                return False
+            # Check distance to each colocalized spot
+            for cz, cy, cx, _ in cell_coloc:
+                dist_xy = np.sqrt((x - cx)**2 + (y - cy)**2)
+                dist_z = abs(z - cz) if use_3d else 0
+                if dist_xy <= tolerance and dist_z <= tolerance:
+                    return True
+            return False
+        
+        # Iterate unique particles in the same order as CropArray
+        unique_particles = df_ch0_copy[particle_col].unique()
+        
+        for i, particle_id in enumerate(unique_particles):
             if i >= num_spots:
                 break
-            coord = (round(row.get('x', 0), 1), round(row.get('y', 0), 1))
-            flag_vector.append(coord in coloc_coords)
+            
+            df_particle = df_ch0_copy[df_ch0_copy[particle_col] == particle_id]
+            
+            # Check if ANY observation of this particle is colocalized
+            is_coloc = False
+            min_dist_all = threshold_px * 10.0  # Large default
+            
+            for _, row in df_particle.iterrows():
+                x_val, y_val = row['x'], row['y']
+                z_val = row.get('z', 0)
+                cell_id = row.get('cell_id', 0)
+                
+                # Check if this observation is in the colocalized set
+                if len(coloc_coords_array) > 0:
+                    if is_coord_colocalized(z_val, y_val, x_val, cell_id, coloc_coords_array, tolerance=1.0):
+                        is_coloc = True
+                
+                # Calculate minimum distance to any ch1 spot for this observation
+                if ch1_coords is not None and len(ch1_coords) > 0:
+                    if use_3d and ch1_coords.shape[1] == 3:
+                        spot_coord = np.array([[z_val * z_scale, y_val, x_val]])
+                        ch1_scaled = ch1_coords.copy().astype(float)
+                        ch1_scaled[:, 0] = ch1_scaled[:, 0] * z_scale  # Scale Z
+                    else:
+                        spot_coord = np.array([[y_val, x_val]])
+                        ch1_scaled = ch1_coords
+                    
+                    from scipy.spatial.distance import cdist
+                    distances = cdist(spot_coord, ch1_scaled, metric='euclidean')
+                    obs_min_dist = float(np.min(distances))
+                    if obs_min_dist < min_dist_all:
+                        min_dist_all = obs_min_dist
+            
+            flag_vector.append(is_coloc)
+            distance_values.append(min_dist_all)
         
-        # Pad flag_vector if needed
+        # Pad vectors if needed (shouldn't happen, but just in case)
         while len(flag_vector) < num_spots:
             flag_vector.append(False)
+            distance_values.append(threshold_px * 10.0)
         
-        # Store for later use
+        # Store for later use (sorting, etc.)
         self.verify_distance_mean_crop = mean_crop
         self.verify_distance_crop_size = crop_size
+        self.verify_distance_values = np.array(distance_values)  # For sorting by distance
         
         # Create spot crops with checkboxes
         self._create_verification_crops(
@@ -12719,6 +13878,9 @@ class GUI(QMainWindow):
             channels=(ch0, ch1)
         )
         
+        # Reset sorted flag so Sort button can be used
+        self._verify_distance_sorted = False
+        
         # Update stats label
         self._update_verify_distance_stats()
     
@@ -12743,9 +13905,88 @@ class GUI(QMainWindow):
             )
     
     def sort_verify_distance(self):
-        """Sort Verify Distance results (by cell ID or coordinate)."""
-        QMessageBox.information(self, "Sort", 
-            "Distance colocalization spots are displayed in detection order.")
+        """Sort Verify Distance results by distance value (ascending - closest to threshold first).
+        
+        Similar to Visual method's certainty-based sorting, but uses the measured
+        distance to nearest partner. Spots with distances closest to the colocalization
+        threshold are shown first as they represent the most uncertain classifications.
+        """
+        if not hasattr(self, 'verify_distance_checkboxes') or len(self.verify_distance_checkboxes) == 0:
+            QMessageBox.information(self, "No Data", "No spots to sort. Please click Populate first.")
+            return
+        
+        if not hasattr(self, 'verify_distance_mean_crop') or self.verify_distance_mean_crop is None:
+            QMessageBox.warning(self, "No Data", "Crop data not available for sorting.")
+            return
+        
+        # Check if distance values are available
+        if not hasattr(self, 'verify_distance_values') or self.verify_distance_values is None:
+            QMessageBox.warning(self, "No Distance Data", 
+                "Distance values not available. Please re-run Populate.")
+            return
+        
+        # Check if already sorted
+        if hasattr(self, '_verify_distance_sorted') and self._verify_distance_sorted:
+            QMessageBox.information(self, "Already Sorted", "Spots are already sorted by distance value.")
+            return
+        
+        mean_crop = self.verify_distance_mean_crop
+        crop_size = self.verify_distance_crop_size
+        distance_values = self.verify_distance_values
+        
+        # Get current checkbox states before sorting
+        current_states = [chk.isChecked() for chk in self.verify_distance_checkboxes]
+        num_spots = len(current_states)
+        
+        # Sort ascending by distance (closest to threshold = most uncertain first)
+        # This matches the Visual method's approach of showing uncertain cases first
+        sorted_indices = np.argsort(distance_values)
+        
+        # Re-order states and distances
+        sorted_states = [current_states[i] if i < len(current_states) else False for i in sorted_indices]
+        sorted_distances = distance_values[sorted_indices]
+        
+        # Re-order crops
+        num_crop_spots = mean_crop.shape[0] // crop_size
+        if num_crop_spots < num_spots:
+            num_spots = num_crop_spots
+            sorted_indices = sorted_indices[:num_spots]
+        
+        sorted_crop = np.zeros_like(mean_crop[:num_spots*crop_size])
+        for new_idx, old_idx in enumerate(sorted_indices[:num_spots]):
+            if old_idx < num_crop_spots:
+                sorted_crop[new_idx*crop_size:(new_idx+1)*crop_size] = \
+                    mean_crop[old_idx*crop_size:(old_idx+1)*crop_size]
+        
+        # Get channels from distance results
+        results = self.distance_coloc_results if hasattr(self, 'distance_coloc_results') else {}
+        ch0 = results.get('channel_0', 0)
+        ch1 = results.get('channel_1', 1)
+        image = self.corrected_image if self.corrected_image is not None else self.image_stack
+        num_channels = image.shape[-1] if image is not None and image.ndim == 5 else 1
+        
+        # Re-create verification crops with sorted data
+        self._create_verification_crops(
+            scroll_area=self.verify_distance_scroll_area,
+            checkboxes_list_attr='verify_distance_checkboxes',
+            mean_crop=sorted_crop,
+            crop_size=crop_size,
+            flag_vector=sorted_states,
+            stats_label=self.verify_distance_stats_label,
+            num_channels=num_channels,
+            channels=(ch0, ch1)
+        )
+        
+        # Update stored data after sorting for consistency
+        self.verify_distance_mean_crop = sorted_crop
+        self.verify_distance_values = sorted_distances
+        self._verify_distance_sort_indices = sorted_indices  # Store for reference
+        
+        # Mark as sorted
+        self._verify_distance_sorted = True
+        
+        # Update stats
+        self._update_verify_distance_stats()
     
     def cleanup_verify_distance(self):
         """Clear all checkboxes in Verify Distance subtab."""
@@ -12833,7 +14074,12 @@ class GUI(QMainWindow):
             
             # Checkbox
             chk = QCheckBox(f"Spot {i+1}")
-            chk.setChecked(bool(flag_vector[i]) if i < len(flag_vector) else False)
+            # Safely get the flag value (handle numpy arrays, lists, etc.)
+            try:
+                flag_val = bool(flag_vector[i]) if i < len(flag_vector) else False
+            except (TypeError, IndexError):
+                flag_val = False
+            chk.setChecked(flag_val)
             chk.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
             
             # Connect to stats update
@@ -12897,7 +14143,18 @@ class GUI(QMainWindow):
                     spot_coord = (int(dfm.iloc[0]['y']), int(dfm.iloc[0]['x']))
                     found_spot = True
                 else:
-                    spot_coord = (0, 0)
+                    # Particle not in current frame - jump to first valid frame for this particle
+                    df_particle = self.df_tracking[self.df_tracking[particle_col] == pid]
+                    if not df_particle.empty:
+                        first_frame = int(df_particle['frame'].min())
+                        self.current_frame = first_frame
+                        if hasattr(self, 'time_slider_tracking_vis'):
+                            self.time_slider_tracking_vis.setValue(first_frame)
+                        dfm = df_particle[df_particle['frame'] == first_frame]
+                        spot_coord = (int(dfm.iloc[0]['y']), int(dfm.iloc[0]['x']))
+                        found_spot = True
+                    else:
+                        spot_coord = (0, 0)
             else:
                 spot_coord = (0, 0)
         else:
@@ -12956,7 +14213,12 @@ class GUI(QMainWindow):
         else:
             main_img = norm_stack[selected_channelIndex]
             main_cmap = cmap_list_imagej[selected_channelIndex % len(cmap_list_imagej)]
-        gs = fig.add_gridspec(1, 2, width_ratios=[3, 2], hspace=0.1, wspace=0.1)
+        
+        # Always show 3D intensity profile for spot quality assessment
+        show_3d_profile = True
+        
+        # 3-column layout: main image + 2D crops + 3D surfaces
+        gs = fig.add_gridspec(1, 3, width_ratios=[3, 1, 1.5], hspace=0.1, wspace=0.15)
         ax_main = fig.add_subplot(gs[0, 0])
         
         # Store main axes reference and recreate RectangleSelector
@@ -12972,8 +14234,15 @@ class GUI(QMainWindow):
             props=dict(facecolor='cyan', edgecolor='white', alpha=0.3, linewidth=2)
         )
         
+        # 2D crop subgrid
         gs2 = gs[0, 1].subgridspec(C, 1, hspace=0.1)
-        axes_zoom = [fig.add_subplot(gs2[i, 0]) for i in range(C)]        
+        axes_zoom = [fig.add_subplot(gs2[i, 0]) for i in range(C)]
+        
+        # 3D profile subgrid (only create if enabled)
+        axes_3d = []
+        if show_3d_profile:
+            gs3 = gs[0, 2].subgridspec(C, 1, hspace=0.15)
+            axes_3d = [fig.add_subplot(gs3[i, 0], projection='3d') for i in range(C)]        
         # remove background if requested
         if hasattr(self, 'checkbox_remove_bg') and self.checkbox_remove_bg.isChecked():
             seg_mask = getattr(self, 'segmentation_mask', None)
@@ -13027,6 +14296,15 @@ class GUI(QMainWindow):
             rect = patches.Rectangle((x0, y0), crop_sz, crop_sz, edgecolor='white', facecolor='none', linewidth=2)
             ax_main.add_patch(rect)
         ax_main.axis('off')
+        
+        # Add thin border to show image boundaries (matching Tracking tab style)
+        # Use -0.5 origin and full size to place border outside the image
+        if self.image_stack is not None:
+            img_H, img_W = main_img.shape[:2]
+            img_border = patches.Rectangle((-0.5, -0.5), img_W, img_H, linewidth=0.8, 
+                                            edgecolor='#555555', facecolor='none', linestyle='-')
+            ax_main.add_patch(img_border)
+        
         for ci, ax in enumerate(axes_zoom):
             if found_spot:
                 crop = norm_stack[ci, y0:y1, x0:x1]
@@ -13034,6 +14312,59 @@ class GUI(QMainWindow):
                 crop = np.zeros((crop_sz, crop_sz))
             ax.imshow(crop, cmap=cmap_list_imagej[ci % len(cmap_list_imagej)], interpolation='nearest', vmin=0, vmax=1)
             ax.axis('off')
+            # Add gray frame border to 2D crops using Rectangle (spines hidden by axis('off'))
+            # Use -0.5 origin and full size to place border outside the image (matplotlib centers pixels at integers)
+            crop_h, crop_w = crop.shape[:2]
+            crop_border = patches.Rectangle((-0.5, -0.5), crop_w, crop_h, linewidth=0.8, 
+                                              edgecolor='#555555', facecolor='none', linestyle='-')
+            ax.add_patch(crop_border)
+        
+        # Render 3D intensity profiles if enabled
+        if show_3d_profile and axes_3d:
+            # Create meshgrid for surface plot (only once, using crop dimensions)
+            crop_example = norm_stack[0, y0:y1, x0:x1] if found_spot else np.zeros((crop_sz, crop_sz))
+            Y_grid, X_grid = np.meshgrid(np.arange(crop_example.shape[0]), 
+                                          np.arange(crop_example.shape[1]), indexing='ij')
+            
+            for ci, ax3d in enumerate(axes_3d):
+                if found_spot:
+                    crop = norm_stack[ci, y0:y1, x0:x1]
+                else:
+                    crop = np.zeros((crop_sz, crop_sz))
+                
+                # Get channel colormap
+                cmap = cmap_list_imagej[ci % len(cmap_list_imagej)]
+                
+                # Plot surface with matching colormap
+                ax3d.plot_surface(X_grid, Y_grid, crop, cmap=cmap, 
+                                   edgecolor='none', alpha=0.9, antialiased=True)
+                
+                # Style the 3D axes for dark theme
+                ax3d.set_facecolor('black')
+                ax3d.set_xlabel('X', fontsize=7, color='white', labelpad=-2)
+                ax3d.set_ylabel('Y', fontsize=7, color='white', labelpad=-2)
+                ax3d.set_zlabel('I', fontsize=7, color='white', labelpad=-2)
+                ax3d.tick_params(axis='both', which='major', labelsize=5, colors='white', pad=0)
+                ax3d.tick_params(axis='z', which='major', labelsize=5, colors='white', pad=0)
+                
+                # Set consistent Z limits for comparison across channels
+                ax3d.set_zlim(0, 1)
+                
+                # Make pane and grid styling match dark theme
+                ax3d.xaxis.pane.fill = False
+                ax3d.yaxis.pane.fill = False
+                ax3d.zaxis.pane.fill = False
+                ax3d.xaxis.pane.set_edgecolor('gray')
+                ax3d.yaxis.pane.set_edgecolor('gray')
+                ax3d.zaxis.pane.set_edgecolor('gray')
+                ax3d.grid(True, alpha=0.3, color='gray')
+                
+                # Add channel label
+                ax3d.set_title(f'Ch{ci}', fontsize=8, color='white', pad=-5)
+                
+                # Set viewing angle for nice perspective
+                ax3d.view_init(elev=25, azim=-45)
+        
         fig.tight_layout()
         
         # Add thin white frame border to main image
@@ -14771,6 +16102,21 @@ class GUI(QMainWindow):
             self.watershed_size_slider.blockSignals(False)
         if hasattr(self, 'watershed_size_label'):
             self.watershed_size_label.setText("0")
+        
+        # Reset Edit tab state
+        self.edit_mode_active = False
+        self.edit_working_mask = None
+        self.edit_original_mask = None
+        self.edit_current_mask_key = None
+        self.edit_undo_stack = []
+        if hasattr(self, '_disconnect_edit_mouse_events'):
+            self._disconnect_edit_mouse_events()
+        if hasattr(self, 'edit_mask_selector'):
+            self.edit_mask_selector.blockSignals(True)
+            self.edit_mask_selector.setCurrentIndex(0)
+            self.edit_mask_selector.blockSignals(False)
+        if hasattr(self, 'edit_instructions_group'):
+            self.edit_instructions_group.setVisible(False)
 
     def reset_photobleaching_tab(self):
         self.figure_photobleaching.clear()
@@ -15475,6 +16821,7 @@ class GUI(QMainWindow):
             self.verify_visual_checkboxes = []
         if hasattr(self, 'verify_visual_stats_label'):
             self.verify_visual_stats_label.setText("Run Visual colocalization first, then click Populate")
+        self._verify_visual_sorted = False
         
         # Reset Verify Distance
         if hasattr(self, 'verify_distance_scroll_area'):
@@ -15483,6 +16830,11 @@ class GUI(QMainWindow):
             self.verify_distance_checkboxes = []
         if hasattr(self, 'verify_distance_stats_label'):
             self.verify_distance_stats_label.setText("Run Distance colocalization first, then click Populate")
+        # Reset stored distance data for sorting
+        self.verify_distance_mean_crop = None
+        self.verify_distance_crop_size = None
+        self.verify_distance_values = None
+        self._verify_distance_sorted = False
 
     def reset_cellpose_tab(self):
         """Reset Cellpose tab state, masks, and UI controls to defaults."""
@@ -15544,6 +16896,8 @@ class GUI(QMainWindow):
             self.chk_remove_border_cells.setChecked(False)
         if hasattr(self, 'chk_remove_unpaired_cells'):
             self.chk_remove_unpaired_cells.setChecked(False)
+        if hasattr(self, 'chk_keep_center_cell'):
+            self.chk_keep_center_cell.setChecked(False)
         
         # Refresh the shared segmentation display
         # (Cellpose now shares the segmentation canvas, so just refresh it)