coralnet-toolbox 0.0.68__py2.py3-none-any.whl → 0.0.70__py2.py3-none-any.whl

coralnet_toolbox/Explorer/QtFeatureStore.py

@@ -0,0 +1,176 @@
+import os
+import glob
+import sqlite3
+import warnings
+
+import faiss
+
+warnings.filterwarnings("ignore", category=DeprecationWarning)
+
+
+# ----------------------------------------------------------------------------------------------------------------------
+# Viewers
+# ----------------------------------------------------------------------------------------------------------------------
+
+
+class FeatureStore:
+    """
+    Manages storing and retrieving annotation features for MULTIPLE models
+    using a single SQLite database and multiple, model-specific FAISS indexes.
+    """
+    def __init__(self, db_path='feature_store.db', index_path_base='features'):
+        self.db_path = db_path
+        self.index_path_base = index_path_base  # Base name for index files, e.g., 'features'
+        self.conn = sqlite3.connect(self.db_path)
+        self.cursor = self.conn.cursor()
+        self._create_table()
+
+        # A dictionary to hold multiple FAISS indexes, keyed by model_key
+        self.faiss_indexes = {}
+
+    def _create_table(self):
+        """Create the metadata table if it doesn't exist."""
+        self.cursor.execute('''
+            CREATE TABLE IF NOT EXISTS features (
+                annotation_id TEXT NOT NULL,
+                model_key TEXT NOT NULL,
+                faiss_index INTEGER NOT NULL,
+                PRIMARY KEY (annotation_id, model_key)
+            )
+        ''')
+        self.conn.commit()
+
+    def _get_or_load_index(self, model_key):
+        """
+        Retrieves an index from memory or loads it from disk if it exists.
+        Returns the index object or None if not found in memory or on disk.
+        """
+        # 1. Check if the index is already loaded in memory
+        if model_key in self.faiss_indexes:
+            return self.faiss_indexes[model_key]
+
+        # 2. If not in memory, check for a corresponding file on disk
+        index_path = f"{self.index_path_base}_{model_key}.faiss"
+        if os.path.exists(index_path):
+            print(f"Loading existing FAISS index from {index_path}")
+            index = faiss.read_index(index_path)
+            self.faiss_indexes[model_key] = index  # Cache it in memory
+            return index
+
+        # 3. If not in memory or on disk, return None
+        return None
+
+    def add_features(self, data_items, features, model_key):
+        """
+        Adds new features to the store for a specific model.
+        """
+        if not len(features):
+            return
+
+        # Get the specific index for this model, loading it if necessary
+        index = self._get_or_load_index(model_key)
+
+        # If no index exists yet, create one
+        if index is None:
+            feature_dim = features.shape[1]
+            print(f"Creating new FAISS index for model '{model_key}' with dimension {feature_dim}.")
+            index = faiss.IndexFlatL2(feature_dim)
+            self.faiss_indexes[model_key] = index
+
+        # Add vectors to the specific FAISS index
+        start_index = index.ntotal
+        index.add(features.astype('float32'))
+
+        # Add metadata to SQLite. The table already supports multiple models.
+        for i, item in enumerate(data_items):
+            faiss_row_index = start_index + i
+            self.cursor.execute(
+                "INSERT OR REPLACE INTO features (annotation_id, model_key, faiss_index) VALUES (?, ?, ?)",
+                (item.annotation.id, model_key, faiss_row_index)
+            )
+        self.conn.commit()
+        self.save_faiss_index(model_key)  # Save the specific index that was modified
+
+    def get_features(self, data_items, model_key):
+        """
+        Retrieves features for given data items and a specific model.
+        """
+        # Get the specific index for this model
+        index = self._get_or_load_index(model_key)
+
+        if index is None:
+            # No features have ever been stored for this model
+            return {}, data_items
+
+        found_features = {}
+        not_found_items = []
+
+        ids_to_query = [item.annotation.id for item in data_items]
+
+        # Query SQLite for the given model_key
+        placeholders = ','.join('?' for _ in ids_to_query)
+        query = (f"SELECT annotation_id, faiss_index FROM features "
+                 f"WHERE model_key=? AND annotation_id IN ({placeholders})")
+        params = [model_key] + ids_to_query
+        self.cursor.execute(query, params)
+
+        faiss_map = {ann_id: faiss_idx for ann_id, faiss_idx in self.cursor.fetchall()}
+
+        if not faiss_map:
+            return {}, data_items
+
+        # Reconstruct vectors from the correct FAISS index
+        faiss_indices = list(faiss_map.values())
+        retrieved_vectors = index.reconstruct_batch(faiss_indices)
+
+        id_to_vector = {ann_id: retrieved_vectors[i] for i, ann_id in enumerate(faiss_map.keys())}
+
+        for item in data_items:
+            ann_id = item.annotation.id
+            if ann_id in id_to_vector:
+                found_features[ann_id] = id_to_vector[ann_id]
+            else:
+                not_found_items.append(item)
+
+        return found_features, not_found_items
+
+    def get_faiss_index_to_annotation_id_map(self, model_key):
+        """
+        Retrieves a mapping from FAISS row index to annotation_id for a given model.
+        """
+        query = "SELECT faiss_index, annotation_id FROM features WHERE model_key = ?"
+        self.cursor.execute(query, (model_key,))
+        return {faiss_idx: ann_id for faiss_idx, ann_id in self.cursor.fetchall()}
+
+    def save_faiss_index(self, model_key):
+        """Saves a specific FAISS index to disk."""
+        if model_key in self.faiss_indexes:
+            index_to_save = self.faiss_indexes[model_key]
+            index_path = f"{self.index_path_base}_{model_key}.faiss"
+            print(f"Saving FAISS index for '{model_key}' to {index_path}")
+            faiss.write_index(index_to_save, index_path)
+
+    def close(self):
+        """Closes the database connection."""
+        self.conn.close()
+
+    def delete_storage(self):
+        """
+        Closes connection and deletes the DB and ALL FAISS index files.
+        """
+        self.close()
+
+        if os.path.exists(self.db_path):
+            try:
+                os.remove(self.db_path)
+                print(f"Deleted feature database: {self.db_path}")
+            except OSError as e:
+                print(f"Error removing database file {self.db_path}: {e}")
+
+        # Use glob to find and delete all matching index files
+        for index_file in glob.glob(f"{self.index_path_base}_*.faiss"):
+            try:
+                os.remove(index_file)
+                print(f"Deleted FAISS index: {index_file}")
+            except OSError as e:
+                print(f"Error removing index file {index_file}: {e}")

