coralnet-toolbox 0.0.75__py2.py3-none-any.whl → 0.0.77__py2.py3-none-any.whl

coralnet_toolbox/IO/QtImportImages.py

@@ -50,7 +50,6 @@ class ImportImages:
     
     def _process_image_files(self, file_names):
         """Helper method to process a list of image files with progress tracking."""
-        # Make the cursor busy
         QApplication.setOverrideCursor(Qt.WaitCursor)
 
         progress_bar = ProgressBar(self.image_window, title="Importing Images")
@@ -58,30 +57,24 @@ class ImportImages:
         progress_bar.start_progress(len(file_names))
 
         try:
-            # Keep track of successfully imported images
             imported_paths = []
             
-            # Add images to the image window's raster manager
+            # Add images directly to the manager without emitting signals
             for file_name in file_names:
-                # Check if the image is already in the raster manager
                 if file_name not in self.image_window.raster_manager.image_paths:
-                    try:
-                        # Use the image window's add_image method which handles the raster manager
-                        if self.image_window.add_image(file_name):
-                            imported_paths.append(file_name)
-                    except Exception as e:
-                        print(f"Warning: Could not import image {file_name}. Error: {e}")
+                    # Call the manager directly to add the raster silently,
+                    # bypassing ImageWindow.add_image and its signal handlers.
+                    if self.image_window.raster_manager.add_raster(file_name, emit_signal=False):
+                        imported_paths.append(file_name)
                 else:
-                    # Image already exists
                     imported_paths.append(file_name)
 
-                # Update the progress bar
                 progress_bar.update_progress()
 
-            # Apply filtering to update the view
+            # After the silent loop, manually update the UI exactly once.
+            self.image_window.update_search_bars()
             self.image_window.filter_images()
             
-            # Show the last imported image if any were imported
             if imported_paths:
                 self.image_window.load_image_by_path(imported_paths[-1])
 
@@ -89,7 +82,6 @@ class ImportImages:
         except Exception as e:
             self._show_error_message(str(e))
         finally:
-            # Restore the cursor to the default cursor
             QApplication.restoreOverrideCursor()
             progress_bar.stop_progress()
             progress_bar.close()

coralnet_toolbox/IO/QtOpenProject.py

@@ -163,46 +163,42 @@ class OpenProject(QDialog):
         # Exit
         self.accept()
 
+    # In: QtOpenProject.py
+
     def import_images(self, images_data, legacy_workareas=None):
         """Import images, states, and work areas from the given data."""
         if not images_data:
             return
 
-        # Determine if the format is old (list of strings) or new (list of dicts)
         is_new_format = isinstance(images_data[0], dict)
-        
         image_paths = [img['path'] for img in images_data] if is_new_format else images_data
         
         if not all([os.path.exists(path) for path in image_paths]):
             image_paths, self.updated_paths = UpdateImagePaths.update_paths(image_paths)
         
-        # Start progress bar
         total_images = len(image_paths)
         progress_bar = ProgressBar(self.image_window, title="Importing Images")
         progress_bar.show()
         progress_bar.start_progress(total_images)
 
         try:
-            # Create a map for quick data lookup if using the new format
             image_data_map = {img['path']: img for img in images_data} if is_new_format else {}
 
-            # Add images to the image window's raster manager one by one
+            # Add images directly to the manager without emitting signals
             for path in image_paths:
-                self.image_window.add_image(path)
+                # Call the manager directly to add the raster silently
+                self.image_window.raster_manager.add_raster(path, emit_signal=False) 
+                
                 raster = self.image_window.raster_manager.get_raster(path)
                 if not raster:
+                    progress_bar.update_progress()
                     continue
 
-                # If using the new format, apply saved state and work areas
                 if is_new_format and path in image_data_map:
                     data = image_data_map[path]
                     state = data.get('state', {})
                     work_areas_list = data.get('work_areas', [])
-
-                    # Apply raster state
                     raster.checkbox_state = state.get('checkbox_state', False)
-                    
-                    # Import work areas for this image
                     for work_area_data in work_areas_list:
                         try:
                             work_area = WorkArea.from_dict(work_area_data, path)
@@ -210,10 +206,8 @@ class OpenProject(QDialog):
                         except Exception as e:
                             print(f"Warning: Could not import work area {work_area_data}: {str(e)}")
                 
