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

coralnet_toolbox/QtProgressBar.py

@@ -1,8 +1,6 @@
 import warnings
 
-import time
-
-from PyQt5.QtCore import pyqtSignal
+from PyQt5.QtCore import pyqtSignal, QPropertyAnimation, QEventLoop
 from PyQt5.QtWidgets import QProgressBar, QVBoxLayout, QDialog, QPushButton, QApplication
 
 warnings.filterwarnings("ignore", category=DeprecationWarning)
@@ -112,16 +110,35 @@ class ProgressBar(QDialog):
     def update_progress(self, new_title=None):
         """
         Increment the progress by one step.
-        Updates the UI and checks if progress is complete.
+        Updates the UI intermittently to improve performance and checks if progress is complete.
         """
         if new_title is not None:
             self.setWindowTitle(new_title)
             
-        if not self.canceled:
-            self.value += 1
+        if self.canceled:
+            return
+
+        self.value += 1
+
+        # --- Performance Improvement ---
+        # To avoid excessive UI repaints that slow down the process, we only update
+        # the visual progress bar periodically. This aims for about 100 updates
+        # over the entire range, ensuring a smooth look without bogging down the main task.
+        # 'max(1, ...)' ensures we always have an interval of at least 1.
+        update_interval = max(1, self.max_value // 100)
+
+        # We update the bar visually only under two conditions:
+        # 1. It's the very last step, to ensure it always finishes at 100%.
+        # 2. The current value is a multiple of our calculated interval.
+        is_last_step = self.value >= self.max_value
+        is_update_step = self.value % update_interval == 0
+
+        if is_update_step or is_last_step:
             self.progress_bar.setValue(self.value)
-            if self.value >= self.max_value:
-                self.stop_progress()
+            
+            # This is crucial. It processes pending events, allowing the GUI to
+            # redraw with the new progress value and to respond to user input,
+            # like clicking the 'Cancel' button.
             QApplication.processEvents()
             
     def update_progress_percentage(self, percentage):
@@ -141,30 +158,38 @@ class ProgressBar(QDialog):
             
     def finish_progress(self, duration_ms=500):
         """
-        Animate the progress bar to its maximum value regardless of current value.
-        This creates a visual effect of the progress bar completing over a short duration.
+        Animate the progress bar to its maximum value using a non-blocking animation.
+        This creates a smooth visual effect of completion without freezing the UI.
         
         Args:
             duration_ms: The duration in milliseconds for the animation (default: 500)
         """
-        
-        # Calculate the steps and delay
-        start_value = self.value
-        steps_needed = self.max_value - start_value
-        if steps_needed <= 0:
-            self.progress_bar.setValue(self.max_value)
-            QApplication.processEvents()
+        # If the progress is already complete, just set the final value and exit.
+        if self.value >= self.max_value:
+            self.stop_progress()
             return
-            
-        # Calculate delay between steps (minimum 1ms)
-        delay = max(duration_ms / steps_needed / 1000, 0.001)
-        
-        # Animate the progress
-        for current in range(start_value + 1, self.max_value + 1):
-            self.value = current
-            self.progress_bar.setValue(current)
-            QApplication.processEvents()
-            time.sleep(delay)
+
+        # --- Non-Blocking Animation using QPropertyAnimation ---
+        # QPropertyAnimation is the standard Qt way to animate widget properties.
+        # It runs on the main event loop, so it does not freeze the application
+        # like the previous time.sleep() implementation. The property name "value"
+        # is passed as a bytes object (b"value").
+        self.animation = QPropertyAnimation(self.progress_bar, b"value")
+        self.animation.setDuration(duration_ms)
+        self.animation.setStartValue(self.value)
+        self.animation.setEndValue(self.max_value)
+        self.animation.start()
+
+        # We run a local event loop that waits for the animation's 'finished'
+        # signal. This ensures that the animation completes visually before
+        # this method returns control to the calling code, which is often
+        # the desired behavior for a "finishing" step.
+        loop = QEventLoop()
+        self.animation.finished.connect(loop.quit)
+        loop.exec_()
+
+        # Finally, update our internal state variable to match the final progress.
+        self.value = self.max_value
 
     def stop_progress(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

@@ -20,8 +20,9 @@ class RasterTableModel(QAbstractTableModel):
     Custom table model for displaying a list of Raster objects.
     """
     # Column indices
-    FILENAME_COL = 0
-    ANNOTATION_COUNT_COL = 1
+    CHECKBOX_COL = 0
+    FILENAME_COL = 1
+    ANNOTATION_COUNT_COL = 2
     
     # Row colors
     HIGHLIGHTED_COLOR = QColor(173, 216, 230)  # Light blue
@@ -39,13 +40,10 @@ class RasterTableModel(QAbstractTableModel):
         self.raster_manager = raster_manager
         self.filtered_paths: List[str] = []
         
-        # We'll remove this separate tracking mechanism to avoid inconsistency
-        # self.highlighted_paths: Set[str] = set()
-        
-        self.column_headers = ["Image Name", "Annotations"]
+        self.column_headers = ["\u2713", "Image Name", "Annotations"]
         
         # Column widths
-        self.column_widths = [-1, 120]  # -1 means stretch
+        self.column_widths = [30, -1, 120]  # -1 means stretch
         
         # Connect to manager signals
         self.raster_manager.rasterAdded.connect(self.on_raster_added)
@@ -82,14 +80,16 @@ class RasterTableModel(QAbstractTableModel):
         raster.set_display_name(max_length=25)
         
         if role == Qt.DisplayRole:
-            if index.column() == self.FILENAME_COL:
+            if index.column() == self.CHECKBOX_COL:
+                return "\u2713" if raster.checkbox_state else ""
+            elif index.column() == self.FILENAME_COL:
                 return raster.display_name
             elif index.column() == self.ANNOTATION_COUNT_COL:
                 return str(raster.annotation_count)
                 
         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):
         """

coralnet_toolbox/SAM/QtDeployPredictor.py

@@ -142,6 +142,12 @@ class DeployPredictorDialog(QDialog):
         """
         group_box = QGroupBox("Parameters")
         layout = QFormLayout()
+        
+        # Allow holes dropdown
+        self.allow_holes_dropdown = QComboBox()
+        self.allow_holes_dropdown.addItems(["True", "False"])
+        self.allow_holes_dropdown.setCurrentIndex(1)  # Default to False
+        layout.addRow("Allow Holes:", self.allow_holes_dropdown)
 
         # Resize image dropdown
         self.resize_image_dropdown = QComboBox()
@@ -236,6 +242,10 @@ class DeployPredictorDialog(QDialog):
         group_box.setLayout(layout)
         self.layout.addWidget(group_box)
 
+    def get_allow_holes(self):
+        """Return the current setting for allowing holes."""
+        return self.allow_holes_dropdown.currentText() == "True"
+    
     def initialize_uncertainty_threshold(self):
         """Initialize the uncertainty threshold slider with the current value"""
         current_value = self.main_window.get_uncertainty_thresh()