coralnet_toolbox/Explorer/QtSettingsWidgets.py

@@ -1,10 +1,10 @@
 import os
 import warnings
 
-from PyQt5.QtCore import Qt
+from PyQt5.QtCore import Qt, pyqtSignal, pyqtSlot
 from PyQt5.QtWidgets import (QVBoxLayout, QHBoxLayout, QPushButton, QComboBox, QLabel, 
                              QWidget, QGroupBox, QSlider, QListWidget, QTabWidget, 
-                             QLineEdit, QFileDialog, QFormLayout)
+                             QLineEdit, QFileDialog, QFormLayout, QSpinBox)
 
 from coralnet_toolbox.MachineLearning.Community.cfg import get_available_configs
 
@@ -16,6 +16,180 @@ warnings.filterwarnings("ignore", category=DeprecationWarning)
 # ----------------------------------------------------------------------------------------------------------------------
 
 
+class UncertaintySettingsWidget(QWidget):
+    """A widget for configuring uncertainty sampling parameters."""
+    parameters_changed = pyqtSignal(dict)
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setup_ui()
+        # Set a strong focus policy to prevent the menu from closing on interaction
+        self.confidence_slider.setFocusPolicy(Qt.StrongFocus)
+        self.margin_slider.setFocusPolicy(Qt.StrongFocus)
+
+    def setup_ui(self):
+        """Creates the UI controls for the parameters."""
+        main_layout = QFormLayout(self)
+        main_layout.setContentsMargins(10, 10, 10, 10)
+        main_layout.setSpacing(15)
+
+        # 1. Confidence Threshold
+        confidence_layout = QHBoxLayout()
+        self.confidence_slider = QSlider(Qt.Horizontal)
+        self.confidence_slider.setMinimum(0)
+        self.confidence_slider.setMaximum(100)
+        self.confidence_slider.setValue(60)
+        self.confidence_slider.setToolTip(
+            "Find annotations where the model's top guess\n"
+            "has a confidence BELOW this threshold."
+        )
+        self.confidence_label = QLabel("60%")
+        self.confidence_label.setMinimumWidth(40)
+        confidence_layout.addWidget(self.confidence_slider)
+        confidence_layout.addWidget(self.confidence_label)
+        main_layout.addRow("Max Confidence:", confidence_layout)
+
+        # 2. Margin Threshold
+        margin_layout = QHBoxLayout()
+        self.margin_slider = QSlider(Qt.Horizontal)
+        self.margin_slider.setMinimum(0)
+        self.margin_slider.setMaximum(50)
+        self.margin_slider.setValue(10)
+        self.margin_slider.setToolTip(
+            "Find annotations where the confidence difference\n"
+            "between the top two guesses is BELOW this threshold."
+        )
+        self.margin_label = QLabel("10%")
+        self.margin_label.setMinimumWidth(40)
+        margin_layout.addWidget(self.margin_slider)
+        margin_layout.addWidget(self.margin_label)
+        main_layout.addRow("Min Margin:", margin_layout)
+
+        # Connect signals
+        self.confidence_slider.valueChanged.connect(self._emit_parameters)
+        self.margin_slider.valueChanged.connect(self._emit_parameters)
+        self.confidence_slider.valueChanged.connect(
+            lambda v: self.confidence_label.setText(f"{v}%")
+        )
+        self.margin_slider.valueChanged.connect(
+            lambda v: self.margin_label.setText(f"{v}%")
+        )
+
+    @pyqtSlot()
+    def _emit_parameters(self):
+        """Gathers current values and emits them in a dictionary."""
+        params = self.get_parameters()
+        self.parameters_changed.emit(params)
+
+    def get_parameters(self):
+        """Returns the current parameters as a dictionary."""
+        return {
+            'confidence': self.confidence_slider.value() / 100.0,
+            'margin': self.margin_slider.value() / 100.0
+        }
+        
+
+class MislabelSettingsWidget(QWidget):
+    """A widget for configuring mislabel detection parameters."""
+    parameters_changed = pyqtSignal(dict)
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setup_ui()
+        # Set a default value to prevent the menu from closing on interaction
+        self.k_spinbox.setFocusPolicy(Qt.StrongFocus)
+        self.threshold_slider.setFocusPolicy(Qt.StrongFocus)
+
+    def setup_ui(self):
+        """Creates the UI controls for the parameters."""
+        main_layout = QFormLayout(self)
+        main_layout.setContentsMargins(10, 10, 10, 10)
+        main_layout.setSpacing(15)
+
+        # 1. K (Number of Neighbors)
+        self.k_spinbox = QSpinBox()
+        self.k_spinbox.setMinimum(2)
+        self.k_spinbox.setMaximum(50)
+        self.k_spinbox.setValue(5)
+        self.k_spinbox.setToolTip("Number of neighbors to check for each point (K).")
+        main_layout.addRow("Neighbors (K):", self.k_spinbox)
+
+        # 2. Agreement Threshold
+        threshold_layout = QHBoxLayout()
+        self.threshold_slider = QSlider(Qt.Horizontal)
+        self.threshold_slider.setMinimum(0)
+        self.threshold_slider.setMaximum(100)
+        self.threshold_slider.setValue(60)
+        self.threshold_slider.setToolTip(
+            "A point is flagged if the percentage of neighbors\n"
+            "with the same label is BELOW this threshold."
+        )
+
+        self.threshold_label = QLabel("60%")
+        self.threshold_label.setMinimumWidth(40)
+
+        threshold_layout.addWidget(self.threshold_slider)
+        threshold_layout.addWidget(self.threshold_label)
+        main_layout.addRow("Agreement:", threshold_layout)
+        
+        # Connect signals
+        self.k_spinbox.valueChanged.connect(self._emit_parameters)
+        self.threshold_slider.valueChanged.connect(self._emit_parameters)
+        self.threshold_slider.valueChanged.connect(
+            lambda v: self.threshold_label.setText(f"{v}%")
+        )
+    
+    @pyqtSlot()
+    def _emit_parameters(self):
+        """Gathers current values and emits them in a dictionary."""
+        params = self.get_parameters()
+        self.parameters_changed.emit(params)
+
+    def get_parameters(self):
+        """Returns the current parameters as a dictionary."""
+        return {
+            'k': self.k_spinbox.value(),
+            'threshold': self.threshold_slider.value() / 100.0
+        }
+        
+
+class SimilaritySettingsWidget(QWidget):
+    """A widget for configuring similarity search parameters (number of neighbors)."""
+    parameters_changed = pyqtSignal(dict)
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setup_ui()
+        self.k_spinbox.setFocusPolicy(Qt.StrongFocus)
+
+    def setup_ui(self):
+        """Creates the UI controls for the parameters."""
+        main_layout = QFormLayout(self)
+        main_layout.setContentsMargins(10, 10, 10, 10)
+        main_layout.setSpacing(15)
+
+        # K (Number of Neighbors)
+        self.k_spinbox = QSpinBox()
+        self.k_spinbox.setMinimum(1)
+        self.k_spinbox.setMaximum(200)
+        self.k_spinbox.setValue(10)
+        self.k_spinbox.setToolTip("Number of similar items to find (K).")
+        main_layout.addRow("Neighbors (K):", self.k_spinbox)
+
+        # Connect signals
+        self.k_spinbox.valueChanged.connect(self._emit_parameters)
+
+    @pyqtSlot()
+    def _emit_parameters(self):
+        params = self.get_parameters()
+        self.parameters_changed.emit(params)
+
+    def get_parameters(self):
+        return {
+            'k': self.k_spinbox.value()
+        }
+        
+
 class AnnotationSettingsWidget(QGroupBox):
     """Widget for filtering annotations by image, type, and label in a multi-column layout."""
 