-                # Update the progress bar
                 progress_bar.update_progress()
-            
-            # Handle backward compatibility for old, top-level work areas
+
             if legacy_workareas:
                 for image_path, work_areas_list in legacy_workareas.items():
                     current_path = self.updated_paths.get(image_path, image_path)
@@ -223,16 +217,18 @@ class OpenProject(QDialog):
                             work_area = WorkArea.from_dict(work_area_data, current_path)
                             raster.add_work_area(work_area)
 
-            # Show the last image if any were imported
-            if self.image_window.raster_manager.image_paths:
-                self.image_window.load_image_by_path(self.image_window.raster_manager.image_paths[-1])
-
         except Exception as e:
             QMessageBox.warning(self.annotation_window,
                                 "Error Importing Image(s)",
                                 f"An error occurred while importing image(s): {str(e)}")
         finally:
-            # Close progress bar
+            # Manually perform the UI updates ONCE for all imported images
+            self.image_window.update_search_bars()
+            self.image_window.filter_images()
+
+            if self.image_window.raster_manager.image_paths:
+                self.image_window.load_image_by_path(self.image_window.raster_manager.image_paths[-1])
+            
             progress_bar.stop_progress()
             progress_bar.close()
 

coralnet_toolbox/MachineLearning/ImportDataset/QtBase.py

@@ -346,6 +346,8 @@ class Base(QDialog):
         self.button_box.rejected.connect(self.reject)
         self.layout.addWidget(self.button_box)
 
+    # In: QtBase.py
+
     def browse_data_yaml(self):
         """Open a file dialog to select the data YAML file and populate advanced options."""
         options = QFileDialog.Options()
@@ -358,22 +360,40 @@ class Base(QDialog):
         try:
             with open(file_path, 'r') as file:
                 data = yaml.safe_load(file)
-            class_names = data.get('names', [])
-            if not class_names:
-                QMessageBox.warning(self, "Warning", "Could not find a 'names' list in the selected YAML file.")
+            
+            names_data = data.get('names')
+            if not names_data:
+                QMessageBox.warning(self, "Warning", "Could not find a 'names' entry in the selected YAML file.")
                 return
 
+            # Handle both dictionary and list formats for class names
+            names_to_display = []
+            if isinstance(names_data, dict):
+                # If it's a dictionary (e.g., {0: 'coral'}), extract the values, sorting by key
+                # to preserve the intended class order.
+                names_to_display = [str(names_data[key]) for key in sorted(names_data.keys())]
+            elif isinstance(names_data, list):
+                # If it's already a list, use it directly.
+                names_to_display = [str(name) for name in names_data]
+            else:
+                # Handle any other unexpected format.
+                QMessageBox.warning(self, "Format Error", 
+                                    f"The 'names' entry in the YAML has an unexpected format: {type(names_data)}.")
+                return
+            
             self.yaml_path_label.setText(file_path)
             yaml_dir = os.path.dirname(file_path)
             self.output_dir_label.setText(yaml_dir)
             self.output_folder_name.setText("data")
 
+            # Clear any existing checkboxes before adding new ones
             for checkbox in self.class_checkboxes:
                 self.class_layout.removeWidget(checkbox)
                 checkbox.deleteLater()
             self.class_checkboxes.clear()
 
-            for name in class_names:
+            # Create checkboxes using the processed list of names
+            for name in names_to_display:
                 checkbox = QCheckBox(name)
                 checkbox.setChecked(True)
                 self.class_layout.addWidget(checkbox)
@@ -504,8 +524,11 @@ class Base(QDialog):
         added_paths = []
         progress_bar.set_title(f"Adding {len(image_paths)} images...")
         progress_bar.start_progress(len(image_paths))
+        
         for path in image_paths:
-            if self.image_window.add_image(path):
+            # Call the manager directly to add the raster silently,
+            # bypassing ImageWindow.add_image and its signal handlers.
+            if self.image_window.raster_manager.add_raster(path, emit_signal=False):
                 added_paths.append(path)
             progress_bar.update_progress()
 
@@ -535,19 +558,21 @@ class Base(QDialog):
                                                self.main_window.get_transparency_value())
 
             self.annotation_window.add_annotation_to_dict(annotation)
