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

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

@@ -408,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
@@ -421,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
@@ -466,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())
 

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
 

coralnet_toolbox/QtImageWindow.py

@@ -562,7 +562,7 @@ class ImageWindow(QWidget):
                 
         except Exception as e:
             self.show_error("Image Loading Error", 
-                          f"Error loading image {os.path.basename(image_path)}:\n{str(e)}")
+                            f"Error loading image {os.path.basename(image_path)}:\n{str(e)}")
             return False
                 
     @property
@@ -1182,26 +1182,25 @@ class ImagePreviewTooltip(QFrame):
             self.hide()
             
     def show_at(self, global_pos):
-        """
-        Position and show the tooltip at the specified global position,
-        always placing it to the bottom-right of the cursor.
-        
-        Args:
-            global_pos (QPoint): Position to show the tooltip
-        """
-        # Always position to bottom-right of cursor with fixed offset
-        x, y = global_pos.x() + 25, global_pos.y() + 25
-        
-        # Ensure tooltip stays within screen boundaries
-        screen_rect = self.screen().geometry()
+        """Position and show the tooltip at the specified global position."""
+        # Position tooltip to bottom-right of cursor
+        x, y = global_pos.x() + 15, global_pos.y() + 15
+
+        # Get the screen that contains the cursor position
+        screen = QApplication.screenAt(global_pos)
+        if not screen:
+            screen = QApplication.primaryScreen()
+
+        # Get screen geometry and tooltip size
+        screen_rect = screen.geometry()
         tooltip_size = self.sizeHint()
-        
-        # Adjust position if needed to stay on screen
+
+        # Adjust position to stay on screen
         if x + tooltip_size.width() > screen_rect.right():
-            x = screen_rect.right() - tooltip_size.width() - 10
+            x = global_pos.x() - tooltip_size.width() - 15
         if y + tooltip_size.height() > screen_rect.bottom():
-            y = screen_rect.bottom() - tooltip_size.height() - 10
-            
+            y = global_pos.y() - tooltip_size.height() - 15
+
         # Set position and show
         self.move(x, y)
         self.show()

coralnet_toolbox/QtLabelWindow.py

@@ -280,7 +280,7 @@ class LabelWindow(QWidget):
 
         self.edit_label_button = QPushButton()
         self.edit_label_button.setIcon(self.main_window.edit_icon)
-        self.edit_label_button.setToolTip("Edit Label")
+        self.edit_label_button.setToolTip("Edit Label / Merge Labels")
         self.edit_label_button.setFixedSize(self.label_width, self.label_height)
         self.edit_label_button.setEnabled(False)  # Initially disabled
         self.top_bar.addWidget(self.edit_label_button)

coralnet_toolbox/QtMainWindow.py

@@ -9,8 +9,8 @@ import requests
 
 from packaging import version
 
-from PyQt5.QtCore import Qt, pyqtSignal, QEvent, QSize, QPoint
 from PyQt5.QtGui import QIcon, QMouseEvent
