coralnet-toolbox 0.0.67__py2.py3-none-any.whl → 0.0.69__py2.py3-none-any.whl

coralnet_toolbox/Explorer/QtFeatureStore.py

@@ -0,0 +1,176 @@
+import os
+import glob
+import sqlite3
+import warnings
+
+import faiss
+
+warnings.filterwarnings("ignore", category=DeprecationWarning)
+
+
+# ----------------------------------------------------------------------------------------------------------------------
+# Viewers
+# ----------------------------------------------------------------------------------------------------------------------
+
+
+class FeatureStore:
+    """
+    Manages storing and retrieving annotation features for MULTIPLE models
+    using a single SQLite database and multiple, model-specific FAISS indexes.
+    """
+    def __init__(self, db_path='feature_store.db', index_path_base='features'):
+        self.db_path = db_path
+        self.index_path_base = index_path_base  # Base name for index files, e.g., 'features'
+        self.conn = sqlite3.connect(self.db_path)
+        self.cursor = self.conn.cursor()
+        self._create_table()
+
+        # A dictionary to hold multiple FAISS indexes, keyed by model_key
+        self.faiss_indexes = {}
+
+    def _create_table(self):
+        """Create the metadata table if it doesn't exist."""
+        self.cursor.execute('''
+            CREATE TABLE IF NOT EXISTS features (
+                annotation_id TEXT NOT NULL,
+                model_key TEXT NOT NULL,
+                faiss_index INTEGER NOT NULL,
+                PRIMARY KEY (annotation_id, model_key)
+            )
+        ''')
+        self.conn.commit()
+
+    def _get_or_load_index(self, model_key):
+        """
+        Retrieves an index from memory or loads it from disk if it exists.
+        Returns the index object or None if not found in memory or on disk.
+        """
+        # 1. Check if the index is already loaded in memory
+        if model_key in self.faiss_indexes:
+            return self.faiss_indexes[model_key]
+
+        # 2. If not in memory, check for a corresponding file on disk
+        index_path = f"{self.index_path_base}_{model_key}.faiss"
+        if os.path.exists(index_path):
+            print(f"Loading existing FAISS index from {index_path}")
+            index = faiss.read_index(index_path)
+            self.faiss_indexes[model_key] = index  # Cache it in memory
+            return index
+
+        # 3. If not in memory or on disk, return None
+        return None
+
+    def add_features(self, data_items, features, model_key):
+        """
+        Adds new features to the store for a specific model.
+        """
+        if not len(features):
+            return
+
+        # Get the specific index for this model, loading it if necessary
+        index = self._get_or_load_index(model_key)
+
+        # If no index exists yet, create one
+        if index is None:
+            feature_dim = features.shape[1]
+            print(f"Creating new FAISS index for model '{model_key}' with dimension {feature_dim}.")
+            index = faiss.IndexFlatL2(feature_dim)
+            self.faiss_indexes[model_key] = index
+
+        # Add vectors to the specific FAISS index
+        start_index = index.ntotal
+        index.add(features.astype('float32'))
+
+        # Add metadata to SQLite. The table already supports multiple models.
+        for i, item in enumerate(data_items):
+            faiss_row_index = start_index + i
+            self.cursor.execute(
+                "INSERT OR REPLACE INTO features (annotation_id, model_key, faiss_index) VALUES (?, ?, ?)",
+                (item.annotation.id, model_key, faiss_row_index)
+            )
+        self.conn.commit()
+        self.save_faiss_index(model_key)  # Save the specific index that was modified
+
+    def get_features(self, data_items, model_key):
+        """
+        Retrieves features for given data items and a specific model.
+        """
+        # Get the specific index for this model
+        index = self._get_or_load_index(model_key)
+
+        if index is None:
+            # No features have ever been stored for this model
+            return {}, data_items
+
+        found_features = {}
+        not_found_items = []
+
+        ids_to_query = [item.annotation.id for item in data_items]
+
+        # Query SQLite for the given model_key
+        placeholders = ','.join('?' for _ in ids_to_query)
+        query = (f"SELECT annotation_id, faiss_index FROM features "
+                 f"WHERE model_key=? AND annotation_id IN ({placeholders})")
+        params = [model_key] + ids_to_query
+        self.cursor.execute(query, params)
+
+        faiss_map = {ann_id: faiss_idx for ann_id, faiss_idx in self.cursor.fetchall()}
+
+        if not faiss_map:
+            return {}, data_items
+
+        # Reconstruct vectors from the correct FAISS index
+        faiss_indices = list(faiss_map.values())
+        retrieved_vectors = index.reconstruct_batch(faiss_indices)
+
+        id_to_vector = {ann_id: retrieved_vectors[i] for i, ann_id in enumerate(faiss_map.keys())}
+
+        for item in data_items:
+            ann_id = item.annotation.id
+            if ann_id in id_to_vector:
+                found_features[ann_id] = id_to_vector[ann_id]
+            else:
+                not_found_items.append(item)
+
+        return found_features, not_found_items
+
+    def get_faiss_index_to_annotation_id_map(self, model_key):
+        """
+        Retrieves a mapping from FAISS row index to annotation_id for a given model.
+        """
+        query = "SELECT faiss_index, annotation_id FROM features WHERE model_key = ?"
+        self.cursor.execute(query, (model_key,))
+        return {faiss_idx: ann_id for faiss_idx, ann_id in self.cursor.fetchall()}
+
+    def save_faiss_index(self, model_key):
+        """Saves a specific FAISS index to disk."""
+        if model_key in self.faiss_indexes:
+            index_to_save = self.faiss_indexes[model_key]
+            index_path = f"{self.index_path_base}_{model_key}.faiss"
+            print(f"Saving FAISS index for '{model_key}' to {index_path}")
+            faiss.write_index(index_to_save, index_path)
+
+    def close(self):
+        """Closes the database connection."""
+        self.conn.close()
+
+    def delete_storage(self):
+        """
+        Closes connection and deletes the DB and ALL FAISS index files.
+        """
+        self.close()
+
+        if os.path.exists(self.db_path):
+            try:
+                os.remove(self.db_path)
+                print(f"Deleted feature database: {self.db_path}")
+            except OSError as e:
+                print(f"Error removing database file {self.db_path}: {e}")
+
+        # Use glob to find and delete all matching index files
+        for index_file in glob.glob(f"{self.index_path_base}_*.faiss"):
+            try:
+                os.remove(index_file)
+                print(f"Deleted FAISS index: {index_file}")
+            except OSError as e:
+                print(f"Error removing index file {index_file}: {e}")

