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

coralnet_toolbox/IO/QtSaveProject.py

@@ -96,10 +96,9 @@ class SaveProject(QDialog):
 
         try:
             project_data = {
-                'image_paths': self.get_images(),
+                'images': self.get_images(),
                 'labels': self.get_labels(),
-                'annotations': self.get_annotations(),
-                'workareas': self.get_workareas()
+                'annotations': self.get_annotations()
             }
 
             with open(file_path, 'w') as file:
@@ -125,10 +124,10 @@ class SaveProject(QDialog):
         self.accept()
 
     def get_images(self):
-        """Get the list of image paths to export."""
+        """Get the list of image objects, including paths, states, and work areas."""
         # Start the progress bar
         total_images = len(self.image_window.raster_manager.image_paths)
-        progress_bar = ProgressBar(self.label_window, "Exporting Images")
+        progress_bar = ProgressBar(self.label_window, "Exporting Image Data")
         progress_bar.show()
         progress_bar.start_progress(total_images)
 
@@ -137,7 +136,19 @@ class SaveProject(QDialog):
 
             # Loop through all of the image paths
             for image_path in self.image_window.raster_manager.image_paths:
-                export_images.append(image_path)
+                raster = self.image_window.raster_manager.get_raster(image_path)
+                if raster:
+                    # Get work areas for this raster
+                    work_areas_list = [wa.to_dict() for wa in raster.get_work_areas()]
+
+                    image_data = {
+                        'path': image_path,
+                        'state': {
+                            'checkbox_state': raster.checkbox_state
+                        },
+                        'work_areas': work_areas_list
+                    }
+                    export_images.append(image_data)
                 progress_bar.update_progress()
 
         except Exception as e:
@@ -234,42 +245,6 @@ class SaveProject(QDialog):
 
         return export_annotations
 
-    def get_workareas(self):
-        """Get the work areas to export."""
-        # Start progress bar
-        total_rasters = len(self.image_window.raster_manager.image_paths)
-        progress_bar = ProgressBar(self.annotation_window, title="Exporting Work Areas")
-        progress_bar.show()
-        progress_bar.start_progress(total_rasters)
-
-        try:
-            export_workareas = {}
-
-            # Loop through all rasters to get their work areas
-            for image_path in self.image_window.raster_manager.image_paths:
-                raster = self.image_window.raster_manager.get_raster(image_path)
-                if raster and raster.has_work_areas():
-                    work_areas_list = []
-                    for work_area in raster.get_work_areas():
-                        work_areas_list.append(work_area.to_dict())
-                    
-                    if work_areas_list:  # Only add if there are work areas
-                        export_workareas[image_path] = work_areas_list
-                
-                progress_bar.update_progress()
-
-        except Exception as e:
-            QMessageBox.warning(self.annotation_window,
-                                "Error Exporting Work Areas",
-                                f"An error occurred while exporting work areas: {str(e)}")
-
-        finally:
-            # Stop the progress bar
-            progress_bar.stop_progress()
-            progress_bar.close()
-
-        return export_workareas
-
     def get_project_path(self):
         """Get the current project path."""
         return self.current_project_path
@@ -290,4 +265,4 @@ class SaveProject(QDialog):
         """Handle dialog rejection (Cancel or close)"""
         if self.current_project_path:
             self.file_path_edit.setText(self.current_project_path)
-        super().reject()
+        super().reject()

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, 800)
+        self.resize(800, 800)
         self.setWindowIcon(get_icon("coral.png"))
         self.setWindowTitle("Export Dataset")
 

coralnet_toolbox/MachineLearning/ImportDataset/QtBase.py