+from PyQt5.QtCore import Qt, pyqtSignal, QEvent, QSize, QPoint
 from PyQt5.QtWidgets import (QListWidget, QCheckBox, QFrame, QComboBox)
 from PyQt5.QtWidgets import (QMainWindow, QApplication, QToolBar, QAction, QSizePolicy,
                              QMessageBox, QWidget, QVBoxLayout, QLabel, QHBoxLayout,
@@ -95,6 +95,7 @@ from coralnet_toolbox.SAM import (
 from coralnet_toolbox.SeeAnything import (
     TrainModelDialog as SeeAnythingTrainModelDialog,
     DeployPredictorDialog as SeeAnythingDeployPredictorDialog,
+    DeployGeneratorDialog as SeeAnythingDeployGeneratorDialog,
     BatchInferenceDialog as SeeAnythingBatchInferenceDialog
 )
 
@@ -258,6 +259,7 @@ class MainWindow(QMainWindow):
         # Create dialogs (See Anything)
         self.see_anything_train_model_dialog = SeeAnythingTrainModelDialog(self)
         self.see_anything_deploy_predictor_dialog = SeeAnythingDeployPredictorDialog(self)
+        self.see_anything_deploy_generator_dialog = SeeAnythingDeployGeneratorDialog(self)
         self.see_anything_batch_inference_dialog = SeeAnythingBatchInferenceDialog(self)
 
         # Create dialogs (AutoDistill)
@@ -622,11 +624,17 @@ class MainWindow(QMainWindow):
         # Train Model
         self.see_anything_train_model_action = QAction("Train Model", self)
         self.see_anything_train_model_action.triggered.connect(self.open_see_anything_train_model_dialog)
-        self.see_anything_menu.addAction(self.see_anything_train_model_action)
-        # Deploy Model
+        # self.see_anything_menu.addAction(self.see_anything_train_model_action)  TODO Doesn't work
+        # Deploy Model submenu
+        self.see_anything_deploy_model_menu = self.see_anything_menu.addMenu("Deploy Model")
+        # Deploy Predictor
         self.see_anything_deploy_predictor_action = QAction("Deploy Predictor", self)
         self.see_anything_deploy_predictor_action.triggered.connect(self.open_see_anything_deploy_predictor_dialog)
-        self.see_anything_menu.addAction(self.see_anything_deploy_predictor_action)
+        self.see_anything_deploy_model_menu.addAction(self.see_anything_deploy_predictor_action)
+        # Deploy Generator
+        self.see_anything_deploy_generator_action = QAction("Deploy Generator", self)
+        self.see_anything_deploy_generator_action.triggered.connect(self.open_see_anything_deploy_generator_dialog)
+        self.see_anything_deploy_model_menu.addAction(self.see_anything_deploy_generator_action)
         # Batch Inference
         self.see_anything_batch_inference_action = QAction("Batch Inference", self)
         self.see_anything_batch_inference_action.triggered.connect(self.open_see_anything_batch_inference_dialog)
@@ -674,6 +682,76 @@ class MainWindow(QMainWindow):
         # ----------------------------------------
         # Create and add the toolbar
         # ----------------------------------------
+        
+        # Define verbose tool descriptions
+        self.tool_descriptions = {
+            "select": ("Select Tool\n\n"
+                       "Select, modify, and manage annotations.\n"
+                       "• Left-click to select annotations; hold Ctrl+left-click to select multiple.\n"
+                       "• Left-click and drag to move selected annotations.\n"
+                       "• Ctrl+click and drag to create a selection rectangle.\n"
+                       "• Ctrl+Shift to show resize handles for a selected Rectangle and Polygon annotations.\n"
+                       "• Ctrl+X to cut a selected annotation along a drawn line.\n"
+                       "• Ctrl+C to combine multiple selected annotations.\n"
+                       "• Ctrl+Space to confirm selected annotations with top predictions.\n"
+                       "• Ctrl+Shift+mouse wheel to adjust polygon complexity.\n"
+                       "• Ctrl+Delete to remove selected annotations."),
+            
+            "patch": ("Patch Tool\n\n"
+                      "Create point (patch) annotations centered at the cursor.\n"
+                      "• Left-click to place a patch at the mouse location.\n"
+                      "• Hold Ctrl and use the mouse wheel or use the Patch Size box to adjust patch size.\n"
+                      "• A semi-transparent preview shows the patch before placing it."),
+            
+            "rectangle": ("Rectangle Tool\n\n"
+                          "Create rectangular annotations by clicking and dragging.\n"
+                          "• Left-click to set the first corner, then move the mouse to size the rectangle.\n"
+                          "• Left-click again to place the rectangle.\n"
+                          "• Press Backspace to cancel drawing the current rectangle.\n"
+                          "• A semi-transparent preview shows the rectangle while drawing."),
+            
+            "polygon": ("Polygon Tool\n\n"
+                        "Create polygon annotations with multiple vertices.\n"
+                        "• Left-click to set the first vertex, then move the mouse to draw the polygon\n"
+                        "• Hold Ctrl while left-clicking to draw straight-line segments.\n"
+                        "• Left-click again to complete the polygon.\n"
+                        "• Press Backspace to cancel the current polygon.\n"
+                        "• A semi-transparent preview shows the polygon while drawing."),
+            
+            "sam": ("Segment Anything (SAM) Tool\n\n"
+                    "Generates AI-powered segmentations.\n"
+                    "• Left-click to create a working area, then left-click again to confirm.\n"
+                    "\t• Or, press Spacebar to create a working area for the current view.\n"
+                    "• Ctrl+Left-click to add positive points (foreground).\n"
+                    "• Ctrl+Right-click to add negative points (background).\n"
+                    "• Left-click and drag to create a bounding box for prompting.\n"
+                    "• Press Spacebar to generate and confirm the segmentation.\n"
+                    "• Press Backspace to cancel the current operation.\n"
+                    "• Uncertainty can be adjusted in Parameters section.\n"
+                    "• A SAM predictor must be deployed first."),
+            
+            "see_anything": ("See Anything (YOLOE) Tool\n\n"
+                             "Uses YOLOE to detect / segments objects of interest based on visual prompts.\n"
+                             "• Left-click to create a working area, then click again to confirm.\n"
+                             "\t• Or, press Spacebar to create a working area for the current view.\n"
+                             "• Draw rectangles inside the working area to guide detection.\n"
+                             "• Press Spacebar to generate detections using drawn rectangles.\n"
+                             "• Press Spacebar again to confirm annotations or apply SAM refinement.\n"
+                             "• Press Backspace to cancel current operation or clear annotations.\n"
+                             "• Uncertainty can be adjusted in Parameters section.\n"
+                             "• A See Anything (YOLOE) predictor must be deployed first."),
+            
+            "work_area": ("Work Area Tool\n\n"
+                          "Defines regions for detection and segmentation models to run predictions on.\n"
+                          "• Left-click to create a working area, then left-click again to confirm.\n"
+                          "\t• Or, press Spacebar to create a work area from the current view.\n"
+                          "• Hold Ctrl+Shift to show delete buttons for existing work areas.\n"
+                          "• Press Ctrl+Shift+Backspace to clear all work areas.\n"
+                          "• Hold Ctrl+Alt to temporarily view a work area of the current view.\n"
+                          "• Work areas can be used with Tile Batch Inference and other batch operations.\n"
+                          "• All work areas are automatically saved with the image in a Project (JSON) file.")
+        }
+    
         self.toolbar = QToolBar("Tools", self)
         self.toolbar.setOrientation(Qt.Vertical)
         self.toolbar.setFixedWidth(40)
@@ -696,6 +774,7 @@ class MainWindow(QMainWindow):
         # Add tools here with icons
         self.select_tool_action = QAction(self.select_icon, "Select", self)
         self.select_tool_action.setCheckable(True)
+        self.select_tool_action.setToolTip(self.tool_descriptions["select"])
         self.select_tool_action.triggered.connect(self.toggle_tool)
         self.toolbar.addAction(self.select_tool_action)
 
@@ -703,16 +782,19 @@ class MainWindow(QMainWindow):
 
         self.patch_tool_action = QAction(self.patch_icon, "Patch", self)
         self.patch_tool_action.setCheckable(True)
+        self.patch_tool_action.setToolTip(self.tool_descriptions["patch"])
         self.patch_tool_action.triggered.connect(self.toggle_tool)
         self.toolbar.addAction(self.patch_tool_action)
 
         self.rectangle_tool_action = QAction(self.rectangle_icon, "Rectangle", self)
         self.rectangle_tool_action.setCheckable(True)
+        self.rectangle_tool_action.setToolTip(self.tool_descriptions["rectangle"])
         self.rectangle_tool_action.triggered.connect(self.toggle_tool)
         self.toolbar.addAction(self.rectangle_tool_action)
 
         self.polygon_tool_action = QAction(self.polygon_icon, "Polygon", self)
         self.polygon_tool_action.setCheckable(True)
+        self.polygon_tool_action.setToolTip(self.tool_descriptions["polygon"])
         self.polygon_tool_action.triggered.connect(self.toggle_tool)
         self.toolbar.addAction(self.polygon_tool_action)
 
@@ -720,11 +802,13 @@ class MainWindow(QMainWindow):
 
         self.sam_tool_action = QAction(self.sam_icon, "SAM", self)
         self.sam_tool_action.setCheckable(True)
+        self.sam_tool_action.setToolTip(self.tool_descriptions["sam"])
         self.sam_tool_action.triggered.connect(self.toggle_tool)
         self.toolbar.addAction(self.sam_tool_action)
 
         self.see_anything_tool_action = QAction(self.see_anything_icon, "See Anything (YOLOE)", self)
         self.see_anything_tool_action.setCheckable(True)
+        self.see_anything_tool_action.setToolTip(self.tool_descriptions["see_anything"])
         self.see_anything_tool_action.triggered.connect(self.toggle_tool)
         self.toolbar.addAction(self.see_anything_tool_action)
 
@@ -732,6 +816,7 @@ class MainWindow(QMainWindow):
 
         self.work_area_tool_action = QAction(self.workarea_icon, "Work Area", self)
         self.work_area_tool_action.setCheckable(True)
+        self.work_area_tool_action.setToolTip(self.tool_descriptions["work_area"])
         self.work_area_tool_action.triggered.connect(self.toggle_tool)
         self.toolbar.addAction(self.work_area_tool_action)
 
@@ -2196,6 +2281,50 @@ class MainWindow(QMainWindow):
             self.see_anything_deploy_predictor_dialog.exec_()
         except Exception as e:
             QMessageBox.critical(self, "Critical Error", f"{e}")
+            
+    def open_see_anything_deploy_generator_dialog(self):
+        """Open the See Anything Deploy Generator dialog to deploy a See Anything generator."""
+        if not self.image_window.raster_manager.image_paths:
+            QMessageBox.warning(self,
+                                "See Anything (YOLOE)",
+                                "No images are present in the project.")
+            return
+        
+        if not self.annotation_window.annotations_dict:
+            QMessageBox.warning(self,
+                                "See Anything (YOLOE)",
+                                "No annotations are present in the project.")
+            return
+        
+        valid_reference_types = {"PolygonAnnotation", "RectangleAnnotation"}
+        has_valid_reference = False
+
+        # Iterate through the rasters in the main manager.
+        for raster in self.image_window.raster_manager.rasters.values():
+            # The values of our map are sets of annotation type names.
+            # e.g., [{'PointAnnotation'}, {'PolygonAnnotation', 'RectangleAnnotation'}]
+            for types_for_a_label in raster.label_to_types_map.values():
+                # Check if the set of types for this specific label
+                # has any overlap with our valid reference types.
+                if not valid_reference_types.isdisjoint(types_for_a_label):
+                    # A valid reference type was found for at least one label on this raster.
+                    has_valid_reference = True
+                    break  # Exit the inner loop (over types)
+            
+            if has_valid_reference:
+                break  # Exit the outer loop (over rasters)
+
+        if not has_valid_reference:
+            QMessageBox.warning(self,
+                                "No Valid Reference Annotations",
+                                "No images have polygon or rectangle annotations to use as a reference.")
+            return
+
+        try:
+            self.untoggle_all_tools()
+            self.see_anything_deploy_generator_dialog.exec_()
+        except Exception as e:
+            QMessageBox.critical(self, "Critical Error", f"An error occurred: {e}")
 
     def open_see_anything_batch_inference_dialog(self):
         """Open the See Anything Batch Inference dialog to run batch inference with See Anything."""
@@ -2205,16 +2334,22 @@ class MainWindow(QMainWindow):
                                 "No images are present in the project.")
             return
 
-        if not self.see_anything_deploy_predictor_dialog.loaded_model:
+        if not self.see_anything_deploy_generator_dialog.loaded_model:
             QMessageBox.warning(self,
                                 "See Anything (YOLOE) Batch Inference",
-                                "Please deploy a model before running batch inference.")
+                                "Please deploy a generator before running batch inference.")
+            return
+        
+        # Check if there are any annotations
+        if not self.annotation_window.annotations_dict:
+            QMessageBox.warning(self,
+                                "See Anything (YOLOE)",
+                                "Cannot run See Anything (YOLOE) without reference annotations in the project.")
             return
 
         try:
             self.untoggle_all_tools()