@@ -220,6 +394,7 @@ class AnnotationSettingsWidget(QGroupBox):
 
 class ModelSettingsWidget(QGroupBox):
     """Widget containing model selection with tabs for different model sources."""
+    selection_changed = pyqtSignal()
 
     def __init__(self, main_window, parent=None):
         super(ModelSettingsWidget, self).__init__("Model Settings", parent)
@@ -243,21 +418,23 @@ class ModelSettingsWidget(QGroupBox):
         self.model_combo.addItems(["Color Features"])
         self.model_combo.insertSeparator(1)  # Add a separator
 
-        standard_models = ['yolov8n-cls.pt',
-                           'yolov8s-cls.pt',
-                           'yolov8m-cls.pt',
-                           'yolov8l-cls.pt',
-                           'yolov8x-cls.pt',
-                           'yolo11n-cls.pt',
-                           'yolo11s-cls.pt',
-                           'yolo11m-cls.pt',
-                           'yolo11l-cls.pt',
-                           'yolo11x-cls.pt',
-                           'yolo12n-cls.pt',
-                           'yolo12s-cls.pt',
-                           'yolo12m-cls.pt',
-                           'yolo12l-cls.pt',
-                           'yolo12x-cls.pt']
+        standard_models = [
+            'yolov8n-cls.pt',
+            'yolov8s-cls.pt',
+            'yolov8m-cls.pt',
+            'yolov8l-cls.pt',
+            'yolov8x-cls.pt',
+            'yolo11n-cls.pt',
+            'yolo11s-cls.pt',
+            'yolo11m-cls.pt',
+            'yolo11l-cls.pt',
+            'yolo11x-cls.pt',
+            'yolo12n-cls.pt',
+            'yolo12s-cls.pt',
+            'yolo12m-cls.pt',
+            'yolo12l-cls.pt',
+            'yolo12x-cls.pt'
+        ]
 
         self.model_combo.addItems(standard_models)
 