@@ -35,7 +35,7 @@ class DatasetProcessor(QObject):
     """
     status_changed = pyqtSignal(str, int)
     progress_updated = pyqtSignal(int)
-    processing_complete = pyqtSignal(list, list)
+    processing_complete = pyqtSignal(list, list, list)
     error = pyqtSignal(str)
     finished = pyqtSignal()
 
@@ -47,6 +47,7 @@ class DatasetProcessor(QObject):
         self.import_as = import_as  # 'rectangle' or 'polygon' (target format)
         self.rename_on_conflict = rename_on_conflict
         self.is_running = True
+        self.parsing_errors = []  # To collect errors instead of printing
 
     def stop(self):
         self.is_running = False
@@ -81,7 +82,7 @@ class DatasetProcessor(QObject):
 
             # Step 4: Emit results for GUI to consume
             image_paths = list(image_label_paths.keys())
-            self.processing_complete.emit(raw_annotations, image_paths)
+            self.processing_complete.emit(raw_annotations, image_paths, self.parsing_errors)
 
         except Exception as e:
             # Catch-all for any error during processing
@@ -146,7 +147,7 @@ class DatasetProcessor(QObject):
             with open(label_path, 'r') as file:
                 lines = file.readlines()
 
-            for line in lines:
+            for line_num, line in enumerate(lines):
                 try:
                     parts = list(map(float, line.split()))
                     class_id = int(parts[0])
@@ -195,8 +196,11 @@ class DatasetProcessor(QObject):
 
                     all_raw_annotations.append(raw_ann_data)
                 except (ValueError, IndexError) as e:
-                    # Skip malformed lines and print a warning
-                    print(f"Skipping malformed line in {label_path}: {line.strip()} ({e})")
+                    # Log the malformed line error instead of printing
+                    error_msg = (f"In file '{os.path.basename(label_path)}' on line {line_num + 1}:\n"
+                                 f"Skipped malformed content: '{line.strip()}'\nReason: {e}\n")
+                    self.parsing_errors.append(error_msg)
+
 
             # Update progress after each image
             self.progress_updated.emit(i + 1)
@@ -290,11 +294,14 @@ class Base(QDialog):
         )
         if file_path:
             self.yaml_path_label.setText(file_path)
-            # Auto-fill output directory and folder name if not set
+            # Auto-fill output directory to be the PARENT of the yaml's directory
             if not self.output_dir_label.text():
-                self.output_dir_label.setText(os.path.dirname(file_path))
+                parent_dir = os.path.dirname(os.path.dirname(file_path))
+                self.output_dir_label.setText(parent_dir)
             if not self.output_folder_name.text():
-                self.output_folder_name.setText("project")
+                # Suggest a folder name based on the yaml file's parent folder
+                project_name = os.path.basename(os.path.dirname(file_path))
+                self.output_folder_name.setText(f"{project_name}_imported")
 
     def browse_output_dir(self):
         """Open a dialog to select the output directory."""
@@ -309,6 +316,16 @@ class Base(QDialog):
         if not all([self.yaml_path_label.text(), self.output_dir_label.text(), self.output_folder_name.text()]):
             QMessageBox.warning(self, "Error", "Please fill in all fields.")
             return
+        
+        # This check for existing output is still relevant
+        self.output_folder = os.path.join(self.output_dir_label.text(), self.output_folder_name.text())
+        if os.path.exists(self.output_folder) and os.listdir(self.output_folder):
+            reply = QMessageBox.question(self,
+                                         'Directory Not Empty',
+                                         f"The directory '{self.output_folder}' is not empty. Continue?",
+                                         QMessageBox.Yes | QMessageBox.No, QMessageBox.No)
+            if reply == QMessageBox.No:
+                return
 
         # Pre-scan for duplicates
         yaml_path = self.yaml_path_label.text()
@@ -358,16 +375,7 @@ class Base(QDialog):
                 rename_files = False
             else:  # User closed the dialog
                 return
-
-        self.output_folder = os.path.join(self.output_dir_label.text(), self.output_folder_name.text())
-        if os.path.exists(self.output_folder) and os.listdir(self.output_folder):
-            reply = QMessageBox.question(self,
-                                         'Directory Not Empty',
-                                         f"The directory '{self.output_folder}' is not empty. Continue?",
-                                         QMessageBox.Yes | QMessageBox.No, QMessageBox.No)
-            if reply == QMessageBox.No:
-                return
-
+        
         self.button_box.setEnabled(False)
         QApplication.setOverrideCursor(Qt.WaitCursor)
 
@@ -393,6 +401,7 @@ class Base(QDialog):
         self.worker.error.connect(self.on_error)
         self.worker.status_changed.connect(self.on_status_changed)
         self.worker.progress_updated.connect(self.on_progress_update)
+        # Connect to the updated signal
         self.worker.processing_complete.connect(self.on_processing_complete)
         self.thread.start()
 
@@ -403,7 +412,7 @@ class Base(QDialog):
     def on_progress_update(self, value):
         self.progress_bar.set_value(value)
 
-    def on_processing_complete(self, raw_annotations, image_paths):
+    def on_processing_complete(self, raw_annotations, image_paths, parsing_errors):
         added_paths = []
         for path in image_paths:
             if self.image_window.add_image(path):
@@ -447,9 +456,20 @@ class Base(QDialog):
             self.image_window.update_image_annotations(added_paths[-1])
             self.annotation_window.load_annotations()
 
-        QMessageBox.information(self, 
-                                "Dataset Imported",
-                                "Dataset has been successfully imported.")
+        # --- Display a summary message, including any parsing errors ---
+        summary_message = "Dataset has been successfully imported."
+        if parsing_errors:
+            # If there were errors, show a more detailed dialog
+            QMessageBox.warning(self, 
+                                "Import Complete with Warnings",
+                                f"{summary_message}\n\nHowever, {len(parsing_errors)} issue(s) were found "
+                                "in the label files. Please review them below.",
+                                details='\n'.join(parsing_errors))
+        else:
+            # Otherwise, show a simple info box
+            QMessageBox.information(self, 
+                                    "Dataset Imported",
+                                    summary_message)
 
     def export_annotations_to_json(self, annotations_list, output_dir):
         """