-            if self.see_anything_batch_inference_dialog.has_valid_sources():
-                self.see_anything_batch_inference_dialog.exec_()
+            self.see_anything_batch_inference_dialog.exec_()
         except Exception as e:
             QMessageBox.critical(self, "Critical Error", f"{e}")
 

coralnet_toolbox/Rasters/QtRaster.py

@@ -2,6 +2,7 @@ import warnings
 
 import os
 import gc
+from collections import defaultdict
 from typing import Optional, Set, List
 
 import cv2
@@ -13,7 +14,6 @@ from PyQt5.QtCore import QObject
 
 from coralnet_toolbox.utilities import rasterio_open
 from coralnet_toolbox.utilities import rasterio_to_qimage
-from coralnet_toolbox.utilities import rasterio_to_cropped_image
 from coralnet_toolbox.utilities import work_area_to_numpy
 from coralnet_toolbox.utilities import pixmap_to_numpy
 
@@ -67,6 +67,10 @@ class Raster(QObject):
         self.labels: Set = set()
         self.annotation_count = 0
         self.annotations: List = []  # Store the actual annotations
+        self.label_counts = {}  # Store counts of annotations per label
+        
+        self.label_set: Set[str] = set()  # Add sets for efficient lookups
+        self.label_to_types_map = {}  # This replaces annotation_types and annotation_type_set
         
         # Work Area state
         self.work_areas: List = []  # Store work area information
