coralnet-toolbox 0.0.71__py2.py3-none-any.whl → 0.0.73__py2.py3-none-any.whl

coralnet_toolbox/Explorer/QtFeatureStore.py

@@ -149,6 +149,21 @@ class FeatureStore:
             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 remove_features_for_annotation(self, annotation_id):
+        """
+        Removes an annotation's feature metadata from the SQLite database.
+        This effectively orphans the vector in the FAISS index, invalidating it.
+        """
+        try:
+            self.cursor.execute(
+                "DELETE FROM features WHERE annotation_id = ?",
+                (annotation_id,)
+            )
+            self.conn.commit()
+            print(f"Invalidated features for annotation_id: {annotation_id}")
+        except sqlite3.Error as e:
+            print(f"Error removing feature for annotation {annotation_id}: {e}")
 
     def close(self):
         """Closes the database connection."""

coralnet_toolbox/Explorer/QtSettingsWidgets.py

@@ -4,7 +4,7 @@ import warnings
 from PyQt5.QtCore import Qt, pyqtSignal, pyqtSlot
 from PyQt5.QtWidgets import (QVBoxLayout, QHBoxLayout, QPushButton, QComboBox, QLabel, 
                              QWidget, QGroupBox, QSlider, QListWidget, QTabWidget, 
-                             QLineEdit, QFileDialog, QFormLayout, QSpinBox)
+                             QLineEdit, QFileDialog, QFormLayout, QSpinBox, QDoubleSpinBox)
 
 from coralnet_toolbox.MachineLearning.Community.cfg import get_available_configs
 
@@ -189,6 +189,48 @@ class SimilaritySettingsWidget(QWidget):
             'k': self.k_spinbox.value()
         }
         
+        
+class DuplicateSettingsWidget(QWidget):
+    """Widget for configuring duplicate detection parameters."""
+    parameters_changed = pyqtSignal(dict)
+
+    def __init__(self, parent=None):
+        super(DuplicateSettingsWidget, self).__init__(parent)
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(10, 10, 10, 10)
+        
+        # Using a DoubleSpinBox for the distance threshold
+        self.threshold_spinbox = QDoubleSpinBox()
+        self.threshold_spinbox.setDecimals(3)
+        self.threshold_spinbox.setRange(0.0, 10.0)
+        self.threshold_spinbox.setSingleStep(0.01)
+        self.threshold_spinbox.setValue(0.1)  # Default value for squared L2 distance
+        self.threshold_spinbox.setToolTip(
+            "Similarity Threshold (Squared L2 Distance).\n"
+            "Lower values mean more similar.\n"
+            "A value of 0 means identical features."
+        )
+        
+        self.threshold_spinbox.valueChanged.connect(self._emit_parameters)
+
+        form_layout = QHBoxLayout()
+        form_layout.addWidget(QLabel("Threshold:"))
+        form_layout.addWidget(self.threshold_spinbox)
+        layout.addLayout(form_layout)
+
+    def _emit_parameters(self):
+        """Emits the current parameters."""
+        params = {
+            'threshold': self.threshold_spinbox.value()
+        }
+        self.parameters_changed.emit(params)
+
+    def get_parameters(self):
+        """Returns the current parameters as a dictionary."""
+        return {
+            'threshold': self.threshold_spinbox.value()
+        }
+
 
 class AnnotationSettingsWidget(QGroupBox):
     """Widget for filtering annotations by image, type, and label in a multi-column layout."""
@@ -213,7 +255,7 @@ class AnnotationSettingsWidget(QGroupBox):
         images_column.addWidget(images_label)
 
         self.images_list = QListWidget()
-        self.images_list.setSelectionMode(QListWidget.MultiSelection)
+        self.images_list.setSelectionMode(QListWidget.ExtendedSelection)
         self.images_list.setMaximumHeight(50)
 
         if hasattr(self.main_window, 'image_window') and hasattr(self.main_window.image_window, 'raster_manager'):
@@ -241,7 +283,7 @@ class AnnotationSettingsWidget(QGroupBox):
         type_column.addWidget(type_label)
 
         self.annotation_type_list = QListWidget()