coralnet_toolbox/MachineLearning/VideoInference/QtBase.py

@@ -320,10 +320,6 @@ class Base(QDialog):
             # If video already loaded, update output dir for widget
             if self.video_path:
                 self.video_region_widget.load_video(self.video_path, dir_name)
-            else:
-                self.update_record_buttons()
-        else:
-            self.update_record_buttons()
 
     def browse_model(self):
         """Open file dialog to select model file (filtered to .pt, .pth)."""

coralnet_toolbox/QtEventFilter.py

@@ -91,9 +91,20 @@ class GlobalEventFilter(QObject):
                 
             # Delete (backspace or delete key) selected annotations when select tool is active
             if event.key() == Qt.Key_Delete or event.key() == Qt.Key_Backspace:
+                # First check if the select tool is active
                 if self.main_window.select_tool_action.isChecked():
+                    selected_tool = self.annotation_window.selected_tool
+                    select_tool = self.annotation_window.tools[selected_tool]
+                    # Get the active subtool if it exists, pass to its keyPressEvent
+                    if hasattr(select_tool, 'active_subtool') and select_tool.active_subtool:
+                        select_tool.active_subtool.keyPressEvent(event)
+                        return True
+                            
+                    # Otherwise, proceed with deletion if there are selected annotations
                     if self.annotation_window.selected_annotations:
                         self.annotation_window.delete_selected_annotations()
+                        return True
+                    
                     # Consume the event so it doesn't do anything else
                     return True
             

coralnet_toolbox/QtImageWindow.py

@@ -1,22 +1,18 @@
 import warnings
 
 import os
-import gc
 from contextlib import contextmanager
 
 import rasterio
 
-from PyQt5.QtGui import QImage, QPixmap
-from PyQt5.QtCore import Qt, pyqtSignal, QTimer, QPoint, QThreadPool, QItemSelectionModel
+from PyQt5.QtCore import Qt, pyqtSignal, QTimer, QPoint, QThreadPool, QItemSelectionModel, QModelIndex
 from PyQt5.QtWidgets import (QSizePolicy, QMessageBox, QCheckBox, QWidget, QVBoxLayout,
                              QLabel, QComboBox, QHBoxLayout, QTableView, QHeaderView, QApplication, 
-                             QMenu, QButtonGroup, QAbstractItemView, QGroupBox, QPushButton, 
-                             QStyle, QFormLayout, QFrame)
-
-from coralnet_toolbox.Rasters import Raster, RasterManager, ImageFilter, RasterTableModel
+                             QMenu, QButtonGroup, QGroupBox, QPushButton, QStyle, 
+                             QFormLayout, QFrame)
 
+from coralnet_toolbox.Rasters import RasterManager, ImageFilter, RasterTableModel
 from coralnet_toolbox.QtProgressBar import ProgressBar