@@ -238,6 +242,7 @@ class Raster(QObject):
     def update_annotation_info(self, annotations: list):
         """
         Update annotation-related information for this raster.
+        This now builds a more powerful cache mapping labels to their annotation types.
         
         Args:
             annotations (list): List of annotation objects
@@ -246,13 +251,59 @@ class Raster(QObject):
         self.annotation_count = len(annotations)
         self.has_annotations = bool(annotations)
         
-        # Check for predictions
-        predictions = [a.machine_confidence for a in annotations if a.machine_confidence != {}]
+        predictions = [a.machine_confidence for a in annotations if a.machine_confidence]
         self.has_predictions = len(predictions) > 0
         
-        # Update labels
-        self.labels = {annotation.label for annotation in annotations if annotation.label}
+        # Clear previous data
+        self.label_counts.clear()
+        self.label_set.clear()
+        self.label_to_types_map.clear() # Clear the new map
+
+        # Use a defaultdict to simplify the aggregation logic
+        temp_map = defaultdict(set)
+
+        for annotation in annotations:
+            # Process label information
+            if annotation.label:
+                if hasattr(annotation.label, 'short_label_code'):
+                    label_name = annotation.label.short_label_code
+                else:
+                    label_name = str(annotation.label)
+                
+                # Update label counts and the set of all labels
+                self.label_counts[label_name] = self.label_counts.get(label_name, 0) + 1
+                self.label_set.add(label_name)
+
+                # Process annotation type information and link it to the label
+                anno_type = annotation.__class__.__name__
+                temp_map[label_name].add(anno_type)
+
+        # Convert defaultdict back to a regular dict for the final attribute
+        self.label_to_types_map = dict(temp_map)
         
+    @property
+    def annotation_types(self) -> dict:
+        """
+        Computes a simple count of each annotation type on-the-fly.
+        This property provides backward compatibility for features like the tooltip
+        without needing to store this data permanently.
+        
+        Returns:
+            dict: A dictionary mapping annotation type names to their counts.
+                e.g., {'PolygonAnnotation': 5, 'PointAnnotation': 2}
+        """
+        type_counts = defaultdict(int)
+        # The self.label_to_types_map structure is {'label': {'type1', 'type2'}}
+        # This is not ideal for counting total types. We need the original annotations list.
+        if not self.annotations:
+            return {}
+            
+        for annotation in self.annotations:
+            anno_type = annotation.__class__.__name__
+            type_counts[anno_type] += 1
+            
+        return dict(type_counts)
+    
     def matches_filter(self, 
                        search_text="", 
                        search_label="", 
@@ -283,8 +334,9 @@ class Raster(QObject):
             label_match = False
             
             # Check actual annotation labels (always consider these)
-            for label in self.labels:
-                if hasattr(label, 'short_label_code') and search_label in label.short_label_code:
+            # Look for the search label in the label_set instead of self.labels
+            for label_code in self.label_set:
+                if search_label in label_code:
                     label_match = True
                     break