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

coralnet_toolbox/QtImageWindow.py

@@ -1,22 +1,18 @@
 import warnings
 
 import os
-import gc
 from contextlib import contextmanager
 
 import rasterio
 
-from PyQt5.QtGui import QImage, QPixmap
-from PyQt5.QtCore import Qt, pyqtSignal, QTimer, QPoint, QThreadPool, QItemSelectionModel
+from PyQt5.QtCore import Qt, pyqtSignal, QTimer, QPoint, QThreadPool, QItemSelectionModel, QModelIndex
 from PyQt5.QtWidgets import (QSizePolicy, QMessageBox, QCheckBox, QWidget, QVBoxLayout,
                              QLabel, QComboBox, QHBoxLayout, QTableView, QHeaderView, QApplication, 
-                             QMenu, QButtonGroup, QAbstractItemView, QGroupBox, QPushButton, 
-                             QStyle, QFormLayout, QFrame)
-
-from coralnet_toolbox.Rasters import Raster, RasterManager, ImageFilter, RasterTableModel
+                             QMenu, QButtonGroup, QGroupBox, QPushButton, QStyle, 
+                             QFormLayout, QFrame)
 
+from coralnet_toolbox.Rasters import RasterManager, ImageFilter, RasterTableModel
 from coralnet_toolbox.QtProgressBar import ProgressBar
-
 from coralnet_toolbox.Icons import get_icon
 
 