-            newly_created_annotations.append(annotation)  # Collect created objects
+            newly_created_annotations.append(annotation)
             
             progress_bar.update_progress()
 
-        # --- Call the restored, correct export function ---
         progress_bar.set_title("Exporting annotations.json...")
         self._export_annotations_to_json(newly_created_annotations, self.output_folder)
         
         progress_bar.finish_progress()
         progress_bar.stop_progress()
         progress_bar.close()
-
+        
+        # Manually perform a full UI update exactly once.
+        self.image_window.update_search_bars()
         self.image_window.filter_images()
+
         if added_paths:
             self.image_window.load_image_by_path(added_paths[-1])
             self.image_window.update_image_annotations(added_paths[-1])

coralnet_toolbox/QtAnnotationWindow.py

@@ -401,6 +401,10 @@ class AnnotationWindow(QGraphicsView):
         self.current_image_path = image_path
         self.active_image = True
 
+        # Automatically mark this image as checked when viewed
+        raster.checkbox_state = True
+        self.main_window.image_window.table_model.update_raster_data(image_path)
+
         self.tools["zoom"].reset_zoom()
         self.scene.addItem(QGraphicsPixmapItem(self.pixmap_image))
         self.fitInView(self.scene.sceneRect(), Qt.KeepAspectRatio)

coralnet_toolbox/QtEventFilter.py

@@ -13,7 +13,7 @@ warnings.filterwarnings("ignore", category=DeprecationWarning)
 
 class GlobalEventFilter(QObject):
     def __init__(self, main_window):
-        super().__init__()
+        super().__init__(main_window)
         self.main_window = main_window
         self.label_window = main_window.label_window
         self.annotation_window = main_window.annotation_window
@@ -24,7 +24,7 @@ class GlobalEventFilter(QObject):
         self.segment_deploy_model_dialog = main_window.segment_deploy_model_dialog
         self.sam_deploy_generator_dialog = main_window.sam_deploy_generator_dialog
         self.see_anything_deploy_generator_dialog = main_window.see_anything_deploy_generator_dialog
-        self.auto_distill_deploy_model_dialog = main_window.auto_distill_deploy_model_dialog
+        self.transformers_deploy_model_dialog = main_window.transformers_deploy_model_dialog
         
     def eventFilter(self, obj, event):
         # Check for explorer window first - this applies to all event types
@@ -75,10 +75,10 @@ class GlobalEventFilter(QObject):
                 if event.key() == Qt.Key_5:
                     self.see_anything_deploy_generator_dialog.predict()
                     return True
-                
-                # Handle hotkey for auto distill prediction
+
+                # Handle hotkey for transformers prediction
                 if event.key() == Qt.Key_6:
-                    self.auto_distill_deploy_model_dialog.predict()
+                    self.transformers_deploy_model_dialog.predict()
                     return True
 
                 # Handle annotation cycling hotkeys

coralnet_toolbox/QtImageWindow.py

@@ -667,6 +667,10 @@ class ImageWindow(QWidget):
                 # Get the raster
                 raster = self.raster_manager.get_raster(image_path)
                 
+                # Mark as checked when viewed
+                raster.checkbox_state = True
+                self.table_model.update_raster_data(image_path)
+                
                 # Update selection
                 self.selected_image_path = image_path
                 self.table_model.set_selected_path(image_path)

coralnet_toolbox/QtMainWindow.py

@@ -9,6 +9,9 @@ import requests
 
 from packaging import version
 
+import torch
+
+from PyQt5 import sip
 from PyQt5.QtGui import QIcon, QMouseEvent
 from PyQt5.QtCore import Qt, pyqtSignal, QEvent, QSize, QPoint
 from PyQt5.QtWidgets import (QListWidget, QCheckBox, QFrame, QComboBox)
@@ -18,6 +21,7 @@ from PyQt5.QtWidgets import (QMainWindow, QApplication, QToolBar, QAction, QSize
                              QGroupBox)
 
 from coralnet_toolbox.QtEventFilter import GlobalEventFilter
+
 from coralnet_toolbox.QtAnnotationWindow import AnnotationWindow
 from coralnet_toolbox.QtConfidenceWindow import ConfidenceWindow
 from coralnet_toolbox.QtImageWindow import ImageWindow
