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

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

@@ -4,12 +4,13 @@ warnings.filterwarnings("ignore", category=DeprecationWarning)
 
 import os
 import re
+import ctypes
 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,
@@ -94,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
 )
 
@@ -130,6 +132,9 @@ class MainWindow(QMainWindow):
 
     def __init__(self, __version__):
         super().__init__()
+        
+        # Get the process ID
+        self.pid = os.getpid()
 
         # Define icons
         self.coral_icon = get_icon("coral.png")
@@ -254,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)
@@ -618,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)
@@ -670,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)
@@ -692,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)
 
@@ -699,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)
 
@@ -716,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)
 
@@ -728,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)
 
@@ -2192,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."""
@@ -2201,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}")
 
@@ -2329,6 +2468,62 @@ class MainWindow(QMainWindow):
             msg.exec_()
         except Exception as e:
             QMessageBox.critical(self, "Critical Error", f"{e}")
+            
+    def check_windows_gdi_count(self):
+        """Calculate and print the number of GDI objects for the current process on Windows."""        
+        # 1. Check if the OS is Windows. If not, return early.
+        if os.name != 'nt':
+            return
+        
+        # Load necessary libraries
+        kernel32 = ctypes.WinDLL('kernel32', use_last_error=True)
+        user32 = ctypes.WinDLL('user32', use_last_error=True)
+
+        # Define constants
+        PROCESS_QUERY_INFORMATION = 0x0400
+        GR_GDIOBJECTS = 0
+
+        process_handle = None
+        try:
+            # 2. Get a handle to the process from its PID
+            process_handle = kernel32.OpenProcess(PROCESS_QUERY_INFORMATION, False, self.pid)
+            
+            if not process_handle:
+                error_code = ctypes.get_last_error()
+                raise RuntimeError(f"Failed to open PID {self.pid}. Error code: {error_code}")
+
+            # 3. Use the handle to get the GDI object count
+            gdi_count = user32.GetGuiResources(process_handle, GR_GDIOBJECTS)
+            
+            if gdi_count >= 9500:  # GDI limit
+                self.show_gdi_limit_warning()
+
+        except Exception as e:
+            pass
+
+        finally:
+            # 4. CRITICAL: Always close the handle when you're done
+            if process_handle:
+                kernel32.CloseHandle(process_handle)
+                
+        return
+            
+    def show_gdi_limit_warning(self):
+        """
+        Show a warning dialog if the GDI limit is reached.
+        """
+        try:
+            self.untoggle_all_tools()
+            msg = QMessageBox()
+            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!"
+            )
+            msg.setStandardButtons(QMessageBox.Ok)
+            msg.exec_()
+        except Exception as e:
+            QMessageBox.critical(self, "Critical Error", f"{e}")
 
     def open_snake_game_dialog(self):
         """

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
             

coralnet_toolbox/Rasters/RasterTableModel.py

@@ -89,7 +89,7 @@ class RasterTableModel(QAbstractTableModel):
                 
         elif role == Qt.TextAlignmentRole:
             return Qt.AlignCenter
-            
+        
         elif role == Qt.FontRole:
             # Bold the selected raster's text
             if raster.is_selected:
@@ -106,12 +106,40 @@ class RasterTableModel(QAbstractTableModel):
                 
         elif role == Qt.ToolTipRole:
             if index.column() == self.FILENAME_COL:
-                # Include full path and metadata in tooltip
                 dimensions = raster.metadata.get('dimensions', f"{raster.width}x{raster.height}")
-                return (f"Path: {path}\n"
-                        f"Dimensions: {dimensions}\n"
-                        f"Has Annotations: {'Yes' if raster.has_annotations else 'No'}\n"
-                        f"Has Predictions: {'Yes' if raster.has_predictions else 'No'}")
+                
+                tooltip_parts = [
+                    f"<b>Path:</b> {path}",
+                    f"<b>Dimensions:</b> {dimensions}",
+                    f"<b>Annotations:</b> {'Yes' if raster.has_annotations else 'No'}",
+                    f"<b>Predictions:</b> {'Yes' if raster.has_predictions else 'No'}"
+                ]
+
+                if raster.has_work_areas():
+                    tooltip_parts.append(f"<b>Work Areas:</b> {raster.count_work_items()}")
+
+                return "<br>".join(tooltip_parts)
+
+            elif index.column() == self.ANNOTATION_COUNT_COL and raster.annotation_count > 0:
+                tooltip_text = f"<b>Total annotations:</b> {raster.annotation_count}"
+                
+                # Add annotation counts per label using a for loop
+                if hasattr(raster, 'label_counts') and raster.label_counts:
+                    label_items = []
+                    for label, count in raster.label_counts.items():
+                        label_items.append(f"<li>{label}: {count}</li>")
+                    label_counts_text = "".join(label_items)
+                    tooltip_text += f"<br><br><b>Annotations by label:</b><ul>{label_counts_text}</ul>"
+                
+                # Add annotation counts per type using a for loop
+                if hasattr(raster, 'annotation_types') and raster.annotation_types:
+                    type_items = []
+                    for type_name, count in raster.annotation_types.items():
+                        type_items.append(f"<li>{type_name}: {count}</li>")
+                    type_counts_text = "".join(type_items)
+                    tooltip_text += f"<br><b>Annotations by type:</b><ul>{type_counts_text}</ul>"
+                
+                return tooltip_text
                 
         return None
         

coralnet_toolbox/SAM/QtBatchInference.py

@@ -35,8 +35,6 @@ class BatchInferenceDialog(QDialog):
         self.deploy_model_dialog = None
         self.loaded_model = None
 
-        self.annotations = []
-        self.prepared_patches = []
         self.image_paths = []
 
         self.layout = QVBoxLayout(self)

coralnet_toolbox/SAM/QtDeployGenerator.py

@@ -384,18 +384,29 @@ class DeployGeneratorDialog(QDialog):
 
     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):
         """