@@ -267,9 +444,6 @@ class ModelSettingsWidget(QGroupBox):
             self.model_combo.addItems(list(community_configs.keys()))
 
         self.model_combo.setCurrentText('Color Features')
-        # Connect selection change to update feature mode field state
-        self.model_combo.currentTextChanged.connect(self._update_feature_mode_state)
-        
         model_select_layout.addRow("Model:", self.model_combo)
         
         self.tabs.addTab(model_select_tab, "Select Model")
@@ -293,18 +467,21 @@ class ModelSettingsWidget(QGroupBox):
 
         main_layout.addWidget(self.tabs)
         
-        # Connect tab change to update feature mode state
-        self.tabs.currentChanged.connect(self._update_feature_mode_state)
+        # Connect all relevant widgets to a single slot that emits the new signal
+        self.model_combo.currentTextChanged.connect(self._on_selection_changed)
+        self.tabs.currentChanged.connect(self._on_selection_changed)
+        self.model_path_edit.textChanged.connect(self._on_selection_changed)
         
         # Add feature extraction mode selection outside of tabs
         feature_mode_layout = QFormLayout()
         self.feature_mode_combo = QComboBox()
         self.feature_mode_combo.addItems(["Predictions", "Embed Features"])
+        self.feature_mode_combo.currentTextChanged.connect(self._on_selection_changed)
         feature_mode_layout.addRow("Feature Mode:", self.feature_mode_combo)
         main_layout.addLayout(feature_mode_layout)
         