coralnet_toolbox/Explorer/QtSettingsWidgets.py

@@ -1,10 +1,10 @@
 import os
 import warnings
 
-from PyQt5.QtCore import Qt
+from PyQt5.QtCore import Qt, pyqtSignal, pyqtSlot
 from PyQt5.QtWidgets import (QVBoxLayout, QHBoxLayout, QPushButton, QComboBox, QLabel, 
                              QWidget, QGroupBox, QSlider, QListWidget, QTabWidget, 
-                             QLineEdit, QFileDialog, QFormLayout)
+                             QLineEdit, QFileDialog, QFormLayout, QSpinBox)
 
 from coralnet_toolbox.MachineLearning.Community.cfg import get_available_configs
 
@@ -16,6 +16,180 @@ warnings.filterwarnings("ignore", category=DeprecationWarning)
 # ----------------------------------------------------------------------------------------------------------------------
 
 
+class UncertaintySettingsWidget(QWidget):
+    """A widget for configuring uncertainty sampling parameters."""
+    parameters_changed = pyqtSignal(dict)
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setup_ui()
+        # Set a strong focus policy to prevent the menu from closing on interaction
+        self.confidence_slider.setFocusPolicy(Qt.StrongFocus)
+        self.margin_slider.setFocusPolicy(Qt.StrongFocus)
+
+    def setup_ui(self):
+        """Creates the UI controls for the parameters."""
+        main_layout = QFormLayout(self)
+        main_layout.setContentsMargins(10, 10, 10, 10)
+        main_layout.setSpacing(15)
+
+        # 1. Confidence Threshold
+        confidence_layout = QHBoxLayout()
+        self.confidence_slider = QSlider(Qt.Horizontal)
+        self.confidence_slider.setMinimum(0)
+        self.confidence_slider.setMaximum(100)
+        self.confidence_slider.setValue(60)
+        self.confidence_slider.setToolTip(
+            "Find annotations where the model's top guess\n"
+            "has a confidence BELOW this threshold."
+        )
+        self.confidence_label = QLabel("60%")
+        self.confidence_label.setMinimumWidth(40)
+        confidence_layout.addWidget(self.confidence_slider)
+        confidence_layout.addWidget(self.confidence_label)
+        main_layout.addRow("Max Confidence:", confidence_layout)
+
+        # 2. Margin Threshold
+        margin_layout = QHBoxLayout()
+        self.margin_slider = QSlider(Qt.Horizontal)
+        self.margin_slider.setMinimum(0)
+        self.margin_slider.setMaximum(50)
+        self.margin_slider.setValue(10)
+        self.margin_slider.setToolTip(
+            "Find annotations where the confidence difference\n"
+            "between the top two guesses is BELOW this threshold."
+        )
+        self.margin_label = QLabel("10%")
+        self.margin_label.setMinimumWidth(40)
+        margin_layout.addWidget(self.margin_slider)
+        margin_layout.addWidget(self.margin_label)
+        main_layout.addRow("Min Margin:", margin_layout)
+
+        # Connect signals
+        self.confidence_slider.valueChanged.connect(self._emit_parameters)
+        self.margin_slider.valueChanged.connect(self._emit_parameters)
+        self.confidence_slider.valueChanged.connect(
+            lambda v: self.confidence_label.setText(f"{v}%")
+        )
+        self.margin_slider.valueChanged.connect(
+            lambda v: self.margin_label.setText(f"{v}%")
+        )
+
+    @pyqtSlot()
+    def _emit_parameters(self):
+        """Gathers current values and emits them in a dictionary."""
+        params = self.get_parameters()
+        self.parameters_changed.emit(params)
+
+    def get_parameters(self):
+        """Returns the current parameters as a dictionary."""
+        return {
+            'confidence': self.confidence_slider.value() / 100.0,
+            'margin': self.margin_slider.value() / 100.0
+        }
+        
+
+class MislabelSettingsWidget(QWidget):
+    """A widget for configuring mislabel detection parameters."""
+    parameters_changed = pyqtSignal(dict)
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setup_ui()
+        # Set a default value to prevent the menu from closing on interaction
+        self.k_spinbox.setFocusPolicy(Qt.StrongFocus)
+        self.threshold_slider.setFocusPolicy(Qt.StrongFocus)
+
+    def setup_ui(self):
+        """Creates the UI controls for the parameters."""
+        main_layout = QFormLayout(self)
+        main_layout.setContentsMargins(10, 10, 10, 10)
+        main_layout.setSpacing(15)
+
+        # 1. K (Number of Neighbors)
+        self.k_spinbox = QSpinBox()
+        self.k_spinbox.setMinimum(2)
+        self.k_spinbox.setMaximum(50)
+        self.k_spinbox.setValue(5)
+        self.k_spinbox.setToolTip("Number of neighbors to check for each point (K).")
+        main_layout.addRow("Neighbors (K):", self.k_spinbox)
+
+        # 2. Agreement Threshold
+        threshold_layout = QHBoxLayout()
+        self.threshold_slider = QSlider(Qt.Horizontal)
+        self.threshold_slider.setMinimum(0)
+        self.threshold_slider.setMaximum(100)
+        self.threshold_slider.setValue(60)
+        self.threshold_slider.setToolTip(
+            "A point is flagged if the percentage of neighbors\n"
+            "with the same label is BELOW this threshold."
+        )
+
+        self.threshold_label = QLabel("60%")
+        self.threshold_label.setMinimumWidth(40)
+
+        threshold_layout.addWidget(self.threshold_slider)
+        threshold_layout.addWidget(self.threshold_label)
+        main_layout.addRow("Agreement:", threshold_layout)
+        
+        # Connect signals
+        self.k_spinbox.valueChanged.connect(self._emit_parameters)
+        self.threshold_slider.valueChanged.connect(self._emit_parameters)
+        self.threshold_slider.valueChanged.connect(
+            lambda v: self.threshold_label.setText(f"{v}%")
+        )
+    
+    @pyqtSlot()
+    def _emit_parameters(self):
+        """Gathers current values and emits them in a dictionary."""
+        params = self.get_parameters()
+        self.parameters_changed.emit(params)
+
+    def get_parameters(self):
+        """Returns the current parameters as a dictionary."""
+        return {
+            'k': self.k_spinbox.value(),
+            'threshold': self.threshold_slider.value() / 100.0
+        }
+        
+
+class SimilaritySettingsWidget(QWidget):
+    """A widget for configuring similarity search parameters (number of neighbors)."""
+    parameters_changed = pyqtSignal(dict)
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setup_ui()
+        self.k_spinbox.setFocusPolicy(Qt.StrongFocus)
+
+    def setup_ui(self):
+        """Creates the UI controls for the parameters."""
+        main_layout = QFormLayout(self)
+        main_layout.setContentsMargins(10, 10, 10, 10)
+        main_layout.setSpacing(15)
+
+        # K (Number of Neighbors)
+        self.k_spinbox = QSpinBox()
+        self.k_spinbox.setMinimum(1)
+        self.k_spinbox.setMaximum(200)
+        self.k_spinbox.setValue(10)
+        self.k_spinbox.setToolTip("Number of similar items to find (K).")
+        main_layout.addRow("Neighbors (K):", self.k_spinbox)
+
+        # Connect signals
+        self.k_spinbox.valueChanged.connect(self._emit_parameters)
+
+    @pyqtSlot()
+    def _emit_parameters(self):
+        params = self.get_parameters()
+        self.parameters_changed.emit(params)
+
+    def get_parameters(self):
+        return {
+            'k': self.k_spinbox.value()
+        }
+        
+
 class AnnotationSettingsWidget(QGroupBox):
     """Widget for filtering annotations by image, type, and label in a multi-column layout."""
 