@@ -99,9 +103,9 @@ from coralnet_toolbox.SeeAnything import (
     BatchInferenceDialog as SeeAnythingBatchInferenceDialog
 )
 
-from coralnet_toolbox.AutoDistill import (
-    DeployModelDialog as AutoDistillDeployModelDialog,
-    BatchInferenceDialog as AutoDistillBatchInferenceDialog
+from coralnet_toolbox.Transformers import (
+    DeployModelDialog as TransformersDeployModelDialog,
+    BatchInferenceDialog as TransformersBatchInferenceDialog
 )
 
 from coralnet_toolbox.CoralNet import (
@@ -114,9 +118,9 @@ from coralnet_toolbox.BreakTime import (
     BreakoutGame
 )
 
-from coralnet_toolbox.Icons import get_icon
+from coralnet_toolbox.QtSystemMonitor import SystemMonitor
 
-from coralnet_toolbox.utilities import get_available_device
+from coralnet_toolbox.Icons import get_icon
 
 
 # ----------------------------------------------------------------------------------------------------------------------
@@ -155,6 +159,7 @@ class MainWindow(QMainWindow):
         self.opaque_icon = get_icon("opaque.png")
         self.all_icon = get_icon("all.png")
         self.parameters_icon = get_icon("parameters.png")
+        self.system_monitor_icon = get_icon("system_monitor.png")
         self.add_icon = get_icon("add.png")
         self.remove_icon = get_icon("remove.png")
         self.edit_icon = get_icon("edit.png")
@@ -193,6 +198,8 @@ class MainWindow(QMainWindow):
         self.label_window = LabelWindow(self)
         self.confidence_window = ConfidenceWindow(self)
         
+        self.system_monitor = None
+        
         self.explorer_window = None  # Initialized in open_explorer_window
 
         # TODO update IO classes to have dialogs
@@ -262,9 +269,9 @@ class MainWindow(QMainWindow):
         self.see_anything_deploy_generator_dialog = SeeAnythingDeployGeneratorDialog(self)
         self.see_anything_batch_inference_dialog = SeeAnythingBatchInferenceDialog(self)
 
-        # Create dialogs (AutoDistill)
-        self.auto_distill_deploy_model_dialog = AutoDistillDeployModelDialog(self)
-        self.auto_distill_batch_inference_dialog = AutoDistillBatchInferenceDialog(self)
+        # Create dialogs (Transformers)
+        self.transformers_deploy_model_dialog = TransformersDeployModelDialog(self)
+        self.transformers_batch_inference_dialog = TransformersBatchInferenceDialog(self)
 
         # Create dialogs (Tile)
         self.classify_tile_dataset_dialog = ClassifyTileDatasetDialog(self)
@@ -601,6 +608,17 @@ class MainWindow(QMainWindow):
         self.ml_segment_video_inference_action = QAction("Segment", self)
         self.ml_segment_video_inference_action.triggered.connect(self.open_segment_video_inference_dialog)
         self.ml_video_inference_menu.addAction(self.ml_segment_video_inference_action) 
+        
+        # Transformers menu
+        self.transformers_menu = self.menu_bar.addMenu("Transformers")
+        # Deploy Model
+        self.transformers_deploy_model_action = QAction("Deploy Model", self)
+        self.transformers_deploy_model_action.triggered.connect(self.open_transformers_deploy_model_dialog)
+        self.transformers_menu.addAction(self.transformers_deploy_model_action)
+        # Batch Inference
+        self.transformers_batch_inference_action = QAction("Batch Inference", self)
+        self.transformers_batch_inference_action.triggered.connect(self.open_transformers_batch_inference_dialog)
+        self.transformers_menu.addAction(self.transformers_batch_inference_action)
 
         # SAM menu
         self.sam_menu = self.menu_bar.addMenu("SAM")
@@ -640,17 +658,6 @@ class MainWindow(QMainWindow):
         self.see_anything_batch_inference_action.triggered.connect(self.open_see_anything_batch_inference_dialog)
         self.see_anything_menu.addAction(self.see_anything_batch_inference_action)
 
-        # Auto Distill menu
-        self.auto_distill_menu = self.menu_bar.addMenu("AutoDistill")
-        # Deploy Model
-        self.auto_distill_deploy_model_action = QAction("Deploy Model", self)
-        self.auto_distill_deploy_model_action.triggered.connect(self.open_auto_distill_deploy_model_dialog)
-        self.auto_distill_menu.addAction(self.auto_distill_deploy_model_action)
-        # Batch Inference
-        self.auto_distill_batch_inference_action = QAction("Batch Inference", self)
-        self.auto_distill_batch_inference_action.triggered.connect(self.open_auto_distill_batch_inference_dialog)
-        self.auto_distill_menu.addAction(self.auto_distill_batch_inference_action)
-
         # Help menu
         self.help_menu = self.menu_bar.addMenu("Help")
 
@@ -659,9 +666,13 @@ class MainWindow(QMainWindow):
         self.check_for_updates_action.triggered.connect(self.open_check_for_updates_dialog)
         self.help_menu.addAction(self.check_for_updates_action)
         # Usage
-        self.usage_action = QAction("Usage", self)
+        self.usage_action = QAction("Usage / Hotkeys", self)
         self.usage_action.triggered.connect(self.open_usage_dialog)
         self.help_menu.addAction(self.usage_action)
+        # System Monitor
+        self.system_monitor_action = QAction("System Monitor", self)
+        self.system_monitor_action.triggered.connect(self.open_system_monitor_dialog)
+        self.help_menu.addAction(self.system_monitor_action)
         # Issues / Feature Requests
         self.create_issue_action = QAction("Issues / Feature Requests", self)
         self.create_issue_action.triggered.connect(self.open_create_new_issue_dialog)
@@ -828,15 +839,15 @@ class MainWindow(QMainWindow):
         self.toolbar.addWidget(spacer)
 
         # Add the device label widget as an action in the toolbar
-        self.devices = get_available_device()
-        self.current_device_index = 0
-        self.device = self.devices[self.current_device_index]
+        self.devices = self.get_available_devices()
+        # Get the 'best' device available
+        self.device = self.devices[-1]
 
         if self.device.startswith('cuda'):
-            if len(self.devices) == 1:
-                device_icon = self.rabbit_icon
-            else:
+            if len([d for d in self.devices if d.endswith('cuda')]) > 1:
                 device_icon = self.rocket_icon
+            else:
+                device_icon = self.rabbit_icon
             device_tooltip = self.device
         elif self.device == 'mps':
             device_icon = self.apple_icon
@@ -1028,9 +1039,9 @@ class MainWindow(QMainWindow):
         self.left_layout.addWidget(self.annotation_window, 85)
         self.left_layout.addWidget(self.label_window, 15)
 
-        # Add widgets to right layout
-        self.right_layout.addWidget(self.image_window, 54)
-        self.right_layout.addWidget(self.confidence_window, 46)
+        # Adjust the right layout with new proportions
+        self.right_layout.addWidget(self.image_window, 54)  # 54% for image window
+        self.right_layout.addWidget(self.confidence_window, 46)  # 46% for confidence window
 
         # Add left and right layouts to main layout
         self.main_layout.addLayout(self.left_layout, 85)
@@ -1054,12 +1065,17 @@ class MainWindow(QMainWindow):
         self.showMaximized()
 
     def closeEvent(self, event):
-        """Ensure the explorer window is closed when the main window closes."""
+        """Ensure the explorer window and system monitor are closed when the main window closes."""
         if self.explorer_window:
             # Setting parent to None prevents it from being deleted with main window
             # before it can be properly handled.
             self.explorer_window.setParent(None)
             self.explorer_window.close()
+        
+        # Close the system monitor if it exists
+        if self.system_monitor:
+            self.system_monitor.close()
+            
         super().closeEvent(event)
 
     def changeEvent(self, event):
@@ -1374,6 +1390,20 @@ class MainWindow(QMainWindow):
             self.sam_tool_action.setChecked(False)
             self.see_anything_tool_action.setChecked(False)
             self.work_area_tool_action.setChecked(False)
+    
+    def get_available_devices(self):
+        """
+        Get available devices
+
+        :return:
+        """
+        devices = ['cpu',]
+        if torch.backends.mps.is_available():
+            devices.append('mps')
+        if torch.cuda.is_available():
+            for i in range(torch.cuda.device_count()):
+                devices.append(f'cuda:{i}')
+        return devices
 
     def toggle_device(self):
         dialog = DeviceSelectionDialog(self.devices, self)
@@ -2211,6 +2241,40 @@ class MainWindow(QMainWindow):
             self.segment_video_inference_dialog.exec_()
         except Exception as e:
             QMessageBox.critical(self, "Critical Error", f"{e}")
+            
+    def open_transformers_deploy_model_dialog(self):
+        """Open the Transformers Deploy Model dialog to deploy an Transformers model."""
+        if not self.image_window.raster_manager.image_paths:
+            QMessageBox.warning(self,
+                                "Transformers Deploy Model",
+                                "No images are present in the project.")
+            return
+
+        try:
+            self.untoggle_all_tools()
+            self.transformers_deploy_model_dialog.exec_()
+        except Exception as e:
+            QMessageBox.critical(self, "Critical Error", f"{e}")
+
+    def open_transformers_batch_inference_dialog(self):
+        """Open the Transformers Batch Inference dialog to run batch inference with Transformers."""
+        if not self.image_window.raster_manager.image_paths:
+            QMessageBox.warning(self,
+                                "Transformers Batch Inference",
+                                "No images are present in the project.")
+            return
+
+        if not self.transformers_deploy_model_dialog.loaded_model:
+            QMessageBox.warning(self,
+                                "Transformers Batch Inference",
+                                "Please deploy a model before running batch inference.")
+            return
+
+        try:
+            self.untoggle_all_tools()
+            self.transformers_batch_inference_dialog.exec_()
+        except Exception as e:
+            QMessageBox.critical(self, "Critical Error", f"{e}")
 
     def open_sam_deploy_predictor_dialog(self):
         """Open the SAM Deploy Predictor dialog to deploy a SAM predictor."""
@@ -2328,40 +2392,16 @@ class MainWindow(QMainWindow):
             self.see_anything_batch_inference_dialog.exec_()
         except Exception as e:
             QMessageBox.critical(self, "Critical Error", f"{e}")
-
-    def open_auto_distill_deploy_model_dialog(self):
-        """Open the AutoDistill Deploy Model dialog to deploy an AutoDistill model."""
-        if not self.image_window.raster_manager.image_paths:
-            QMessageBox.warning(self,
-                                "AutoDistill Deploy Model",
-                                "No images are present in the project.")
-            return
-
-        try:
-            self.untoggle_all_tools()
-            self.auto_distill_deploy_model_dialog.exec_()
-        except Exception as e:
-            QMessageBox.critical(self, "Critical Error", f"{e}")
-
-    def open_auto_distill_batch_inference_dialog(self):
-        """Open the AutoDistill Batch Inference dialog to run batch inference with AutoDistill."""
-        if not self.image_window.raster_manager.image_paths:
-            QMessageBox.warning(self,
-                                "AutoDistill Batch Inference",
-                                "No images are present in the project.")
-            return
-
-        if not self.auto_distill_deploy_model_dialog.loaded_model:
-            QMessageBox.warning(self,
-                                "AutoDistill Batch Inference",
-                                "Please deploy a model before running batch inference.")
-            return
-
-        try:
-            self.untoggle_all_tools()
-            self.auto_distill_batch_inference_dialog.exec_()
-        except Exception as e:
-            QMessageBox.critical(self, "Critical Error", f"{e}")
+            
+    def open_system_monitor_dialog(self):
+        """Open the system system monitor window."""
+        if self.system_monitor is None or sip.isdeleted(self.system_monitor):
+            self.system_monitor = SystemMonitor()
+        
+        # Show the monitor window
+        self.system_monitor.show()
+        self.system_monitor.activateWindow()
+        self.system_monitor.raise_()
             
     def open_usage_dialog(self):
         """Display QMessageBox with link to create new issue on GitHub."""

coralnet_toolbox/QtProgressBar.py

@@ -39,6 +39,7 @@ class ProgressBar(QDialog):
 
         # Create cancel button
         self.cancel_button = QPushButton("Cancel", self)
+        self.cancel_button.setEnabled(False)
         self.cancel_button.clicked.connect(self.cancel)
 
         # Setup layout