-        # Initialize the feature mode state based on current selection
-        self._update_feature_mode_state()
+        # Initialize the feature mode state and emit the first signal
+        self._on_selection_changed()
 
     def browse_for_model(self):
         """Open a file dialog to browse for model files."""
@@ -318,6 +495,12 @@ class ModelSettingsWidget(QGroupBox):
         )
         if file_path:
             self.model_path_edit.setText(file_path)
+            
+    @pyqtSlot()
+    def _on_selection_changed(self):
+        """Central slot to handle any change in model selection and emit a single signal."""
+        self._update_feature_mode_state()
+        self.selection_changed.emit()
 
     def _update_feature_mode_state(self, *args):
         """Update the enabled state of the feature mode field based on the current model selection."""

coralnet_toolbox/QtAnnotationWindow.py

@@ -448,7 +448,7 @@ class AnnotationWindow(QGraphicsView):
         # Center the view on the work area's center
         self.centerOn(work_area_center)
 
-    def center_on_annotation(self, annotation):
+    def just_center_on_annotation(self, annotation):
         """Center the view on the specified annotation."""
         # Create graphics item if it doesn't exist
         if not annotation.graphics_item:
@@ -460,6 +460,33 @@ class AnnotationWindow(QGraphicsView):
 
         # Center the view on the annotation's center
         self.centerOn(annotation_center)