@@ -220,6 +394,7 @@ class AnnotationSettingsWidget(QGroupBox):
 
 class ModelSettingsWidget(QGroupBox):
     """Widget containing model selection with tabs for different model sources."""
+    selection_changed = pyqtSignal()
 
     def __init__(self, main_window, parent=None):
         super(ModelSettingsWidget, self).__init__("Model Settings", parent)
@@ -243,21 +418,23 @@ class ModelSettingsWidget(QGroupBox):
         self.model_combo.addItems(["Color Features"])
         self.model_combo.insertSeparator(1)  # Add a separator
 
-        standard_models = ['yolov8n-cls.pt',
-                           'yolov8s-cls.pt',
-                           'yolov8m-cls.pt',
-                           'yolov8l-cls.pt',
-                           'yolov8x-cls.pt',
-                           'yolo11n-cls.pt',
-                           'yolo11s-cls.pt',
-                           'yolo11m-cls.pt',
-                           'yolo11l-cls.pt',
-                           'yolo11x-cls.pt',
-                           'yolo12n-cls.pt',
-                           'yolo12s-cls.pt',
-                           'yolo12m-cls.pt',
-                           'yolo12l-cls.pt',
-                           'yolo12x-cls.pt']
+        standard_models = [
+            'yolov8n-cls.pt',
+            'yolov8s-cls.pt',
+            'yolov8m-cls.pt',
+            'yolov8l-cls.pt',
+            'yolov8x-cls.pt',
+            'yolo11n-cls.pt',
+            'yolo11s-cls.pt',
+            'yolo11m-cls.pt',
+            'yolo11l-cls.pt',
+            'yolo11x-cls.pt',
+            'yolo12n-cls.pt',
+            'yolo12s-cls.pt',
+            'yolo12m-cls.pt',
+            'yolo12l-cls.pt',
+            'yolo12x-cls.pt'
+        ]
 
         self.model_combo.addItems(standard_models)
 
