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

coralnet_toolbox/AutoDistill/QtDeployModel.py

@@ -52,7 +52,7 @@ class DeployModelDialog(QDialog):
         self.annotation_window = main_window.annotation_window
 
         self.setWindowIcon(get_icon("coral.png"))
-        self.setWindowTitle("AutoDistill Deploy Model (Ctrl + 5)")
+        self.setWindowTitle("AutoDistill Deploy Model (Ctrl + 6)")
         self.resize(400, 325)
 
         # Initialize variables
@@ -350,18 +350,29 @@ class DeployModelDialog(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):
         """

coralnet_toolbox/Explorer/QtDataItem.py

@@ -272,7 +272,7 @@ class AnnotationDataItem:
         
         self.embedding_x = embedding_x if embedding_x is not None else 0.0
         self.embedding_y = embedding_y if embedding_y is not None else 0.0
-        self.embedding_id = embedding_id if embedding_id is not None else 0
+        self.embedding_id = embedding_id
         
         self._is_selected = False
         self._preview_label = None

coralnet_toolbox/Explorer/QtExplorer.py

@@ -16,7 +16,7 @@ from PyQt5.QtWidgets import (QVBoxLayout, QHBoxLayout, QGraphicsView, QScrollAre
                              QGraphicsScene, QPushButton, QComboBox, QLabel, QWidget,
                              QMainWindow, QSplitter, QGroupBox, QSlider, QMessageBox,
                              QApplication, QGraphicsRectItem, QRubberBand, QMenu,
-                             QWidgetAction, QToolButton, QAction)
+                             QWidgetAction, QToolButton, QAction, QDoubleSpinBox)
 
 from coralnet_toolbox.Explorer.QtFeatureStore import FeatureStore
 from coralnet_toolbox.Explorer.QtDataItem import AnnotationDataItem
@@ -28,6 +28,7 @@ from coralnet_toolbox.Explorer.QtSettingsWidgets import UncertaintySettingsWidge
 from coralnet_toolbox.Explorer.QtSettingsWidgets import MislabelSettingsWidget
 from coralnet_toolbox.Explorer.QtSettingsWidgets import EmbeddingSettingsWidget
 from coralnet_toolbox.Explorer.QtSettingsWidgets import AnnotationSettingsWidget
+from coralnet_toolbox.Explorer.QtSettingsWidgets import DuplicateSettingsWidget
 
 from coralnet_toolbox.Annotations.QtRectangleAnnotation import RectangleAnnotation
 
@@ -68,6 +69,8 @@ class EmbeddingViewer(QWidget):
     mislabel_parameters_changed = pyqtSignal(dict) 
     find_uncertain_requested = pyqtSignal()
     uncertainty_parameters_changed = pyqtSignal(dict)
+    find_duplicates_requested = pyqtSignal()
+    duplicate_parameters_changed = pyqtSignal(dict)
 
     def __init__(self, parent=None):
         """Initialize the EmbeddingViewer widget."""
@@ -193,8 +196,37 @@ class EmbeddingViewer(QWidget):
         
         uncertainty_settings_widget.parameters_changed.connect(self.uncertainty_parameters_changed.emit)
         toolbar_layout.addWidget(self.find_uncertain_button)
+        
+        # Create a QToolButton for duplicate detection
+        self.find_duplicates_button = QToolButton()
+        self.find_duplicates_button.setText("Find Duplicates")
+        self.find_duplicates_button.setToolTip(
+            "Find annotations that are likely duplicates based on feature similarity."
+        )
+        self.find_duplicates_button.setPopupMode(QToolButton.MenuButtonPopup)
+        self.find_duplicates_button.setToolButtonStyle(Qt.ToolButtonTextOnly)
+        self.find_duplicates_button.setStyleSheet(
+            "QToolButton::menu-indicator { "
+            "subcontrol-position: right center; "
+            "subcontrol-origin: padding; "
+            "left: -4px; }"
+        )
+
+        run_duplicates_action = QAction("Find Duplicates", self)
+        run_duplicates_action.triggered.connect(self.find_duplicates_requested.emit)
+        self.find_duplicates_button.setDefaultAction(run_duplicates_action)
+
+        duplicate_settings_widget = DuplicateSettingsWidget()
+        duplicate_menu = QMenu(self)
+        duplicate_widget_action = QWidgetAction(duplicate_menu)
+        duplicate_widget_action.setDefaultWidget(duplicate_settings_widget)
+        duplicate_menu.addAction(duplicate_widget_action)
+        self.find_duplicates_button.setMenu(duplicate_menu)
+        
+        duplicate_settings_widget.parameters_changed.connect(self.duplicate_parameters_changed.emit)
+        toolbar_layout.addWidget(self.find_duplicates_button)
     
-        # Add a strech and separator
+        # Add a stretch and separator
         toolbar_layout.addStretch()
         toolbar_layout.addWidget(self._create_separator())
 
@@ -293,6 +325,7 @@ class EmbeddingViewer(QWidget):
 
         self.find_mislabels_button.setEnabled(points_exist)
         self.find_uncertain_button.setEnabled(points_exist and self.is_uncertainty_analysis_available)
+        self.find_duplicates_button.setEnabled(points_exist)
         self.center_on_selection_button.setEnabled(points_exist and selection_exists)
 
         if self.isolated_mode:
@@ -348,6 +381,7 @@ class EmbeddingViewer(QWidget):
         self.center_on_selection_button.setEnabled(False)  # Disable center button
         self.find_mislabels_button.setEnabled(False)
         self.find_uncertain_button.setEnabled(False)
+        self.find_duplicates_button.setEnabled(False)
 
         self.isolate_button.show()
         self.isolate_button.setEnabled(False)
@@ -851,7 +885,7 @@ class AnnotationViewer(QWidget):
                     
                 # Show resize handles for Rectangle annotations
                 if isinstance(annotation_to_select, RectangleAnnotation):
-                    explorer.annotation_window.set_selected_tool('select') # Accidently unselects in AnnotationWindow
+                    explorer.annotation_window.set_selected_tool('select')  # Accidentally unselects in AnnotationWindow
                     explorer.annotation_window.select_annotation(annotation_to_select, quiet_mode=True)
                     select_tool = explorer.annotation_window.tools.get('select')
 
@@ -1584,6 +1618,7 @@ class ExplorerWindow(QMainWindow):
         self.mislabel_params = {'k': 20, 'threshold': 0.6}
         self.uncertainty_params = {'confidence': 0.6, 'margin': 0.1}
         self.similarity_params = {'k': 30}
+        self.duplicate_params = {'threshold': 0.05}
         
         self.data_item_cache = {}  # Cache for AnnotationDataItem objects
 
@@ -1744,6 +1779,8 @@ class ExplorerWindow(QMainWindow):
         self.model_settings_widget.selection_changed.connect(self.on_model_selection_changed)
         self.embedding_viewer.find_uncertain_requested.connect(self.find_uncertain_annotations)
         self.embedding_viewer.uncertainty_parameters_changed.connect(self.on_uncertainty_params_changed)
+        self.embedding_viewer.find_duplicates_requested.connect(self.find_duplicate_annotations)
+        self.embedding_viewer.duplicate_parameters_changed.connect(self.on_duplicate_params_changed)
         self.annotation_viewer.find_similar_requested.connect(self.find_similar_annotations)
         self.annotation_viewer.similarity_settings_widget.parameters_changed.connect(self.on_similarity_params_changed)
         
@@ -1887,6 +1924,12 @@ class ExplorerWindow(QMainWindow):
         """Updates the stored parameters for uncertainty analysis."""
         self.uncertainty_params = params
         print(f"Uncertainty parameters updated: {self.uncertainty_params}")
+
+    @pyqtSlot(dict)
+    def on_duplicate_params_changed(self, params):
+        """Updates the stored parameters for duplicate detection."""
+        self.duplicate_params = params
+        print(f"Duplicate detection parameters updated: {self.duplicate_params}")
         
     @pyqtSlot(dict)
     def on_similarity_params_changed(self, params):
@@ -2067,6 +2110,98 @@ class ExplorerWindow(QMainWindow):
 
         finally:
             QApplication.restoreOverrideCursor()
+
+    def find_duplicate_annotations(self):
+        """
+        Identifies annotations that are likely duplicates based on feature similarity.
+        It uses a nearest-neighbor approach in the high-dimensional feature space.
+        For each group of duplicates found, it selects all but one "original".
+        """
+        threshold = self.duplicate_params.get('threshold', 0.05)
+
+        if not self.embedding_viewer.points_by_id or len(self.embedding_viewer.points_by_id) < 2:
+            QMessageBox.information(self, 
+                                    "Not Enough Data", 
+                                    "This feature requires at least 2 points in the embedding viewer.")
+            return
+
+        items_in_view = list(self.embedding_viewer.points_by_id.values())
+        data_items_in_view = [p.data_item for p in items_in_view]
+
+        model_info = self.model_settings_widget.get_selected_model()
+        model_name, feature_mode = model_info if isinstance(model_info, tuple) else (model_info, "default")
+        sanitized_model_name = os.path.basename(model_name).replace(' ', '_')
+        sanitized_feature_mode = feature_mode.replace(' ', '_').replace('/', '_')
+        model_key = f"{sanitized_model_name}_{sanitized_feature_mode}"
+
+        # Make cursor busy
+        QApplication.setOverrideCursor(Qt.WaitCursor)
+        try:
+            index = self.feature_store._get_or_load_index(model_key)
+            if index is None:
+                QMessageBox.warning(self, "Error", "Could not find a valid feature index for the current model.")
+                return
+
+            features_dict, _ = self.feature_store.get_features(data_items_in_view, model_key)
+            if not features_dict:
+                QMessageBox.warning(self, "Error", "Could not retrieve features for the items in view.")
+                return
+
+            query_ann_ids = list(features_dict.keys())
+            query_vectors = np.array([features_dict[ann_id] for ann_id in query_ann_ids]).astype('float32')
+
+            # Find the 2 nearest neighbors for each vector. D = squared L2 distances.
+            D, I = index.search(query_vectors, 2)
+
+            # Use a Disjoint Set Union (DSU) data structure to group duplicates.
+            parent = {ann_id: ann_id for ann_id in query_ann_ids}
+            
+            # Helper functions for DSU
+            def find_set(v):
+                if v == parent[v]:
+                    return v
+                parent[v] = find_set(parent[v])
+                return parent[v]
+            
+            def unite_sets(a, b):
+                a = find_set(a)
+                b = find_set(b)
+                if a != b:
+                    parent[b] = a
+            
+            id_map = self.feature_store.get_faiss_index_to_annotation_id_map(model_key)
+
+            for i, ann_id in enumerate(query_ann_ids):
+                neighbor_faiss_idx = I[i, 1]  # The second result is the nearest neighbor
+                distance = D[i, 1]
+
+                if distance < threshold:
+                    neighbor_ann_id = id_map.get(neighbor_faiss_idx)
+                    if neighbor_ann_id and neighbor_ann_id in parent:
+                        unite_sets(ann_id, neighbor_ann_id)
+            
+            # Group annotations by their set representative
+            groups = {}
+            for ann_id in query_ann_ids:
+                root = find_set(ann_id)
+                if root not in groups:
+                    groups[root] = []
+                groups[root].append(ann_id)
+
+            copies_to_select = set()
+            for root_id, group_ids in groups.items():
+                if len(group_ids) > 1:
+                    # Sort IDs to consistently pick the same "original".
+                    # Sorting strings is reliable.
+                    sorted_ids = sorted(group_ids)
+                    # The first ID is the original, add the rest to the selection.
+                    copies_to_select.update(sorted_ids[1:])
+            
+            print(f"Found {len(copies_to_select)} duplicate annotations.")
+            self.embedding_viewer.render_selection_from_ids(copies_to_select)
+
+        finally:
+            QApplication.restoreOverrideCursor()
             
     def find_uncertain_annotations(self):
         """