-        self.annotation_type_list.setSelectionMode(QListWidget.MultiSelection)
+        self.annotation_type_list.setSelectionMode(QListWidget.ExtendedSelection)
         self.annotation_type_list.setMaximumHeight(50)
         self.annotation_type_list.addItems(["PatchAnnotation",
                                             "RectangleAnnotation",
@@ -269,7 +311,7 @@ class AnnotationSettingsWidget(QGroupBox):
         label_column.addWidget(label_label)
 
         self.label_list = QListWidget()
-        self.label_list.setSelectionMode(QListWidget.MultiSelection)
+        self.label_list.setSelectionMode(QListWidget.ExtendedSelection)
         self.label_list.setMaximumHeight(50)
 
         if hasattr(self.main_window, 'label_window') and hasattr(self.main_window.label_window, 'labels'):
@@ -670,8 +712,8 @@ class EmbeddingSettingsWidget(QGroupBox):
 
     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([])
+            # Clear all selections before running a new embedding pipeline.
+            if hasattr(self.explorer_window, '_clear_selections'):
+                self.explorer_window._clear_selections()
 
             self.explorer_window.run_embedding_pipeline()

coralnet_toolbox/MachineLearning/DeployModel/QtDetect.py

@@ -123,18 +123,29 @@ class Detect(Base):
 
     def update_sam_task_state(self):
         """
-        Centralized method to check if SAM is loaded and update task and dropdown accordingly.
+        Centralized method to check if SAM is loaded and update task accordingly.
+        If the user has selected to use SAM, this function ensures the task is set to 'segment'.
+        Crucially, it does NOT alter the task if SAM is not selected, respecting the
+        user's choice from the 'Task' dropdown.
         """
-        sam_active = (
-            self.sam_dialog is not None and 
-            self.sam_dialog.loaded_model is not None and
-            self.use_sam_dropdown.currentText() == "True"
-        )
-        if sam_active:
-            self.task = 'segment'
-        else:
-            self.task = 'detect'
-            self.use_sam_dropdown.setCurrentText("False")
+        # Check if the user wants to use the SAM model
+        if self.use_sam_dropdown.currentText() == "True":
+            # SAM is requested. Check if it's actually available.
+            sam_is_available = (
+                hasattr(self, 'sam_dialog') and
+                self.sam_dialog is not None and
+                self.sam_dialog.loaded_model is not None
+            )
+
+            if sam_is_available:
+                # If SAM is wanted and available, the task must be segmentation.
+                self.task = 'segment'
+            else:
+                # If SAM is wanted but not available, revert the dropdown and do nothing else.
+                # The 'is_sam_model_deployed' function already handles showing an error message.
+                self.use_sam_dropdown.setCurrentText("False")
+
+        # If use_sam_dropdown is "False", do nothing. Let self.task be whatever the user set.
 
     def load_model(self):
         """

coralnet_toolbox/MachineLearning/DeployModel/QtSegment.py

@@ -123,17 +123,29 @@ class Segment(Base):
         
     def update_sam_task_state(self):
         """
-        Centralized method to check if SAM is loaded and update task and dropdown accordingly.
+        Centralized method to check if SAM is loaded and update task accordingly.
+        If the user has selected to use SAM, this function ensures the task is set to 'segment'.
+        Crucially, it does NOT alter the task if SAM is not selected, respecting the
+        user's choice from the 'Task' dropdown.
         """
-        sam_active = (
-            self.sam_dialog is not None and 
-            self.sam_dialog.loaded_model is not None and
-            self.use_sam_dropdown.currentText() == "True"
-        )
-        if sam_active:
-            self.task = 'segment'
-        else:
-            self.use_sam_dropdown.setCurrentText("False")
+        # Check if the user wants to use the SAM model
+        if self.use_sam_dropdown.currentText() == "True":
+            # SAM is requested. Check if it's actually available.
+            sam_is_available = (
+                hasattr(self, 'sam_dialog') and
+                self.sam_dialog is not None and
+                self.sam_dialog.loaded_model is not None
+            )
+
+            if sam_is_available:
+                # If SAM is wanted and available, the task must be segmentation.
+                self.task = 'segment'
+            else:
+                # If SAM is wanted but not available, revert the dropdown and do nothing else.
+                # The 'is_sam_model_deployed' function already handles showing an error message.
+                self.use_sam_dropdown.setCurrentText("False")
+
+        # If use_sam_dropdown is "False", do nothing. Let self.task be whatever the user set.
 
     def load_model(self):
         """

coralnet_toolbox/MachineLearning/ExportDataset/QtBase.py

@@ -42,7 +42,7 @@ class Base(QDialog):
         self.annotation_window = main_window.annotation_window
         self.image_window = main_window.image_window
 
-        self.resize(1000, 600)
+        self.resize(1000, 800)
         self.setWindowIcon(get_icon("coral.png"))
         self.setWindowTitle("Export Dataset")
 
@@ -64,10 +64,8 @@ class Base(QDialog):
         self.setup_output_layout()
         # Setup the ratio layout
         self.setup_ratio_layout()
-        # Setup the annotation layout
-        self.setup_annotation_layout()
-        # Setup the options layout
-        self.setup_options_layout()
+        # Setup the data selection layout
+        self.setup_data_selection_layout()
         # Setup the table layout
         self.setup_table_layout()
         # Setup the status layout
@@ -147,10 +145,25 @@ class Base(QDialog):
         group_box.setLayout(layout)
         self.layout.addWidget(group_box)
 
-    def setup_annotation_layout(self):
-        """Setup the annotation type checkboxes layout."""
+    def setup_data_selection_layout(self):
+        """Setup the layout for data selection options in a horizontal arrangement."""
+        options_layout = QHBoxLayout()
+
+        # Create and add the group boxes
+        annotation_types_group = self.create_annotation_layout()
+        image_options_group = self.create_image_source_layout()
+        negative_samples_group = self.create_negative_samples_layout()
+
+        options_layout.addWidget(annotation_types_group)
+        options_layout.addWidget(image_options_group)
+        options_layout.addWidget(negative_samples_group)
+
+        self.layout.addLayout(options_layout)
+
+    def create_annotation_layout(self):
+        """Creates the annotation type checkboxes layout group box."""
         group_box = QGroupBox("Annotation Types")
-        layout = QHBoxLayout()
+        layout = QVBoxLayout()
 
         self.include_patches_checkbox = QCheckBox("Include Patch Annotations")
         self.include_rectangles_checkbox = QCheckBox("Include Rectangle Annotations")
@@ -161,30 +174,24 @@ class Base(QDialog):
         layout.addWidget(self.include_polygons_checkbox)
 
         group_box.setLayout(layout)
-        self.layout.addWidget(group_box)
+        return group_box
 
-    def setup_options_layout(self):
-        """Setup the image options layout."""
-        group_box = QGroupBox("Image Options")
-        layout = QHBoxLayout()  # Changed from QVBoxLayout to QHBoxLayout
+    def create_image_source_layout(self):
+        """Creates the image source options layout group box."""
+        group_box = QGroupBox("Image Source")
+        layout = QVBoxLayout()
 
-        # Create a button group for the image checkboxes
         self.image_options_group = QButtonGroup(self)
 
         self.all_images_radio = QRadioButton("All Images")
         self.filtered_images_radio = QRadioButton("Filtered Images")
 
-        # Add the radio buttons to the button group
         self.image_options_group.addButton(self.all_images_radio)
         self.image_options_group.addButton(self.filtered_images_radio)
-
-        # Ensure only one radio button can be checked at a time
         self.image_options_group.setExclusive(True)
 
-        # Set the default radio button
         self.all_images_radio.setChecked(True)
 
-        # Connect radio button signals
         self.all_images_radio.toggled.connect(self.update_image_selection)
         self.filtered_images_radio.toggled.connect(self.update_image_selection)
 
@@ -192,7 +199,32 @@ class Base(QDialog):
         layout.addWidget(self.filtered_images_radio)
 
         group_box.setLayout(layout)
-        self.layout.addWidget(group_box)
+        return group_box
+
+    def create_negative_samples_layout(self):
+        """Creates the negative sample options layout group box."""
+        group_box = QGroupBox("Negative Samples")
+        layout = QVBoxLayout()
+
+        self.negative_samples_group = QButtonGroup(self)
+
+        self.include_negatives_radio = QRadioButton("Include Negatives")
+        self.exclude_negatives_radio = QRadioButton("Exclude Negatives")
+
+        self.negative_samples_group.addButton(self.include_negatives_radio)
+        self.negative_samples_group.addButton(self.exclude_negatives_radio)
+        self.negative_samples_group.setExclusive(True)
+
+        self.exclude_negatives_radio.setChecked(True)
+
+        # Connect to update stats when changed. Only one needed for the group.
+        self.include_negatives_radio.toggled.connect(self.update_summary_statistics)
+
+        layout.addWidget(self.include_negatives_radio)
+        layout.addWidget(self.exclude_negatives_radio)
+
+        group_box.setLayout(layout)
+        return group_box
 
     def setup_table_layout(self):
         """Setup the label counts table layout."""
@@ -424,6 +456,11 @@ class Base(QDialog):
         else:
             images = self.image_window.raster_manager.image_paths
 
+        # If "Exclude Negatives" is checked, only use images that have selected annotations.
+        if self.exclude_negatives_radio.isChecked():
+            image_paths_with_annotations = {a.image_path for a in self.selected_annotations}
+            images = [img for img in images if img in image_paths_with_annotations]
+
         random.shuffle(images)
 
         train_split = int(len(images) * self.train_ratio)
@@ -551,9 +588,6 @@ class Base(QDialog):
 
         self.updating_summary_statistics = True
 
-        # Split the data by images
-        self.split_data()
-
         # Selected labels based on user's selection
         self.selected_labels = []
         for row in range(self.label_counts_table.rowCount()):
@@ -564,6 +598,9 @@ class Base(QDialog):
 
         # Filter annotations based on the selected annotation types and current tab
         self.selected_annotations = self.filter_annotations()
+        
+        # Split the data by images
+        self.split_data()
 
         # Split the data by annotations
         self.determine_splits()
@@ -704,4 +741,4 @@ class Base(QDialog):
         raise NotImplementedError("Method must be implemented in the subclass.")
 
     def process_annotations(self, annotations, split_dir, split):
-        raise NotImplementedError("Method must be implemented in the subclass.")
+        raise NotImplementedError("Method must be implemented in the subclass.")

coralnet_toolbox/MachineLearning/ExportDataset/QtClassify.py

@@ -60,6 +60,10 @@ class Classify(Base):
         self.include_polygons_checkbox.setChecked(True)
         self.include_polygons_checkbox.setEnabled(True)
 
+        # Disable negative sample options for classification
+        self.include_negatives_radio.setEnabled(False)
+        self.exclude_negatives_radio.setEnabled(False)
+
     def create_dataset(self, output_dir_path):
         """
         Create an image classification dataset.
@@ -219,4 +223,4 @@ class Classify(Base):
             progress_bar.stop_progress()
             progress_bar.close()
             progress_bar = None
-            gc.collect()
+            gc.collect()

coralnet_toolbox/MachineLearning/ExportDataset/QtDetect.py

@@ -53,6 +53,10 @@ class Detect(Base):
         self.include_rectangles_checkbox.setEnabled(True)  # Enable user to uncheck rectangles if desired
         self.include_polygons_checkbox.setChecked(True)
         self.include_polygons_checkbox.setEnabled(True)  # Already enabled
+
+        # Explicitly enable negative sample options for detection
+        self.include_negatives_radio.setEnabled(True)
+        self.exclude_negatives_radio.setEnabled(True)
         
     def create_dataset(self, output_dir_path):
         """
@@ -106,12 +110,20 @@ class Detect(Base):
         Process and save detection annotations.
 
         Args:
-            annotations (list): List of annotations.
+            annotations (list): List of annotations for this split.
             split_dir (str): Path to the split directory.
             split (str): Split name (e.g., "Training", "Validation", "Testing").
         """
-        # Get unique image paths
-        image_paths = list(set(a.image_path for a in annotations))
+        # Determine the full list of images for this split (including negatives)
+        if split == "Training":
+            image_paths = self.train_images
+        elif split == "Validation":
+            image_paths = self.val_images
+        elif split == "Testing":
+            image_paths = self.test_images
+        else:
+            image_paths = []
+
         if not image_paths:
             return
 
@@ -124,6 +136,7 @@ class Detect(Base):
         for image_path in image_paths:
             yolo_annotations = []
             image_height, image_width = rasterio_open(image_path).shape
+            # Filter the annotations passed to this function to get only those for the current image
             image_annotations = [a for a in annotations if a.image_path == image_path]
 
             for image_annotation in image_annotations:
@@ -132,11 +145,11 @@ class Detect(Base):
                 yolo_annotations.append(f"{class_number} {annotation}")
 
             # Save the annotations to a text file
-            file_ext = image_path.split(".")[-1]
-            text_file = os.path.basename(image_path).replace(f".{file_ext}", ".txt")
+            file_ext = os.path.splitext(image_path)[1]
+            text_file = os.path.basename(image_path).replace(file_ext, ".txt")
             text_path = os.path.join(f"{split_dir}/labels", text_file)
 
-            # Write the annotations to the text file
+            # Write the annotations to the text file (creates an empty file for negatives)
             with open(text_path, 'w') as f:
                 for annotation in yolo_annotations:
                     f.write(annotation + '\n')

coralnet_toolbox/MachineLearning/ExportDataset/QtSegment.py

@@ -53,6 +53,10 @@ class Segment(Base):
         self.include_rectangles_checkbox.setEnabled(True)  # Enable rectangles for segmentation
         self.include_polygons_checkbox.setChecked(True)
         self.include_polygons_checkbox.setEnabled(True)  # Enable user to uncheck polygons if desired
+        
+        # Explicitly enable negative sample options for segmentation
+        self.include_negatives_radio.setEnabled(True)
+        self.exclude_negatives_radio.setEnabled(True)
 
     def create_dataset(self, output_dir_path):
         """
@@ -106,12 +110,20 @@ class Segment(Base):
         Process and save segmentation annotations.
 
         Args:
-            annotations (list): List of annotations.
+            annotations (list): List of annotations for this split.
             split_dir (str): Path to the split directory.
             split (str): Split name (e.g., "Training", "Validation", "Testing").
         """
-        # Get unique image paths
-        image_paths = list(set(a.image_path for a in annotations))
+        # Determine the full list of images for this split (including negatives)
+        if split == "Training":
+            image_paths = self.train_images
+        elif split == "Validation":
+            image_paths = self.val_images
+        elif split == "Testing":
+            image_paths = self.test_images
+        else:
+            image_paths = []
+
         if not image_paths:
             return
 
@@ -124,6 +136,7 @@ class Segment(Base):
         for image_path in image_paths:
             yolo_annotations = []
             image_height, image_width = rasterio_open(image_path).shape
+            # Filter the annotations passed to this function to get only those for the current image
             image_annotations = [a for a in annotations if a.image_path == image_path]
 
             for image_annotation in image_annotations:
@@ -132,11 +145,11 @@ class Segment(Base):
                 yolo_annotations.append(f"{class_number} {annotation}")
 
             # Save the annotations to a text file
-            file_ext = image_path.split(".")[-1]
-            text_file = os.path.basename(image_path).replace(f".{file_ext}", ".txt")
+            file_ext = os.path.splitext(image_path)[1]
+            text_file = os.path.basename(image_path).replace(file_ext, ".txt")
             text_path = os.path.join(f"{split_dir}/labels", text_file)
 
-            # Write the annotations to the text file
+            # Write the annotations to the text file (creates an empty file for negatives)
             with open(text_path, 'w') as f:
                 for annotation in yolo_annotations:
                     f.write(annotation + '\n')
@@ -146,7 +159,7 @@ class Segment(Base):
 
             progress_bar.update_progress()
 
-        # Make cursor normal
+        # Reset cursor
         QApplication.restoreOverrideCursor()
         progress_bar.stop_progress()
-        progress_bar.close()
+        progress_bar.close()

coralnet_toolbox/QtAnnotationWindow.py

@@ -48,6 +48,7 @@ class AnnotationWindow(QGraphicsView):
     annotationSelected = pyqtSignal(int)  # Signal to emit when annotation is selected
     annotationDeleted = pyqtSignal(str)  # Signal to emit when annotation is deleted
     annotationCreated = pyqtSignal(str)  # Signal to emit when annotation is created
+    annotationModified = pyqtSignal(str)  # Signal to emit when annotation is modified
 
     def __init__(self, main_window, parent=None):
         """Initialize the annotation window with the main window and parent widget."""
@@ -374,6 +375,9 @@ class AnnotationWindow(QGraphicsView):
 
     def set_image(self, image_path):
         """Set and display an image at the given path."""
+        # Calculate GDIs for Windows if needed
+        self.main_window.check_windows_gdi_count()
+        
         # Clean up
         self.clear_scene()
 
@@ -404,10 +408,6 @@ class AnnotationWindow(QGraphicsView):
 
         self.toggle_cursor_annotation()
 
-        # Set the image dimensions, and current view in status bar
-        self.imageLoaded.emit(self.pixmap_image.width(), self.pixmap_image.height())
-        self.viewChanged.emit(self.pixmap_image.width(), self.pixmap_image.height())
-
         # Load all associated annotations
         self.load_annotations()
         # Update the image window's image annotations
@@ -417,6 +417,10 @@ class AnnotationWindow(QGraphicsView):
 
         QApplication.processEvents()
 
+        # Set the image dimensions, and current view in status bar
+        self.imageLoaded.emit(self.pixmap_image.width(), self.pixmap_image.height())
+        self.viewChanged.emit(self.pixmap_image.width(), self.pixmap_image.height())
+
     def update_current_image_path(self, image_path):
         """Update the current image path being displayed."""
         self.current_image_path = image_path
@@ -462,29 +466,57 @@ class AnnotationWindow(QGraphicsView):
         self.centerOn(annotation_center)
     
     def center_on_annotation(self, annotation):
-        """Center and zoom in to focus on the specified annotation."""
+        """Center and zoom in to focus on the specified annotation with dynamic padding."""
         # 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
+
+        # Step 1: Calculate annotation and image area
+        annotation_area = annotation_rect.width() * annotation_rect.height()
+        if self.pixmap_image:
+            image_width = self.pixmap_image.width()
+            image_height = self.pixmap_image.height()
+        else:
+            # Fallback to scene rect if image not loaded
+            image_width = self.scene.sceneRect().width()
+            image_height = self.scene.sceneRect().height()
+        image_area = image_width * image_height
+
+        # Step 2: Compute the relative area ratio (avoid division by zero)
+        if image_area > 0:
+            relative_area = annotation_area / image_area
+        else:
+            relative_area = 1.0  # fallback, treat as full image
+
+        # Step 3: Map ratio to padding factor (smaller annotation = more padding)
+        # Example: padding_factor = clamp(0.5 * (1/relative_area)**0.5, 0.1, 0.5)
+        # - For very small annotations, padding approaches 0.5 (50%)
+        # - For large annotations, padding approaches 0.1 (10%)
+        import math
+        min_padding = 0.1  # 10%
+        max_padding = 0.5  # 50%
+        if relative_area > 0:
+            padding_factor = max(min(0.5 * (1 / math.sqrt(relative_area)), max_padding), min_padding)
+        else:
+            padding_factor = min_padding
+
+        # Step 4: Apply dynamic padding
+        padding_x = annotation_rect.width() * padding_factor
+        padding_y = annotation_rect.height() * padding_factor
         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_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())
 
@@ -543,7 +575,7 @@ class AnnotationWindow(QGraphicsView):
             return type(self.selected_annotations[0])
         return None
 
-    def select_annotation(self, annotation, multi_select=False):
+    def select_annotation(self, annotation, multi_select=False, quiet_mode=False):
         """Select an annotation and update the UI accordingly."""
         # If the annotation is already selected and Ctrl is pressed, unselect it
         if annotation in self.selected_annotations and multi_select:
@@ -569,7 +601,11 @@ class AnnotationWindow(QGraphicsView):
             
             # If this is the only selected annotation, update label window and confidence window
             if len(self.selected_annotations) == 1:
-                self.labelSelected.emit(annotation.label.id)
+                
+                if not quiet_mode:
+                    # Emit the label selected signal, unless in quiet mode.
+                    # This is in Explorer to avoid overwriting preview label.
+                    self.labelSelected.emit(annotation.label.id)
                 
                 # Make sure we have a cropped image
                 if not annotation.cropped_image:

coralnet_toolbox/QtEventFilter.py

@@ -23,6 +23,7 @@ class GlobalEventFilter(QObject):
         self.detect_deploy_model_dialog = main_window.detect_deploy_model_dialog
         self.segment_deploy_model_dialog = main_window.segment_deploy_model_dialog
         self.sam_deploy_generator_dialog = main_window.sam_deploy_generator_dialog
+        self.see_anything_deploy_generator_dialog = main_window.see_anything_deploy_generator_dialog
         self.auto_distill_deploy_model_dialog = main_window.auto_distill_deploy_model_dialog
         
     def eventFilter(self, obj, event):
@@ -69,9 +70,14 @@ class GlobalEventFilter(QObject):
                 if event.key() == Qt.Key_4:
                     self.sam_deploy_generator_dialog.predict()
                     return True
-
-                # Handle hotkey for auto distill prediction
+                
+                # Handle hotkey for see anything (YOLOE) generator
                 if event.key() == Qt.Key_5:
+                    self.see_anything_deploy_generator_dialog.predict()
+                    return True
+                
+                # Handle hotkey for auto distill prediction
+                if event.key() == Qt.Key_6:
                     self.auto_distill_deploy_model_dialog.predict()
                     return True