@@ -267,9 +444,6 @@ class ModelSettingsWidget(QGroupBox):
             self.model_combo.addItems(list(community_configs.keys()))
 
         self.model_combo.setCurrentText('Color Features')
-        # Connect selection change to update feature mode field state
-        self.model_combo.currentTextChanged.connect(self._update_feature_mode_state)
-        
         model_select_layout.addRow("Model:", self.model_combo)
         
         self.tabs.addTab(model_select_tab, "Select Model")
@@ -293,18 +467,21 @@ class ModelSettingsWidget(QGroupBox):
 
         main_layout.addWidget(self.tabs)
         
-        # Connect tab change to update feature mode state
-        self.tabs.currentChanged.connect(self._update_feature_mode_state)
+        # Connect all relevant widgets to a single slot that emits the new signal
+        self.model_combo.currentTextChanged.connect(self._on_selection_changed)
+        self.tabs.currentChanged.connect(self._on_selection_changed)
+        self.model_path_edit.textChanged.connect(self._on_selection_changed)
         
         # Add feature extraction mode selection outside of tabs
         feature_mode_layout = QFormLayout()
         self.feature_mode_combo = QComboBox()
         self.feature_mode_combo.addItems(["Predictions", "Embed Features"])
+        self.feature_mode_combo.currentTextChanged.connect(self._on_selection_changed)
         feature_mode_layout.addRow("Feature Mode:", self.feature_mode_combo)
         main_layout.addLayout(feature_mode_layout)
         