@@ -2658,6 +2793,7 @@ class ExplorerWindow(QMainWindow):
             norm_y = (embedded_features[i, 1] - min_vals[1]) / range_vals[1] if range_vals[1] > 0 else 0.5
             item.embedding_x = (norm_x * scale_factor) - (scale_factor / 2)
             item.embedding_y = (norm_y * scale_factor) - (scale_factor / 2)
+            item.embedding_id = i
 
     def run_embedding_pipeline(self):
         """
@@ -2813,6 +2949,10 @@ class ExplorerWindow(QMainWindow):
             self.current_data_items = [
                 item for item in self.current_data_items if item.annotation.id not in deleted_ann_ids
             ]
+            # Also update the annotation viewer's list to keep it in sync
+            self.annotation_viewer.all_data_items = [
+                item for item in self.annotation_viewer.all_data_items if item.annotation.id not in deleted_ann_ids
+            ]
             for ann_id in deleted_ann_ids:
                 if ann_id in self.data_item_cache:
                     del self.data_item_cache[ann_id]

coralnet_toolbox/Explorer/QtSettingsWidgets.py

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

coralnet_toolbox/MachineLearning/DeployModel/QtDetect.py

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

coralnet_toolbox/MachineLearning/DeployModel/QtSegment.py

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

coralnet_toolbox/MachineLearning/ExportDataset/QtBase.py

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

coralnet_toolbox/MachineLearning/ExportDataset/QtClassify.py

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