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

coralnet_toolbox/Explorer/QtSettingsWidgets.py

@@ -0,0 +1,494 @@
+import os
+import warnings
+
+from PyQt5.QtCore import Qt
+from PyQt5.QtWidgets import (QVBoxLayout, QHBoxLayout, QPushButton, QComboBox, QLabel, 
+                             QWidget, QGroupBox, QSlider, QListWidget, QTabWidget, 
+                             QLineEdit, QFileDialog, QFormLayout)
+
+from coralnet_toolbox.MachineLearning.Community.cfg import get_available_configs
+
+warnings.filterwarnings("ignore", category=DeprecationWarning)
+
+
+# ----------------------------------------------------------------------------------------------------------------------
+# Widgets
+# ----------------------------------------------------------------------------------------------------------------------
+
+
+class AnnotationSettingsWidget(QGroupBox):
+    """Widget for filtering annotations by image, type, and label in a multi-column layout."""
+
+    def __init__(self, main_window, parent=None):
+        super(AnnotationSettingsWidget, self).__init__("Annotation Settings", parent)
+        self.main_window = main_window
+        self.explorer_window = parent  # Store reference to ExplorerWindow
+        self.setup_ui()
+
+    def setup_ui(self):
+        # The main layout is vertical, to hold the top columns, the stretch, and the bottom buttons
+        layout = QVBoxLayout(self)
+
+        # A horizontal layout to contain the filter columns
+        conditions_layout = QHBoxLayout()
+
+        # Images column
+        images_column = QVBoxLayout()
+        images_label = QLabel("Images:")
+        images_label.setStyleSheet("font-weight: bold;")
+        images_column.addWidget(images_label)
+
+        self.images_list = QListWidget()
+        self.images_list.setSelectionMode(QListWidget.MultiSelection)
+        self.images_list.setMaximumHeight(50)
+
+        if hasattr(self.main_window, 'image_window') and hasattr(self.main_window.image_window, 'raster_manager'):
+            for path in self.main_window.image_window.raster_manager.image_paths:
+                self.images_list.addItem(os.path.basename(path))
+
+        images_column.addWidget(self.images_list)
+
+        images_buttons_layout = QHBoxLayout()
+        self.images_select_all_btn = QPushButton("Select All")
+        self.images_select_all_btn.clicked.connect(self.select_all_images)
+        images_buttons_layout.addWidget(self.images_select_all_btn)
+
+        self.images_deselect_all_btn = QPushButton("Deselect All")
+        self.images_deselect_all_btn.clicked.connect(self.deselect_all_images)
+        images_buttons_layout.addWidget(self.images_deselect_all_btn)
+        images_column.addLayout(images_buttons_layout)
+
+        conditions_layout.addLayout(images_column)
+
+        # Annotation Type column
+        type_column = QVBoxLayout()
+        type_label = QLabel("Annotation Type:")
+        type_label.setStyleSheet("font-weight: bold;")
+        type_column.addWidget(type_label)
+
+        self.annotation_type_list = QListWidget()
+        self.annotation_type_list.setSelectionMode(QListWidget.MultiSelection)
+        self.annotation_type_list.setMaximumHeight(50)
+        self.annotation_type_list.addItems(["PatchAnnotation",
+                                            "RectangleAnnotation",
+                                            "PolygonAnnotation",
+                                            "MultiPolygonAnnotation"])
+
+        type_column.addWidget(self.annotation_type_list)
+
+        type_buttons_layout = QHBoxLayout()
+        self.type_select_all_btn = QPushButton("Select All")
+        self.type_select_all_btn.clicked.connect(self.select_all_annotation_types)
+        type_buttons_layout.addWidget(self.type_select_all_btn)
+
+        self.type_deselect_all_btn = QPushButton("Deselect All")
+        self.type_deselect_all_btn.clicked.connect(self.deselect_all_annotation_types)
+        type_buttons_layout.addWidget(self.type_deselect_all_btn)
+        type_column.addLayout(type_buttons_layout)
+
+        conditions_layout.addLayout(type_column)
+
+        # Label column
+        label_column = QVBoxLayout()
+        label_label = QLabel("Label:")
+        label_label.setStyleSheet("font-weight: bold;")
+        label_column.addWidget(label_label)
+
+        self.label_list = QListWidget()
+        self.label_list.setSelectionMode(QListWidget.MultiSelection)
+        self.label_list.setMaximumHeight(50)
+
+        if hasattr(self.main_window, 'label_window') and hasattr(self.main_window.label_window, 'labels'):
+            for label in self.main_window.label_window.labels:
+                self.label_list.addItem(label.short_label_code)
+
+        label_column.addWidget(self.label_list)
+
+        label_buttons_layout = QHBoxLayout()
+        self.label_select_all_btn = QPushButton("Select All")
+        self.label_select_all_btn.clicked.connect(self.select_all_labels)
+        label_buttons_layout.addWidget(self.label_select_all_btn)
+
+        self.label_deselect_all_btn = QPushButton("Deselect All")
+        self.label_deselect_all_btn.clicked.connect(self.deselect_all_labels)
+        label_buttons_layout.addWidget(self.label_deselect_all_btn)
+        label_column.addLayout(label_buttons_layout)
+
+        conditions_layout.addLayout(label_column)
+
+        # Add the horizontal layout of columns to the main vertical layout
+        layout.addLayout(conditions_layout)
+
+        # Add a stretch item to push the columns to the top
+        layout.addStretch(1)
+
+        # Bottom buttons layout with Apply and Clear buttons on the right
+        bottom_layout = QHBoxLayout()
+        bottom_layout.addStretch()  # Push buttons to the right
+
+        self.apply_button = QPushButton("Apply")
+        self.apply_button.clicked.connect(self.apply_conditions)
+        bottom_layout.addWidget(self.apply_button)
+
+        self.clear_button = QPushButton("Clear")
+        self.clear_button.clicked.connect(self.clear_all_conditions)
+        bottom_layout.addWidget(self.clear_button)
+
+        # Add the bottom buttons layout to the main layout, keeping it at the bottom
+        layout.addLayout(bottom_layout)
+
+        # Set defaults
+        self.set_defaults()
+
+    def select_all_images(self):
+        """Select all items in the images list."""
+        self.images_list.selectAll()
+
+    def deselect_all_images(self):
+        """Deselect all items in the images list."""
+        self.images_list.clearSelection()
+
+    def select_all_annotation_types(self):
+        """Select all items in the annotation types list."""
+        self.annotation_type_list.selectAll()
+
+    def deselect_all_annotation_types(self):
+        """Deselect all items in the annotation types list."""
+        self.annotation_type_list.clearSelection()
+
+    def select_all_labels(self):
+        """Select all items in the labels list."""
+        self.label_list.selectAll()
+
+    def deselect_all_labels(self):
+        """Deselect all items in the labels list."""
+        self.label_list.clearSelection()
+
+    def set_defaults(self):
+        """Set default selections."""
+        self.set_default_to_current_image()
+        self.select_all_annotation_types()
+        self.select_all_labels()
+
+    def set_default_to_current_image(self):
+        """Set the current image as the default selection."""
+        if hasattr(self.main_window, 'annotation_window'):
+            current_image_path = self.main_window.annotation_window.current_image_path
+            if current_image_path:
+                current_image_name = os.path.basename(current_image_path)
+                items = self.images_list.findItems(current_image_name, Qt.MatchExactly)
+                if items:
+                    items[0].setSelected(True)
+                    return
+        self.select_all_images()
+
+    def clear_all_conditions(self):
+        """Reset all conditions to their defaults."""
+        self.images_list.clearSelection()
+        self.annotation_type_list.clearSelection()
+        self.label_list.clearSelection()
+        self.set_defaults()
+        if self.explorer_window and hasattr(self.explorer_window, 'refresh_filters'):
+            self.explorer_window.refresh_filters()
+
+    def apply_conditions(self):
+        """Apply the current filter conditions."""
+        if self.explorer_window and hasattr(self.explorer_window, 'refresh_filters'):
+            self.explorer_window.refresh_filters()
+
+    def get_selected_images(self):
+        """Get selected image names."""
+        selected_items = self.images_list.selectedItems()
+        if not selected_items:
+            return []
+        return [item.text() for item in selected_items]
+
+    def get_selected_annotation_types(self):
+        """Get selected annotation types."""
+        selected_items = self.annotation_type_list.selectedItems()
+        if not selected_items:
+            return []
+        return [item.text() for item in selected_items]
+
+    def get_selected_labels(self):
+        """Get selected labels."""
+        selected_items = self.label_list.selectedItems()
+        if not selected_items:
+            return []
+        return [item.text() for item in selected_items]
+
+
+class ModelSettingsWidget(QGroupBox):
+    """Widget containing model selection with tabs for different model sources."""
+
+    def __init__(self, main_window, parent=None):
+        super(ModelSettingsWidget, self).__init__("Model Settings", parent)
+        self.main_window = main_window
+        self.explorer_window = parent
+        self.setup_ui()
+
+    def setup_ui(self):
+        """Set up the UI with a tabbed interface for model selection."""
+        main_layout = QVBoxLayout(self)
+
+        # --- Tabbed Interface for Model Selection ---
+        self.tabs = QTabWidget()
+
+        # Tab 1: Select Model
+        model_select_tab = QWidget()
+        model_select_layout = QFormLayout(model_select_tab)
+        model_select_layout.setContentsMargins(5, 10, 5, 5)  # Add some top margin
+
+        self.model_combo = QComboBox()
+        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']
+
+        self.model_combo.addItems(standard_models)
+
+        community_configs = get_available_configs(task='classify')
+        if community_configs:
+            self.model_combo.insertSeparator(len(standard_models) + 2)
+            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")
+
+        # Tab 2: Existing Model from File
+        model_existing_tab = QWidget()
+        model_existing_layout = QFormLayout(model_existing_tab)
+        model_existing_layout.setContentsMargins(5, 10, 5, 5)
+
+        self.model_path_edit = QLineEdit()
+        self.model_path_edit.setPlaceholderText("Path to a existing .pt model file...")
+        browse_button = QPushButton("Browse...")
+        browse_button.clicked.connect(self.browse_for_model)
+
+        path_layout = QHBoxLayout()
+        path_layout.addWidget(self.model_path_edit)
+        path_layout.addWidget(browse_button)
+        model_existing_layout.addRow("Model Path:", path_layout)
+        
+        self.tabs.addTab(model_existing_tab, "Use Existing Model")
+
+        main_layout.addWidget(self.tabs)
+        
+        # Connect tab change to update feature mode state
+        self.tabs.currentChanged.connect(self._update_feature_mode_state)
+        
+        # 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"])
+        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()
+
+    def browse_for_model(self):
+        """Open a file dialog to browse for model files."""
+        options = QFileDialog.Options()
+        file_path, _ = QFileDialog.getOpenFileName(
+            self,
+            "Select Model File",
+            "",
+            "PyTorch Models (*.pt);;All Files (*)",
+            options=options
+        )
+        if file_path:
+            self.model_path_edit.setText(file_path)
+
+    def _update_feature_mode_state(self, *args):
+        """Update the enabled state of the feature mode field based on the current model selection."""
+        current_tab_index = self.tabs.currentIndex()
+        is_color_features = False
+        
+        if current_tab_index == 0:
+            # Select Model tab - check if Color Features is selected
+            current_model = self.model_combo.currentText()
+            is_color_features = current_model == "Color Features"
+        elif current_tab_index == 1:
+            # Use Existing Model tab - feature mode should always be enabled
+            is_color_features = False
+        
+        # Enable feature mode only if not Color Features
+        self.feature_mode_combo.setEnabled(not is_color_features)
+        
+        # Update the tooltip based on state
+        if is_color_features:
+            self.feature_mode_combo.setToolTip("Feature Mode is not available for Color Features")
+        else:
+            self.feature_mode_combo.setToolTip("Select the feature extraction mode")
+    
+    def get_selected_model(self):
+        """Get the currently selected model name/path and feature mode."""
+        current_tab_index = self.tabs.currentIndex()
+        
+        # Get model name/path and feature mode based on the active tab
+        if current_tab_index == 0:
+            model_name = self.model_combo.currentText()
+        elif current_tab_index == 1:
+            model_name = self.model_path_edit.text()
+        else:
+            return "", None
+        
+        feature_mode = self.feature_mode_combo.currentText() if self.feature_mode_combo.isEnabled() else "N/A"
+        return model_name, feature_mode
+
+
+class EmbeddingSettingsWidget(QGroupBox):
+    """Widget containing settings with tabs for models and embedding."""
+
+    def __init__(self, main_window, parent=None):
+        super(EmbeddingSettingsWidget, self).__init__("Embedding Settings", parent)
+        self.main_window = main_window
+        self.explorer_window = parent
+
+        self.setup_ui()
+
+        # Initial call to set the sliders correctly for the default technique
+        self._update_parameter_sliders()
+
+    def setup_ui(self):
+        """Set up the UI with embedding technique parameters."""
+        main_layout = QVBoxLayout(self)
+        main_layout.setContentsMargins(5, 10, 5, 5)
+
+        # Form layout for embedding settings
+        settings_layout = QFormLayout()
+
+        self.embedding_technique_combo = QComboBox()
+        self.embedding_technique_combo.addItems(["PCA", "TSNE", "UMAP"])
+        self.embedding_technique_combo.currentTextChanged.connect(self._update_parameter_sliders)
+        settings_layout.addRow("Technique:", self.embedding_technique_combo)
+
+        # Slider 1
+        self.param1_label = QLabel("Parameter 1:")
+        param1_layout = QHBoxLayout()
+        self.param1_slider = QSlider(Qt.Horizontal)
+        self.param1_value_label = QLabel("0")
+        self.param1_value_label.setMinimumWidth(25)
+        param1_layout.addWidget(self.param1_slider)
+        param1_layout.addWidget(self.param1_value_label)
+        settings_layout.addRow(self.param1_label, param1_layout)
+        self.param1_slider.valueChanged.connect(lambda v: self.param1_value_label.setText(str(v)))
+
+        # Slider 2
+        self.param2_label = QLabel("Parameter 2:")
+        param2_layout = QHBoxLayout()
+        self.param2_slider = QSlider(Qt.Horizontal)
+        self.param2_value_label = QLabel("0.0")
+        self.param2_value_label.setMinimumWidth(35)  # Increased width for larger numbers
+        param2_layout.addWidget(self.param2_slider)
+        param2_layout.addWidget(self.param2_value_label)
+        settings_layout.addRow(self.param2_label, param2_layout)
+
+        self.apply_embedding_button = QPushButton("Apply Embedding")
+        self.apply_embedding_button.clicked.connect(self.apply_embedding)
+        settings_layout.addRow("", self.apply_embedding_button)
+
+        main_layout.addLayout(settings_layout)
+
+    def _update_parameter_sliders(self):
+        """Enable, disable, and configure sliders based on the selected technique."""
+        technique = self.embedding_technique_combo.currentText()
+
+        # Disconnect any existing connections to prevent conflicts
+        try:
+            self.param2_slider.valueChanged.disconnect()
+        except TypeError:
+            pass  # No connection existed
+
+        if technique == "UMAP":
+            # Enable Row 1 for n_neighbors
+            self.param1_label.setEnabled(True)
+            self.param1_slider.setEnabled(True)
+            self.param1_value_label.setEnabled(True)
+            self.param1_label.setText("n_neighbors:")
+            self.param1_slider.setRange(2, 150)
+            self.param1_slider.setValue(15)
+
+            # Enable Row 2 for min_dist
+            self.param2_label.setEnabled(True)
+            self.param2_slider.setEnabled(True)
+            self.param2_value_label.setEnabled(True)
+            self.param2_label.setText("min_dist:")
+            self.param2_slider.setRange(0, 99)
+            self.param2_slider.setValue(10)
+            self.param2_slider.valueChanged.connect(lambda v: self.param2_value_label.setText(f"{v/100.0:.2f}"))
+
+        elif technique == "TSNE":
+            # Enable Row 1 for Perplexity
+            self.param1_label.setEnabled(True)
+            self.param1_slider.setEnabled(True)
+            self.param1_value_label.setEnabled(True)
+            self.param1_label.setText("Perplexity:")
+            self.param1_slider.setRange(5, 50)
+            self.param1_slider.setValue(30)
+
+            # --- MODIFIED: Enable Row 2 for Early Exaggeration ---
+            self.param2_label.setEnabled(True)
+            self.param2_slider.setEnabled(True)
+            self.param2_value_label.setEnabled(True)
+            self.param2_label.setText("Exaggeration:")
+            self.param2_slider.setRange(50, 600)  # Represents 5.0 to 60.0
+            self.param2_slider.setValue(120)      # Represents 12.0
+            self.param2_slider.valueChanged.connect(lambda v: self.param2_value_label.setText(f"{v/10.0:.1f}"))
+
+        elif technique == "PCA":
+            # Disable both rows for PCA and reset to minimum values
+            self.param1_label.setEnabled(False)
+            self.param1_slider.setEnabled(False)
+            self.param1_value_label.setEnabled(False)
+            self.param1_label.setText(" ")
+            self.param1_slider.setValue(self.param1_slider.minimum())
+            self.param1_value_label.setText(str(self.param1_slider.minimum()))
+
+            self.param2_label.setEnabled(False)
+            self.param2_slider.setEnabled(False)
+            self.param2_value_label.setEnabled(False)
+            self.param2_label.setText(" ")
+            self.param2_slider.setValue(self.param2_slider.minimum())
+            self.param2_value_label.setText(str(self.param2_slider.minimum()))
+
+    def get_embedding_parameters(self):
+        """Returns a dictionary of the current embedding parameters."""
+        params = {
+            'technique': self.embedding_technique_combo.currentText(),
+        }
+        if params['technique'] == 'UMAP':
+            params['n_neighbors'] = self.param1_slider.value()
+            params['min_dist'] = self.param2_slider.value() / 100.0
+        elif params['technique'] == 'TSNE':
+            params['perplexity'] = self.param1_slider.value()
+            params['early_exaggeration'] = self.param2_slider.value() / 10.0
+        return params
+
+    def apply_embedding(self):
+        if self.explorer_window and hasattr(self.explorer_window, 'run_embedding_pipeline'):
+            # Clear all selections before running embedding pipeline
+            if hasattr(self.explorer_window, 'handle_selection_change'):
+                self.explorer_window.handle_selection_change([])
+
+            self.explorer_window.run_embedding_pipeline()