-        # Initialize the feature mode state based on current selection
-        self._update_feature_mode_state()
+        # Initialize the feature mode state and emit the first signal
+        self._on_selection_changed()
 
     def browse_for_model(self):
         """Open a file dialog to browse for model files."""
@@ -318,6 +495,12 @@ class ModelSettingsWidget(QGroupBox):
         )
         if file_path:
             self.model_path_edit.setText(file_path)
+            
+    @pyqtSlot()
+    def _on_selection_changed(self):
+        """Central slot to handle any change in model selection and emit a single signal."""
+        self._update_feature_mode_state()
+        self.selection_changed.emit()
 
     def _update_feature_mode_state(self, *args):
         """Update the enabled state of the feature mode field based on the current model selection."""
@@ -457,16 +640,20 @@ class EmbeddingSettingsWidget(QGroupBox):
             self.param2_slider.valueChanged.connect(lambda v: self.param2_value_label.setText(f"{v/10.0:.1f}"))
 
         elif technique == "PCA":
-            # Disable both rows for PCA
+            # Disable both rows for PCA and reset to minimum values
             self.param1_label.setEnabled(False)
             self.param1_slider.setEnabled(False)
             self.param1_value_label.setEnabled(False)
             self.param1_label.setText(" ")
+            self.param1_slider.setValue(self.param1_slider.minimum())
+            self.param1_value_label.setText(str(self.param1_slider.minimum()))
 
             self.param2_label.setEnabled(False)
             self.param2_slider.setEnabled(False)
             self.param2_value_label.setEnabled(False)
             self.param2_label.setText(" ")
+            self.param2_slider.setValue(self.param2_slider.minimum())
+            self.param2_value_label.setText(str(self.param2_slider.minimum()))
 
     def get_embedding_parameters(self):
         """Returns a dictionary of the current embedding parameters."""

coralnet_toolbox/QtEventFilter.py

@@ -26,18 +26,29 @@ class GlobalEventFilter(QObject):
         self.auto_distill_deploy_model_dialog = main_window.auto_distill_deploy_model_dialog
         
     def eventFilter(self, obj, event):
+        # Check for explorer window first - this applies to all event types
+        if hasattr(self.main_window, 'explorer_window') and self.main_window.explorer_window:
+            # Special exception for WASD keys which should always work
+            if event.type() == QEvent.KeyPress and event.key() in [Qt.Key_W, Qt.Key_A, Qt.Key_S, Qt.Key_D] and \
+                event.modifiers() & Qt.ControlModifier:
+                self.label_window.handle_wasd_key(event.key())
+                return True
+            
+            # For all other events when explorer is visible, pass them through
+            return False
+            
+        # Now handle keyboard events
         if event.type() == QEvent.KeyPress:
             if event.modifiers() & Qt.ControlModifier and not (event.modifiers() & Qt.ShiftModifier):