+    
+    def center_on_annotation(self, annotation):
+        """Center and zoom in to focus on the specified annotation."""
+        # Create graphics item if it doesn't exist
+        if not annotation.graphics_item:
+            annotation.create_graphics_item(self.scene)
+
+        # Get the bounding rect of the annotation in scene coordinates
+        annotation_rect = annotation.graphics_item.boundingRect()
+        
+        # Add some padding around the annotation (20% on each side)
+        padding_x = annotation_rect.width() * 0.2
+        padding_y = annotation_rect.height() * 0.2
+        padded_rect = annotation_rect.adjusted(-padding_x, -padding_y, padding_x, padding_y)
+        
+        # Fit the padded annotation rect in the view
+        self.fitInView(padded_rect, Qt.KeepAspectRatio)
+        
+        # Update the zoom factor based on the new view transformation
+        # We can calculate this by comparing the viewport size to the scene rect size
+        view_rect = self.viewport().rect()
+        zoom_x = view_rect.width() / padded_rect.width() 
+        zoom_y = view_rect.height() / padded_rect.height()
+        self.zoom_factor = min(zoom_x, zoom_y)
+        
+        # Signal that the view has changed
+        self.viewChanged.emit(*self.get_image_dimensions())
 
     def cycle_annotations(self, direction):
         """Cycle through annotations in the specified direction."""

coralnet_toolbox/QtEventFilter.py

@@ -26,18 +26,29 @@ class GlobalEventFilter(QObject):
         self.auto_distill_deploy_model_dialog = main_window.auto_distill_deploy_model_dialog
         
     def eventFilter(self, obj, event):
+        # Check for explorer window first - this applies to all event types
+        if hasattr(self.main_window, 'explorer_window') and self.main_window.explorer_window:
+            # Special exception for WASD keys which should always work
+            if event.type() == QEvent.KeyPress and event.key() in [Qt.Key_W, Qt.Key_A, Qt.Key_S, Qt.Key_D] and \
+                event.modifiers() & Qt.ControlModifier:
+                self.label_window.handle_wasd_key(event.key())
+                return True
+            
+            # For all other events when explorer is visible, pass them through
+            return False
+            
+        # Now handle keyboard events
         if event.type() == QEvent.KeyPress:
             if event.modifiers() & Qt.ControlModifier and not (event.modifiers() & Qt.ShiftModifier):
-                
-                # Handle Tab key for switching between Select and Annotation tools
-                if event.key() == Qt.Key_Alt:
-                    self.main_window.switch_back_to_tool()
-                    return True
-                
                 # Handle WASD keys for selecting Label
                 if event.key() in [Qt.Key_W, Qt.Key_A, Qt.Key_S, Qt.Key_D]:
                     self.label_window.handle_wasd_key(event.key())
                     return True
+
+                # Handle Alt key for switching between Select and Annotation tools
+                if event.key() == Qt.Key_Alt:
+                    self.main_window.switch_back_to_tool()
+                    return True
                 
                 # Handle hotkey for image classification prediction
                 if event.key() == Qt.Key_1:
@@ -74,22 +85,12 @@ class GlobalEventFilter(QObject):
                 
             # Delete (backspace or delete key) selected annotations when select tool is active
             if event.key() == Qt.Key_Delete or event.key() == Qt.Key_Backspace:
-
-                # First, check if the Explorer window exists and is the active window
-                if (self.main_window.explorer_window and 
-                    self.main_window.explorer_window.isActiveWindow()):
-                    
-                    # If it is, let the Explorer handle its own key press events.
-                    # Returning False passes the event along instead of consuming it.
-                    return False
-
-                # If Explorer is not active, proceed with the original logic for the main window
                 if self.main_window.select_tool_action.isChecked():
                     if self.annotation_window.selected_annotations:
                         self.annotation_window.delete_selected_annotations()
                     # Consume the event so it doesn't do anything else
                     return True
-                
+            
             # Handle image cycling hotkeys
             if event.key() == Qt.Key_Up and event.modifiers() == (Qt.AltModifier):
                 self.image_window.cycle_previous_image()

coralnet_toolbox/QtMainWindow.py

@@ -1398,6 +1398,9 @@ class MainWindow(QMainWindow):
 
     def update_label_transparency(self, value):
         """Update the label transparency value in LabelWindow, AnnotationWindow and the Slider"""
