coralnet-toolbox 0.0.73__py2.py3-none-any.whl → 0.0.75__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/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,7 +80,9 @@ 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)
@@ -149,6 +149,26 @@ class RasterTableModel(QAbstractTableModel):
             return Qt.NoItemFlags
             
         return Qt.ItemIsEnabled | Qt.ItemIsSelectable
+    
+    def add_path(self, path: str):
+        """
+        Efficiently add a single path by signaling a row insertion.
+        
+        Args:
+            path (str): The image path to add.
+        """
+        if path in self.raster_manager.image_paths and path not in self.filtered_paths:
+            # The position for the new row is at the end of the current list
+            row_position = len(self.filtered_paths)
+            
+            # Signal that we are about to insert one row at this position
+            self.beginInsertRows(QModelIndex(), row_position, row_position)
+            
+            # Add the data
+            self.filtered_paths.append(path)
+            
+            # Signal that the insertion is complete
+            self.endInsertRows()
             
     def highlight_path(self, path: str, highlighted: bool = True):
         """

coralnet_toolbox/SAM/QtDeployGenerator.py

@@ -168,7 +168,7 @@ class DeployGeneratorDialog(QDialog):
 
         # Image size control
         self.imgsz_spinbox = QSpinBox()
-        self.imgsz_spinbox.setRange(512, 65536)
+        self.imgsz_spinbox.setRange(1024, 65536)
         self.imgsz_spinbox.setSingleStep(1024)
         self.imgsz_spinbox.setValue(self.imgsz)
         layout.addRow("Image Size (imgsz):", self.imgsz_spinbox)
@@ -460,9 +460,6 @@ class DeployGeneratorDialog(QDialog):
             progress_bar.stop_progress()
             progress_bar.close()
 
-        # Exit the dialog box
-        self.accept()
-
     def get_imgsz(self):
         """Get the image size for the model."""
         self.imgsz = self.imgsz_spinbox.value()

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()
@@ -152,7 +158,7 @@ class DeployPredictorDialog(QDialog):
 
         # Image size control
         self.imgsz_spinbox = QSpinBox()
-        self.imgsz_spinbox.setRange(512, 65536)
+        self.imgsz_spinbox.setRange(1024, 65536)
         self.imgsz_spinbox.setSingleStep(1024)
         self.imgsz_spinbox.setValue(self.imgsz)
         layout.addRow("Image Size (imgsz):", self.imgsz_spinbox)
@@ -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()
@@ -348,8 +358,6 @@ class DeployPredictorDialog(QDialog):
             progress_bar.stop_progress()
             progress_bar.close()
 
-        self.accept()
-
     def resize_image(self, image):
         """
         Resize the image to the specified size.