-
 from coralnet_toolbox.Icons import get_icon
 
 
@@ -30,11 +26,24 @@ warnings.filterwarnings("ignore", category=rasterio.errors.NotGeoreferencedWarni
 
 
 class NoArrowKeyTableView(QTableView):
+    # Custom signal to be emitted only on a left-click
+    leftClicked = pyqtSignal(QModelIndex)
+
     def keyPressEvent(self, event):
         if event.key() in (Qt.Key_Up, Qt.Key_Down):
             event.ignore()
             return
         super().keyPressEvent(event)
+
+    def mousePressEvent(self, event):
+        # On a left mouse press, emit our custom signal
+        if event.button() == Qt.LeftButton:
+            index = self.indexAt(event.pos())
+            if index.isValid():
+                self.leftClicked.emit(index)
+        # Call the base class implementation to handle standard behavior
+        # like row selection and context menu triggers.
+        super().mousePressEvent(event)
         
 
 class ImageWindow(QWidget):
@@ -256,10 +265,11 @@ class ImageWindow(QWidget):
         self.table_model = RasterTableModel(self.raster_manager, self)
         self.tableView.setModel(self.table_model)
         
-        # Set column widths - removed checkbox column, adjust accordingly
-        self.tableView.horizontalHeader().setSectionResizeMode(0, QHeaderView.Stretch)
-        self.tableView.setColumnWidth(1, 120)
-        self.tableView.horizontalHeader().setSectionResizeMode(1, QHeaderView.Fixed)
+        # Set column widths
+        self.tableView.horizontalHeader().setSectionResizeMode(0, QHeaderView.ResizeToContents)  # Checkmark column
+        self.tableView.horizontalHeader().setSectionResizeMode(1, QHeaderView.Stretch)  # Filename column
+        self.tableView.setColumnWidth(2, 120)  # Annotation column
+        self.tableView.horizontalHeader().setSectionResizeMode(2, QHeaderView.Fixed)
         
         # Style the header
         self.tableView.horizontalHeader().setStyleSheet("""
@@ -271,7 +281,7 @@ class ImageWindow(QWidget):
         """)
         
         # Connect signals for clicking
-        self.tableView.pressed.connect(self.on_table_pressed)
+        self.tableView.leftClicked.connect(self.on_table_pressed)
         self.tableView.doubleClicked.connect(self.on_table_double_clicked)
         
         # Add table view to the layout
@@ -413,59 +423,62 @@ class ImageWindow(QWidget):
     #
     
     def on_table_pressed(self, index):
-        """Handle a single click on the table view."""
+        """Handle a single left-click on the table view with complex modifier support."""
         if not index.isValid():
             return
-        
-        # Get the path at the clicked row
+
         path = self.table_model.get_path_at_row(index.row())
         if not path:
             return
         
-        # Get keyboard modifiers
         modifiers = QApplication.keyboardModifiers()
-        
-        # Handle highlighting logic
-        if modifiers & Qt.ControlModifier:
-            # Ctrl+Click: Toggle highlight for the clicked row
+        current_row = index.row()
+
+        # Define conditions for modifiers
+        has_ctrl = bool(modifiers & Qt.ControlModifier)
+        has_shift = bool(modifiers & Qt.ShiftModifier)
+
+        if has_shift:
+            # This block handles both Shift+Click and Ctrl+Shift+Click.
+            # First, determine the paths in the selection range.
+            range_paths = []
+            if self.last_highlighted_row >= 0:
+                start = min(self.last_highlighted_row, current_row)
+                end = max(self.last_highlighted_row, current_row)
+                for r in range(start, end + 1):
+                    p = self.table_model.get_path_at_row(r)
+                    if p:
+                        range_paths.append(p)
+            else:
+                # If there's no anchor, the range is just the clicked item.
+                range_paths.append(path)
+
+            if not has_ctrl:
+                # Case 1: Simple Shift+Click. Clears previous highlights 
+                # and selects only the new range.
+                self.table_model.set_highlighted_paths(range_paths)
+            else:
+                # Case 2: Ctrl+Shift+Click. Adds the new range to the
+                # existing highlighted rows without clearing them.
+                for p in range_paths:
+                    self.table_model.highlight_path(p, True)
+        
+        elif has_ctrl:
+            # Case 3: Ctrl+Click. Toggles a single row's highlight state
+            # and sets it as the new anchor for future shift-clicks.
             raster = self.raster_manager.get_raster(path)
             if raster:
                 self.table_model.highlight_path(path, not raster.is_highlighted)
-                # Update highlighted count
-                self.update_highlighted_count_label()
-                
-        elif modifiers & Qt.ShiftModifier:
-            # Shift+Click: Highlight range from last highlighted to current
-            if self.last_highlighted_row >= 0:
-                # Get the current row and last highlighted row
-                current_row = index.row()
-                
-                # Calculate range (handle both directions)
-                start_row = min(self.last_highlighted_row, current_row)
-                end_row = max(self.last_highlighted_row, current_row)
-                
-                # Highlight the range
-                for row in range(start_row, end_row + 1):
-                    path_to_highlight = self.table_model.get_path_at_row(row)
-                    if path_to_highlight:
-                        self.table_model.highlight_path(path_to_highlight, True)
-            else:
-                # No previous selection, just highlight the current row
-                self.table_model.highlight_path(path, True)
-                
-            # Update the last highlighted row
-            self.last_highlighted_row = index.row()
-            
-            # Update highlighted count
-            self.update_highlighted_count_label()
+            self.last_highlighted_row = current_row
+        
         else:
-            # Regular click: Clear all highlights and highlight only this row
-            self.table_model.clear_highlights()
-            self.table_model.highlight_path(path, True)
-            self.last_highlighted_row = index.row()
-            
-            # Update highlighted count
-            self.update_highlighted_count_label()
+            # Case 4: Plain Click. Clears everything and highlights only
+            # the clicked row, setting it as the new anchor.
+            self.table_model.set_highlighted_paths([path])
+            self.last_highlighted_row = current_row
+        
+        # Finally, update the count label after any changes.
+        self.update_highlighted_count_label()
 
     def on_table_double_clicked(self, index):
         """Handle double click on table view (selects image and loads it)."""
@@ -521,6 +534,24 @@ class ImageWindow(QWidget):
         """Handler for when an image is loaded."""
         self.selected_image_path = path
         
+    def on_toggle(self, new_state: bool):
+            """
+            Sets the checked state for all currently highlighted rows.
+
+            Args:
+                new_state (bool): The new state to set (True for checked, False for unchecked).
+            """
+            highlighted_paths = self.table_model.get_highlighted_paths()
+            if not highlighted_paths:
+                return
+
+            for path in highlighted_paths:
+                raster = self.raster_manager.get_raster(path)
+                if raster:
+                    raster.checkbox_state = new_state
+                    # Notify the model to update the view for this specific raster
+                    self.table_model.update_raster_data(path)
+            
     #
     # Public methods
     #
@@ -960,28 +991,46 @@ class ImageWindow(QWidget):
         
     def show_context_menu(self, position):
         """
-        Show the context menu for the table.
+        Show the context menu for the table, including the toggle check state action.
         
         Args:
             position (QPoint): Position to show the menu
         """
+        # Get the path corresponding to the right-clicked row
+        index = self.tableView.indexAt(position)
+        path_at_cursor = self.table_model.get_path_at_row(index.row()) if index.isValid() else None
+
+        # Get the currently highlighted paths from the model
         highlighted_paths = self.table_model.get_highlighted_paths()
-        if not highlighted_paths:
-            # If no highlights, highlight the row under the cursor only
-            index = self.tableView.indexAt(position)
-            if index.isValid():
-                path = self.table_model.get_path_at_row(index.row())
-                if path:
-                    self.table_model.set_highlighted_paths([path])
-                    self.last_highlighted_row = index.row()
-                    highlighted_paths = [path]
-        else:
-            # If any highlights, ensure all highlighted rows are used (no change needed)
-            self.table_model.set_highlighted_paths(highlighted_paths)
+
+        # If the user right-clicked on a row that wasn't already highlighted,
+        # then we assume they want to act on this row alone.
+        if path_at_cursor and path_at_cursor not in highlighted_paths:
+            self.table_model.set_highlighted_paths([path_at_cursor])
+            self.last_highlighted_row = index.row()
+            highlighted_paths = [path_at_cursor]
+        
+        # If no rows are highlighted, do nothing.
         if not highlighted_paths:
             return
+
         context_menu = QMenu(self)
         count = len(highlighted_paths)
+        
+        # Add the check/uncheck action
+        raster_under_cursor = self.raster_manager.get_raster(path_at_cursor)
+        if raster_under_cursor:
+            is_checked = raster_under_cursor.checkbox_state
+            if is_checked:
+                action_text = f"Uncheck {count} Highlighted Image{'s' if count > 1 else ''}"
+            else:
+                action_text = f"Check {count} Highlighted Image{'s' if count > 1 else ''}"
+            toggle_check_action = context_menu.addAction(action_text)
+            toggle_check_action.triggered.connect(lambda: self.on_toggle(not is_checked))
+
+        context_menu.addSeparator()
+
+        # Add existing delete actions
         delete_images_action = context_menu.addAction(f"Delete {count} Highlighted Image{'s' if count > 1 else ''}")
         delete_images_action.triggered.connect(lambda: self.delete_highlighted_images())
         delete_annotations_action = context_menu.addAction(

coralnet_toolbox/QtLabelWindow.py

@@ -485,7 +485,19 @@ class LabelWindow(QWidget):
         self.scroll_content.setFixedWidth(self.labels_per_row * self.label_width)
 
     def reorganize_labels(self):
-        """Rearrange labels in the grid layout based on the current order and labels_per_row."""
+        """
+        Rearrange labels in the grid layout based on the current order and labels_per_row.
+        """
+        # First, clear the existing layout to remove any lingering widgets.
+        # This prevents references to deleted widgets from persisting in the layout.
+        while self.grid_layout.count():
+            item = self.grid_layout.takeAt(0)
+            widget = item.widget()
+            if widget:
+                # Setting the parent to None removes the widget from the layout's control.
+                widget.setParent(None)
+
+        # Now, add the current labels from the model back into the clean layout.
         for i, label in enumerate(self.labels):
             row = i // self.labels_per_row
             col = i % self.labels_per_row

coralnet_toolbox/QtMainWindow.py

@@ -2290,34 +2290,10 @@ class MainWindow(QMainWindow):
                                 "No images are present in the project.")
             return
         
-        if not self.annotation_window.annotations_dict:
+        if len(self.label_window.labels) <= 1:
             QMessageBox.warning(self,
                                 "See Anything (YOLOE)",
-                                "No annotations are present in the project.")
-            return
-        
-        valid_reference_types = {"PolygonAnnotation", "RectangleAnnotation"}
-        has_valid_reference = False
-
-        # Iterate through the rasters in the main manager.
-        for raster in self.image_window.raster_manager.rasters.values():
-            # The values of our map are sets of annotation type names.
-            # e.g., [{'PointAnnotation'}, {'PolygonAnnotation', 'RectangleAnnotation'}]
-            for types_for_a_label in raster.label_to_types_map.values():
-                # Check if the set of types for this specific label
-                # has any overlap with our valid reference types.
-                if not valid_reference_types.isdisjoint(types_for_a_label):
-                    # A valid reference type was found for at least one label on this raster.
-                    has_valid_reference = True
-                    break  # Exit the inner loop (over types)
-            
-            if has_valid_reference:
-                break  # Exit the outer loop (over rasters)
-
-        if not has_valid_reference:
-            QMessageBox.warning(self,
-                                "No Valid Reference Annotations",
-                                "No images have polygon or rectangle annotations to use as a reference.")
+                                "At least one reference label is required for reference.")
             return
 
         try:
@@ -2518,7 +2494,9 @@ class MainWindow(QMainWindow):
             msg.setWindowIcon(self.coral_icon)
             msg.setWindowTitle("GDI Limit Reached")
             msg.setText(
-                "The GDI limit has been reached! Please immediately save your work, close, and reopen the application!"
+                "The GDI limit is getting dangerously close to being reached (this is a known issue). "
+                "Please immediately save your progress, close, and re-open the application. Failure to do so may "
+                "result in data loss."
             )
             msg.setStandardButtons(QMessageBox.Ok)
             msg.exec_()