+        if self.explorer_window:
+            return  # Do not update transparency if explorer window is open
+        
         if self.all_labels_button.isChecked():
             # Set transparency for all labels in LabelWindow, AnnotationWindow
             self.label_window.set_all_labels_transparency(value)
@@ -1616,6 +1619,49 @@ class MainWindow(QMainWindow):
         except Exception as e:
             QMessageBox.critical(self, "Critical Error", f"{e}")
             
+    def set_main_window_enabled_state(self, enable_list=None, disable_list=None):
+        """
+        Modular method to enable/disable widgets and actions in the main window.
+        - enable_list: list of widgets/actions to enable
+        - disable_list: list of widgets/actions to disable
+        If both are None, enables everything.
+        """
+        # All main widgets/actions to consider
+        all_widgets = [
+            self.toolbar,
+            self.menu_bar,
+            self.image_window,
+            self.label_window,
+            self.confidence_window,
+            self.annotation_window,
+            # Status bar widgets
+            *(self.status_bar_layout.itemAt(i).widget() for i in range(self.status_bar_layout.count()))
+        ]
+        # Remove None entries (in case any status bar slot is empty)
+        all_widgets = [w for w in all_widgets if w is not None]
+
+        # If neither list is provided, enable everything
+        if enable_list is None and disable_list is None:
+            for w in all_widgets:
+                w.setEnabled(True)
+            return
+
+        # Disable everything by default
+        for w in all_widgets:
+            w.setEnabled(False)
+            
+        # Enable specified widgets/actions
+        if enable_list:
+            for w in enable_list:
+                if w is not None:
+                    w.setEnabled(True)
+                    
+        # Disable specified widgets/actions (overrides enable if both present)
+        if disable_list:
+            for w in disable_list:
+                if w is not None:
+                    w.setEnabled(False)
+
     def open_explorer_window(self):
         """Open the Explorer window, moving the LabelWindow into it."""
         # Check if there are any images in the project
@@ -1634,29 +1680,40 @@ class MainWindow(QMainWindow):
         
         try:
             self.untoggle_all_tools()
+            # Set the transparency value ahead of time
+            self.update_transparency_slider(0)
+            
             # Recreate the explorer window, passing the main window instance
             self.explorer_window = ExplorerWindow(self)
             
             # Move the label_window from the main layout to the explorer
-            # The ExplorerWindow's __init__ will handle adding it to its own layout.
             self.left_layout.removeWidget(self.label_window)
             self.label_window.setParent(self.explorer_window.left_panel)  # Re-parent
             self.explorer_window.left_layout.insertWidget(1, self.label_window)  # Add to explorer layout
                 
-            # Make the explorer window modal to block interaction with main window
-            self.explorer_window.setWindowModality(Qt.ApplicationModal)
-            # Disable the main window explicitly
-            self.setEnabled(False)
+            # Disable all main window widgets except select few
+            self.set_main_window_enabled_state(
+                enable_list=[self.annotation_window, 
+                             self.label_window],
+                disable_list=[self.toolbar, 
+                              self.menu_bar, 
+                              self.image_window, 
+                              self.confidence_window]
+            )
             
             self.explorer_window.showMaximized()
             self.explorer_window.activateWindow()
             self.explorer_window.raise_()
+            
         except Exception as e:
             QMessageBox.critical(self, "Critical Error", f"{e}")
             if self.explorer_window:
                 self.explorer_window.close()  # Ensure cleanup
+                
             self.explorer_window = None
-
+            # Re-enable everything if there was an error
+            self.set_main_window_enabled_state()
+        
     def explorer_closed(self):
         """Handle the explorer window being closed."""
         if self.explorer_window:
@@ -1667,8 +1724,8 @@ class MainWindow(QMainWindow):
             self.label_window.resizeEvent(None)
             self.resizeEvent(None)
             
-            # Re-enable the main window
-            self.setEnabled(True)
+            # Re-enable all main window widgets
+            self.set_main_window_enabled_state()
             
             # Clean up reference
             self.explorer_window = None