coralnet_toolbox/Explorer/__init__.py

@@ -0,0 +1,7 @@
+# coralnet_toolbox/Explorer/__init__.py
+
+from .QtExplorer import ExplorerWindow
+
+__all__ = [
+    'ExplorerWindow',
+]

coralnet_toolbox/IO/QtImportViscoreAnnotations.py

@@ -262,10 +262,8 @@ class ImportViscoreAnnotations(QDialog):
                     # Get the label information
                     short_code = str(label_code)
                     # Create the label if it does not exist
-                    label = self.label_window.add_label_if_not_exists(short_code,
-                                                                      long_code=None,
-                                                                      color=None,
-                                                                      label_id=None)
+                    label = self.label_window.add_label_if_not_exists(short_code)
+                    
                 progress_bar.update_progress()
 
             # Import annotations

coralnet_toolbox/IO/QtOpenProject.py

@@ -365,8 +365,9 @@ class OpenProject(QDialog):
                 # Update the image window's image annotations
                 self.image_window.update_image_annotations(image_path)
 
-            # Load the annotations for current image
+            # Load the annotations for current image and update counts
             self.annotation_window.load_annotations()
+            self.label_window.update_annotation_count()
 
         except Exception as e:
             QMessageBox.warning(self.annotation_window,

coralnet_toolbox/MachineLearning/DeployModel/QtDetect.py

@@ -284,6 +284,10 @@ class Detect(Base):
         self.update_sam_task_state()
         if self.task != 'segment':
             return results_list
+        
+        if not self.sam_dialog or self.use_sam_dropdown.currentText() == "False":
+            # If SAM is not deployed or not selected, return the results as is
+            return results_list
 
         if self.sam_dialog.loaded_model is None:
             # If SAM is not loaded, ensure we do not use it accidentally

coralnet_toolbox/MachineLearning/DeployModel/QtSegment.py

@@ -283,6 +283,10 @@ class Segment(Base):
         """Apply SAM to the results if needed."""
         # Check if SAM model is deployed and loaded
         self.update_sam_task_state()
+        
+        if not self.sam_dialog or self.use_sam_dropdown.currentText() == "False":
+            # If SAM is not deployed or not selected, return the results as is
+            return results_list
 
         if self.sam_dialog.loaded_model is None:
             # If SAM is not loaded, ensure we do not use it accidentally

coralnet_toolbox/MachineLearning/TrainModel/QtClassify.py

@@ -66,7 +66,7 @@ class Classify(Base):
                            'yolo11s-cls.pt',
                            'yolo11m-cls.pt',
                            'yolo11l-cls.pt',
-                           'yolo11x-cls.pt'
+                           'yolo11x-cls.pt',
                            'yolo12n-cls.pt',
                            'yolo12s-cls.pt',
                            'yolo12m-cls.pt',

coralnet_toolbox/QtConfidenceWindow.py

@@ -6,6 +6,7 @@ from PyQt5.QtWidgets import (QGraphicsView, QGraphicsScene, QWidget, QVBoxLayout
                              QLabel, QHBoxLayout, QFrame, QGroupBox, QPushButton)
 
 from coralnet_toolbox.Icons import get_icon
+from coralnet_toolbox.utilities import scale_pixmap
 
 warnings.filterwarnings("ignore", category=DeprecationWarning)
 
@@ -253,28 +254,6 @@ class ConfidenceWindow(QWidget):
         if self.annotation and updated_annotation.id == self.annotation.id:
             self.refresh_display()
 
-    def scale_pixmap(self, pixmap):
-        """Scale pixmap and graphic if they exceed max dimension while preserving aspect ratio"""
-        width = pixmap.width()
-        height = pixmap.height()
-        
-        # Check if scaling is needed
-        if width <= self.max_graphic_size and height <= self.max_graphic_size:
-            return pixmap
-            
-        # Calculate scale factor based on largest dimension
-        scale = self.max_graphic_size / max(width, height)
-        
-        # Scale pixmap
-        scaled_pixmap = pixmap.scaled(
-            int(width * scale), 
-            int(height * scale),
-            Qt.KeepAspectRatio,
-            Qt.SmoothTransformation
-        )
-        
-        return scaled_pixmap
-
     def display_cropped_image(self, annotation):
         """Display the cropped image and update the bar chart."""
         try:
@@ -282,7 +261,7 @@ class ConfidenceWindow(QWidget):
             self.update_annotation(annotation)
             if self.annotation.cropped_image:
                 # Get the cropped image graphic
-                cropped_image_graphic = self.scale_pixmap(annotation.get_cropped_image_graphic())
+                cropped_image_graphic = scale_pixmap(annotation.get_cropped_image_graphic(), self.max_graphic_size)
                 # Add the scaled annotation graphic (as pixmap)
                 self.scene.addPixmap(cropped_image_graphic)
                 # Add the border color with increased width

coralnet_toolbox/QtEventFilter.py

@@ -30,7 +30,7 @@ class GlobalEventFilter(QObject):
             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_Tab:
+                if event.key() == Qt.Key_Alt:
                     self.main_window.switch_back_to_tool()
                     return True
                 
@@ -72,11 +72,22 @@ class GlobalEventFilter(QObject):
                     self.annotation_window.cycle_annotations(1)
                     return True
                 
-                # Delete (backspace or delete key) selected annotations when select tool is active
-                if event.key() == Qt.Key_Delete or event.key() == Qt.Key_Backspace:
-                    if self.main_window.select_tool_action.isChecked():
-                        if self.annotation_window.selected_annotations:
-                            self.annotation_window.delete_selected_annotations()
+            # 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
@@ -125,4 +136,4 @@ class GlobalEventFilter(QObject):
                                      'Are you sure you want to exit?',
                                      QMessageBox.Yes | QMessageBox.No, QMessageBox.No)
         if reply == QMessageBox.Yes:
-            QApplication.quit()
+            QApplication.quit()