@@ -30,11 +26,24 @@ warnings.filterwarnings("ignore", category=rasterio.errors.NotGeoreferencedWarni
 
 
 class NoArrowKeyTableView(QTableView):
+    # Custom signal to be emitted only on a left-click
+    leftClicked = pyqtSignal(QModelIndex)
+
     def keyPressEvent(self, event):
         if event.key() in (Qt.Key_Up, Qt.Key_Down):
             event.ignore()
             return
         super().keyPressEvent(event)
+
+    def mousePressEvent(self, event):
+        # On a left mouse press, emit our custom signal
+        if event.button() == Qt.LeftButton:
+            index = self.indexAt(event.pos())
+            if index.isValid():
+                self.leftClicked.emit(index)
+        # Call the base class implementation to handle standard behavior
+        # like row selection and context menu triggers.
+        super().mousePressEvent(event)
         
 
 class ImageWindow(QWidget):
@@ -256,10 +265,11 @@ class ImageWindow(QWidget):
         self.table_model = RasterTableModel(self.raster_manager, self)
         self.tableView.setModel(self.table_model)
         
-        # Set column widths - removed checkbox column, adjust accordingly
-        self.tableView.horizontalHeader().setSectionResizeMode(0, QHeaderView.Stretch)
-        self.tableView.setColumnWidth(1, 120)
-        self.tableView.horizontalHeader().setSectionResizeMode(1, QHeaderView.Fixed)
+        # Set column widths
+        self.tableView.horizontalHeader().setSectionResizeMode(0, QHeaderView.ResizeToContents)  # Checkmark column
+        self.tableView.horizontalHeader().setSectionResizeMode(1, QHeaderView.Stretch)  # Filename column
+        self.tableView.setColumnWidth(2, 120)  # Annotation column
+        self.tableView.horizontalHeader().setSectionResizeMode(2, QHeaderView.Fixed)
         
         # Style the header
         self.tableView.horizontalHeader().setStyleSheet("""
@@ -271,7 +281,7 @@ class ImageWindow(QWidget):
         """)
         
         # Connect signals for clicking
-        self.tableView.pressed.connect(self.on_table_pressed)
+        self.tableView.leftClicked.connect(self.on_table_pressed)
         self.tableView.doubleClicked.connect(self.on_table_double_clicked)
         
         # Add table view to the layout
@@ -413,59 +423,62 @@ class ImageWindow(QWidget):
     #
     
     def on_table_pressed(self, index):
-        """Handle a single click on the table view."""
+        """Handle a single left-click on the table view with complex modifier support."""
         if not index.isValid():
             return
-        
-        # Get the path at the clicked row
+
         path = self.table_model.get_path_at_row(index.row())
         if not path:
             return
         
-        # Get keyboard modifiers
         modifiers = QApplication.keyboardModifiers()
-        
-        # Handle highlighting logic
-        if modifiers & Qt.ControlModifier:
-            # Ctrl+Click: Toggle highlight for the clicked row
+        current_row = index.row()
+
+        # Define conditions for modifiers
+        has_ctrl = bool(modifiers & Qt.ControlModifier)
+        has_shift = bool(modifiers & Qt.ShiftModifier)
+
+        if has_shift:
+            # This block handles both Shift+Click and Ctrl+Shift+Click.
+            # First, determine the paths in the selection range.
+            range_paths = []
+            if self.last_highlighted_row >= 0:
+                start = min(self.last_highlighted_row, current_row)
+                end = max(self.last_highlighted_row, current_row)
+                for r in range(start, end + 1):
+                    p = self.table_model.get_path_at_row(r)
+                    if p:
+                        range_paths.append(p)
+            else:
+                # If there's no anchor, the range is just the clicked item.
+                range_paths.append(path)
+
+            if not has_ctrl:
+                # Case 1: Simple Shift+Click. Clears previous highlights 
+                # and selects only the new range.
+                self.table_model.set_highlighted_paths(range_paths)
+            else:
+                # Case 2: Ctrl+Shift+Click. Adds the new range to the
+                # existing highlighted rows without clearing them.
+                for p in range_paths:
+                    self.table_model.highlight_path(p, True)
+        
+        elif has_ctrl:
+            # Case 3: Ctrl+Click. Toggles a single row's highlight state
+            # and sets it as the new anchor for future shift-clicks.
             raster = self.raster_manager.get_raster(path)
             if raster:
                 self.table_model.highlight_path(path, not raster.is_highlighted)
-                # Update highlighted count
-                self.update_highlighted_count_label()
-                
-        elif modifiers & Qt.ShiftModifier:
-            # Shift+Click: Highlight range from last highlighted to current
-            if self.last_highlighted_row >= 0:
-                # Get the current row and last highlighted row
-                current_row = index.row()
-                
-                # Calculate range (handle both directions)
-                start_row = min(self.last_highlighted_row, current_row)
-                end_row = max(self.last_highlighted_row, current_row)
-                
-                # Highlight the range
-                for row in range(start_row, end_row + 1):
-                    path_to_highlight = self.table_model.get_path_at_row(row)
-                    if path_to_highlight:
-                        self.table_model.highlight_path(path_to_highlight, True)
-            else:
-                # No previous selection, just highlight the current row
-                self.table_model.highlight_path(path, True)
-                
-            # Update the last highlighted row
-            self.last_highlighted_row = index.row()
-            
-            # Update highlighted count
-            self.update_highlighted_count_label()
+            self.last_highlighted_row = current_row
+        
         else:
-            # Regular click: Clear all highlights and highlight only this row
-            self.table_model.clear_highlights()
-            self.table_model.highlight_path(path, True)
-            self.last_highlighted_row = index.row()
-            
-            # Update highlighted count
-            self.update_highlighted_count_label()
+            # Case 4: Plain Click. Clears everything and highlights only
+            # the clicked row, setting it as the new anchor.
+            self.table_model.set_highlighted_paths([path])
+            self.last_highlighted_row = current_row
+        
+        # Finally, update the count label after any changes.
+        self.update_highlighted_count_label()
 
     def on_table_double_clicked(self, index):
         """Handle double click on table view (selects image and loads it)."""
@@ -521,6 +534,24 @@ class ImageWindow(QWidget):
         """Handler for when an image is loaded."""
         self.selected_image_path = path
         
+    def on_toggle(self, new_state: bool):
+            """
+            Sets the checked state for all currently highlighted rows.
+
+            Args:
+                new_state (bool): The new state to set (True for checked, False for unchecked).
+            """
+            highlighted_paths = self.table_model.get_highlighted_paths()
+            if not highlighted_paths:
+                return
+
+            for path in highlighted_paths:
+                raster = self.raster_manager.get_raster(path)
+                if raster:
+                    raster.checkbox_state = new_state
+                    # Notify the model to update the view for this specific raster
+                    self.table_model.update_raster_data(path)
+            
     #
     # Public methods
     #
@@ -562,7 +593,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
@@ -960,28 +991,46 @@ class ImageWindow(QWidget):
         
     def show_context_menu(self, position):
         """
-        Show the context menu for the table.
+        Show the context menu for the table, including the toggle check state action.
         
         Args:
             position (QPoint): Position to show the menu
         """
+        # Get the path corresponding to the right-clicked row
+        index = self.tableView.indexAt(position)
+        path_at_cursor = self.table_model.get_path_at_row(index.row()) if index.isValid() else None
+
+        # Get the currently highlighted paths from the model
         highlighted_paths = self.table_model.get_highlighted_paths()
-        if not highlighted_paths:
-            # If no highlights, highlight the row under the cursor only
-            index = self.tableView.indexAt(position)
-            if index.isValid():
-                path = self.table_model.get_path_at_row(index.row())
-                if path:
-                    self.table_model.set_highlighted_paths([path])
-                    self.last_highlighted_row = index.row()
-                    highlighted_paths = [path]
-        else:
-            # If any highlights, ensure all highlighted rows are used (no change needed)
-            self.table_model.set_highlighted_paths(highlighted_paths)
+
+        # If the user right-clicked on a row that wasn't already highlighted,
+        # then we assume they want to act on this row alone.
+        if path_at_cursor and path_at_cursor not in highlighted_paths:
+            self.table_model.set_highlighted_paths([path_at_cursor])
+            self.last_highlighted_row = index.row()
+            highlighted_paths = [path_at_cursor]
+        
+        # If no rows are highlighted, do nothing.
         if not highlighted_paths:
             return
+
         context_menu = QMenu(self)
         count = len(highlighted_paths)
+        
+        # Add the check/uncheck action
+        raster_under_cursor = self.raster_manager.get_raster(path_at_cursor)
+        if raster_under_cursor:
+            is_checked = raster_under_cursor.checkbox_state
+            if is_checked:
+                action_text = f"Uncheck {count} Highlighted Image{'s' if count > 1 else ''}"
+            else:
+                action_text = f"Check {count} Highlighted Image{'s' if count > 1 else ''}"
+            toggle_check_action = context_menu.addAction(action_text)
+            toggle_check_action.triggered.connect(lambda: self.on_toggle(not is_checked))
+
+        context_menu.addSeparator()
+
+        # Add existing delete actions
         delete_images_action = context_menu.addAction(f"Delete {count} Highlighted Image{'s' if count > 1 else ''}")
         delete_images_action.triggered.connect(lambda: self.delete_highlighted_images())
         delete_annotations_action = context_menu.addAction(
@@ -1182,26 +1231,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)
@@ -485,7 +485,19 @@ class LabelWindow(QWidget):
         self.scroll_content.setFixedWidth(self.labels_per_row * self.label_width)
 
     def reorganize_labels(self):
-        """Rearrange labels in the grid layout based on the current order and labels_per_row."""
+        """
+        Rearrange labels in the grid layout based on the current order and labels_per_row.
+        """
+        # First, clear the existing layout to remove any lingering widgets.
+        # This prevents references to deleted widgets from persisting in the layout.
+        while self.grid_layout.count():
+            item = self.grid_layout.takeAt(0)
+            widget = item.widget()
+            if widget:
+                # Setting the parent to None removes the widget from the layout's control.
+                widget.setParent(None)
+
+        # Now, add the current labels from the model back into the clean layout.
         for i, label in enumerate(self.labels):
             row = i // self.labels_per_row
             col = i % self.labels_per_row

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,26 @@ 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 len(self.label_window.labels) <= 1:
+            QMessageBox.warning(self,
+                                "See Anything (YOLOE)",
+                                "At least one reference label is required for 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 +2310,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}")
 
@@ -2383,7 +2494,9 @@ class MainWindow(QMainWindow):
             msg.setWindowIcon(self.coral_icon)
             msg.setWindowTitle("GDI Limit Reached")
             msg.setText(
-                "The GDI limit has been reached! Please immediately save your work, close, and reopen the application!"
+                "The GDI limit is getting dangerously close to being reached (this is a known issue). "
+                "Please immediately save your progress, close, and re-open the application. Failure to do so may "
+                "result in data loss."
             )
             msg.setStandardButtons(QMessageBox.Ok)
             msg.exec_()