-                
-                # Handle Tab key for switching between Select and Annotation tools
-                if event.key() == Qt.Key_Alt:
-                    self.main_window.switch_back_to_tool()
-                    return True
-                
                 # Handle WASD keys for selecting Label
                 if event.key() in [Qt.Key_W, Qt.Key_A, Qt.Key_S, Qt.Key_D]:
                     self.label_window.handle_wasd_key(event.key())
                     return True
+
+                # Handle Alt key for switching between Select and Annotation tools
+                if event.key() == Qt.Key_Alt:
+                    self.main_window.switch_back_to_tool()
+                    return True
                 
                 # Handle hotkey for image classification prediction
                 if event.key() == Qt.Key_1:
@@ -72,13 +83,14 @@ class GlobalEventFilter(QObject):
                     self.annotation_window.cycle_annotations(1)
                     return True
                 
-                # Delete (backspace or delete key) selected annotations when select tool is active
-                if event.key() == Qt.Key_Delete or event.key() == Qt.Key_Backspace:
-                    if self.main_window.select_tool_action.isChecked():
-                        if self.annotation_window.selected_annotations:
-                            self.annotation_window.delete_selected_annotations()
+            # Delete (backspace or delete key) selected annotations when select tool is active
+            if event.key() == Qt.Key_Delete or event.key() == Qt.Key_Backspace:
+                if self.main_window.select_tool_action.isChecked():
+                    if self.annotation_window.selected_annotations:
+                        self.annotation_window.delete_selected_annotations()
+                    # Consume the event so it doesn't do anything else
                     return True
-                
+            
             # Handle image cycling hotkeys
             if event.key() == Qt.Key_Up and event.modifiers() == (Qt.AltModifier):
                 self.image_window.cycle_previous_image()

coralnet_toolbox/QtLabelWindow.py

@@ -395,23 +395,35 @@ class LabelWindow(QWidget):
         """Update the annotation count display with current selection and total count."""
         annotations = self.annotation_window.get_image_annotations()
         
-        # Check if we're in Explorer mode and get Explorer selections
-        explorer_selected_count = 0
+        # Check if we're in Explorer mode
         if (hasattr(self.main_window, 'explorer_window') and 
             self.main_window.explorer_window and 
             hasattr(self.main_window.explorer_window, 'annotation_viewer')):
-            explorer_selected_count = len(self.main_window.explorer_window.annotation_viewer.selected_widgets)
+            
+            annotation_viewer = self.main_window.explorer_window.annotation_viewer
+
+            # --- REORDERED LOGIC ---
+            # Priority 1: Always check for a selection in Explorer first.
+            explorer_selected_count = len(annotation_viewer.selected_widgets)
+            if explorer_selected_count > 0:
+                if explorer_selected_count == 1:
+                    text = "Annotation: 1"
+                else:
+                    text = f"Annotations: {explorer_selected_count}"
+                self.annotation_count_display.setText(text)
+                return  # Exit early, selection count is most important.
+
+            # Priority 2: If no selection, THEN check for isolation mode.
+            if annotation_viewer.isolated_mode:
+                count = len(annotation_viewer.isolated_widgets)
+                text = f"Annotations: {count}"
+                self.annotation_count_display.setText(text)
+                return  # Exit early
         
-        # Get annotation window selections
+        # --- ORIGINAL FALLBACK LOGIC (Unchanged) ---
         annotation_window_selected_count = len(self.annotation_window.selected_annotations)
         
-        # Prioritize Explorer selections if Explorer is open
-        if explorer_selected_count > 0:
-            if explorer_selected_count == 1:
-                text = f"Annotation: 1"
-            else:
-                text = f"Annotations: {explorer_selected_count}"
-        elif annotation_window_selected_count == 0:
+        if annotation_window_selected_count == 0:
             text = f"Annotations: {len(annotations)}"
         elif annotation_window_selected_count > 1:
             text = f"Annotations: {annotation_window_selected_count}"