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

coralnet_toolbox/IO/QtExportTagLabAnnotations.py

@@ -197,30 +197,50 @@ class ExportTagLabAnnotations:
         """
         # Calculate bounding box, centroid, area, perimeter, and contour
         points = annotation.points
+        # Convert points to TagLab contour format
+        contour = self.taglabToPoints(np.array([[point.x(), point.y()] for point in points]))
+        inner_contours = []
+        if hasattr(annotation, 'holes') and annotation.holes:
+            # Convert holes to TagLab format
+            for hole in annotation.holes:
+                inner_contours.append(self.taglabToPoints(np.array([[point.x(), point.y()] for point in hole])))
+        
+        # Calculate bounding box
         min_x = int(min(point.x() for point in points))
         min_y = int(min(point.y() for point in points))
         max_x = int(max(point.x() for point in points))
-        max_y = int(max(point.y() for point in points))
+        max_y = int(max(point.y() for point in points))        
         width = max_x - min_x
         height = max_y - min_y
+        bbox = [min_x, min_y, width, height]
+        
+        # Calculate centroid
         centroid_x = float(f"{sum(point.x() for point in points) / len(points):.1f}")
         centroid_y = float(f"{sum(point.y() for point in points) / len(points):.1f}")
+        centroid = [centroid_x, centroid_y]
+        
         area = float(f"{annotation.get_area():.1f}")
         perimeter = float(f"{annotation.get_perimeter():.1f}")
-        contour = self.taglabToPoints(np.array([[point.x(), point.y()] for point in points]))
+        data = annotation.data if hasattr(annotation, 'data') else {}
+        
+        # Pop these keys from data if they exist
+        class_name = data.pop('class_name', annotation.label.short_label_code)
+        instance_name = data.pop('instance_name', "coral0")
+        blob_name = data.pop('blob_name', f"c-0-{centroid_x}x-{centroid_y}y")
+        note = data.pop('note', "")
 
         annotation_dict = {
-            "bbox": [min_y, min_x, width, height],
-            "centroid": [centroid_x, centroid_y],
+            "bbox": bbox,
+            "centroid": centroid,
             "area": area,
             "perimeter": perimeter,
             "contour": contour,
-            "inner contours": [],
-            "class name": annotation.label.short_label_code,
-            "instance name": "coral0",  # Placeholder, update as needed
-            "blob name": f"c-0-{centroid_x}x-{centroid_y}y",
-            "note": "",
-            "data": {}
+            "inner contours": inner_contours,
+            "class name": class_name,
+            "instance name": instance_name,
+            "blob name": blob_name,
+            "note": note,
+            "data": data
         }
         
         return annotation_dict

coralnet_toolbox/IO/QtImportTagLabAnnotations.py

@@ -161,23 +161,25 @@ class ImportTagLabAnnotations:
                         short_label_code = label_info['name'].strip()
                         long_label_code = label_info['name'].strip()
                         color = QColor(*label_info['fill'])
-
-                        # Unpack the annotation data
-                        bbox = annotation['bbox']
-                        centroid = annotation['centroid']
-                        area = annotation['area']
-                        perimeter = annotation['perimeter']
-                        contour = annotation['contour']
-                        inner_contours = annotation['inner contours']
-                        class_name = annotation['class name']
-                        instance_name = annotation['instance name']
-                        blob_name = annotation['blob name']
-                        idx = annotation['id']
-                        note = annotation['note']
-                        data = annotation['data']
+                       
+                        # Pack all other data into a dict
+                        imported_data = {
+                            'bbox': annotation.get('bbox'),
+                            'centroid': annotation.get('centroid'),
+                            'area': annotation.get('area'),
+                            'perimeter': annotation.get('perimeter'),
+                            'class_name': annotation.get('class name'),
+                            'instance_name': annotation.get('instance name'),
+                            'blob_name': annotation.get('blob name'),
+                            'id': annotation.get('id'),
+                            'note': annotation.get('note'),
+                            'data': annotation.get('data'),
+                        }
 
                         # Convert contour string to points
                         points = self.parse_contour(annotation['contour'])
+                        # Convert inner contours to a list of lists of points (holes)
+                        holes = [self.parse_contour(inner) for inner in annotation.get('inner contours', [])]
 
                         # Create the label if it doesn't exist
                         label = self.label_window.add_label_if_not_exists(short_label_code,
@@ -191,8 +193,12 @@ class ImportTagLabAnnotations:
                             long_label_code=long_label_code,
                             color=color,
                             image_path=image_full_path,
-                            label_id=label_id
+                            label_id=label_id,
+                            holes=holes,
                         )
+                        # Add additional data to the annotation
+                        polygon_annotation.data = imported_data
+                        
                         # Add annotation to the dict
                         self.annotation_window.add_annotation_to_dict(polygon_annotation)
 

coralnet_toolbox/IO/QtOpenProject.py

@@ -12,16 +12,12 @@ from PyQt5.QtWidgets import (QDialog, QFileDialog, QVBoxLayout, QPushButton, QLa
                              QLineEdit)
 
 from coralnet_toolbox.QtLabelWindow import Label
-
 from coralnet_toolbox.QtWorkArea import WorkArea
-
 from coralnet_toolbox.Annotations.QtPatchAnnotation import PatchAnnotation
 from coralnet_toolbox.Annotations.QtPolygonAnnotation import PolygonAnnotation
 from coralnet_toolbox.Annotations.QtRectangleAnnotation import RectangleAnnotation
 from coralnet_toolbox.Annotations.QtMultiPolygonAnnotation import MultiPolygonAnnotation
-
 from coralnet_toolbox.Common.QtUpdateImagePaths import UpdateImagePaths
-
 from coralnet_toolbox.QtProgressBar import ProgressBar
 
 
@@ -143,19 +139,18 @@ class OpenProject(QDialog):
             with open(file_path, 'r') as file:
                 project_data = json.load(file)
 
+            # Handle both new and old project formats for images and work areas
+            images_data = project_data.get('images', project_data.get('image_paths'))
+            legacy_workareas = project_data.get('workareas') # For backward compatibility
+
             # Update main window with loaded project data
-            self.import_images(project_data.get('image_paths'))
-            self.import_workareas(project_data.get('workareas'))
+            self.import_images(images_data, legacy_workareas)
             self.import_labels(project_data.get('labels'))
             self.import_annotations(project_data.get('annotations'))
             
             # Update current project path
             self.current_project_path = file_path
 
-            QMessageBox.information(self.annotation_window, 
-                                    "Project Loaded",
-                                    "Project has been successfully loaded.")
-
         except Exception as e:
             QMessageBox.warning(self.annotation_window, 
                                 "Error Loading Project", 
@@ -168,10 +163,15 @@ class OpenProject(QDialog):
         # Exit
         self.accept()
 
-    def import_images(self, image_paths):
-        """Import images from the given paths."""
-        if not image_paths:
+    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)
@@ -183,15 +183,46 @@ class OpenProject(QDialog):
         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
             for path in image_paths:
-                # Use the improved add_image method which handles both
-                # adding to raster_manager and updating filtered_paths
                 self.image_window.add_image(path)
+                raster = self.image_window.raster_manager.get_raster(path)
+                if not raster:
+                    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)
+                            raster.add_work_area(work_area)
+                        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)
+                    raster = self.image_window.raster_manager.get_raster(current_path)
+                    if raster:
+                        for work_area_data in work_areas_list:
+                            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])
@@ -204,69 +235,6 @@ class OpenProject(QDialog):
             # Close progress bar
             progress_bar.stop_progress()
             progress_bar.close()
-            
-    def import_workareas(self, workareas):
-        """Import work areas for each image."""
-        if not workareas:
-            return
-        
-        # Start the progress bar
-        total_images = len(workareas)
-        progress_bar = ProgressBar(self.annotation_window, title="Importing Work Areas")
-        progress_bar.show()
-        progress_bar.start_progress(total_images)
-
-        try:
-            # Loop through each image's work areas
-            for image_path, work_areas_list in workareas.items():
-                
-                # Check if the image path was updated (moved)
-                updated_path = False
-                
-                if image_path not in self.image_window.raster_manager.image_paths:
-                    # Check if the path was updated
-                    if image_path in self.updated_paths:
-                        image_path = self.updated_paths[image_path]
-                        updated_path = True
-                    else:
-                        print(f"Warning: Image not found for work areas: {image_path}")
-                        continue
-                
-                # Get the raster for this image
-                raster = self.image_window.raster_manager.get_raster(image_path)
-                if not raster:
-                    print(f"Warning: Could not get raster for image: {image_path}")
-                    continue
-                
-                # Import each work area for this image
-                for work_area_data in work_areas_list:
-                    try:
-                        # Update image path if it was changed
-                        if updated_path:
-                            work_area_data['image_path'] = image_path
-                        
-                        # Create WorkArea from dictionary
-                        work_area = WorkArea.from_dict(work_area_data, image_path)
-                        
-                        # Add work area to the raster
-                        raster.add_work_area(work_area)
-                        
-                    except Exception as e:
-                        print(f"Warning: Could not import work area {work_area_data}: {str(e)}")
-                        continue
-                
-                # Update the progress bar
-                progress_bar.update_progress()
-
-        except Exception as e:
-            QMessageBox.warning(self.annotation_window,
-                                "Error Importing Work Areas",
-                                f"An error occurred while importing work areas: {str(e)}")
-
-        finally:
-            # Close progress bar
-            progress_bar.stop_progress()
-            progress_bar.close()
 
     def import_labels(self, labels):
         """Import labels from the given list."""

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/DeployModel/QtDetect.py

@@ -123,18 +123,29 @@ class Detect(Base):
 
     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/MachineLearning/DeployModel/QtSegment.py

@@ -123,17 +123,29 @@ class Segment(Base):
         
     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.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/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, 600)
+        self.resize(800, 800)
         self.setWindowIcon(get_icon("coral.png"))
         self.setWindowTitle("Export Dataset")
 
@@ -64,10 +64,8 @@ class Base(QDialog):
         self.setup_output_layout()
         # Setup the ratio layout
         self.setup_ratio_layout()
-        # Setup the annotation layout
-        self.setup_annotation_layout()
-        # Setup the options layout
-        self.setup_options_layout()
+        # Setup the data selection layout
+        self.setup_data_selection_layout()
         # Setup the table layout
         self.setup_table_layout()
         # Setup the status layout
@@ -147,10 +145,25 @@ class Base(QDialog):
         group_box.setLayout(layout)
         self.layout.addWidget(group_box)
 
-    def setup_annotation_layout(self):
-        """Setup the annotation type checkboxes layout."""
+    def setup_data_selection_layout(self):
+        """Setup the layout for data selection options in a horizontal arrangement."""
+        options_layout = QHBoxLayout()
+
+        # Create and add the group boxes
+        annotation_types_group = self.create_annotation_layout()
+        image_options_group = self.create_image_source_layout()
+        negative_samples_group = self.create_negative_samples_layout()
+
+        options_layout.addWidget(annotation_types_group)
+        options_layout.addWidget(image_options_group)
+        options_layout.addWidget(negative_samples_group)
+
+        self.layout.addLayout(options_layout)
+
+    def create_annotation_layout(self):
+        """Creates the annotation type checkboxes layout group box."""
         group_box = QGroupBox("Annotation Types")
-        layout = QHBoxLayout()
+        layout = QVBoxLayout()
 
         self.include_patches_checkbox = QCheckBox("Include Patch Annotations")
         self.include_rectangles_checkbox = QCheckBox("Include Rectangle Annotations")
@@ -161,30 +174,24 @@ class Base(QDialog):
         layout.addWidget(self.include_polygons_checkbox)
 
         group_box.setLayout(layout)
-        self.layout.addWidget(group_box)
+        return group_box
 
-    def setup_options_layout(self):
-        """Setup the image options layout."""
-        group_box = QGroupBox("Image Options")
-        layout = QHBoxLayout()  # Changed from QVBoxLayout to QHBoxLayout
+    def create_image_source_layout(self):
+        """Creates the image source options layout group box."""
+        group_box = QGroupBox("Image Source")
+        layout = QVBoxLayout()
 
-        # Create a button group for the image checkboxes
         self.image_options_group = QButtonGroup(self)
 
         self.all_images_radio = QRadioButton("All Images")
         self.filtered_images_radio = QRadioButton("Filtered Images")
 
-        # Add the radio buttons to the button group
         self.image_options_group.addButton(self.all_images_radio)
         self.image_options_group.addButton(self.filtered_images_radio)
-
-        # Ensure only one radio button can be checked at a time
         self.image_options_group.setExclusive(True)
 
-        # Set the default radio button
         self.all_images_radio.setChecked(True)
 
-        # Connect radio button signals
         self.all_images_radio.toggled.connect(self.update_image_selection)
         self.filtered_images_radio.toggled.connect(self.update_image_selection)
 
@@ -192,7 +199,32 @@ class Base(QDialog):
         layout.addWidget(self.filtered_images_radio)
 
         group_box.setLayout(layout)
-        self.layout.addWidget(group_box)
+        return group_box
+
+    def create_negative_samples_layout(self):
+        """Creates the negative sample options layout group box."""
+        group_box = QGroupBox("Negative Samples")
+        layout = QVBoxLayout()
+
+        self.negative_samples_group = QButtonGroup(self)
+
+        self.include_negatives_radio = QRadioButton("Include Negatives")
+        self.exclude_negatives_radio = QRadioButton("Exclude Negatives")
+
+        self.negative_samples_group.addButton(self.include_negatives_radio)
+        self.negative_samples_group.addButton(self.exclude_negatives_radio)
+        self.negative_samples_group.setExclusive(True)
+
+        self.exclude_negatives_radio.setChecked(True)
+
+        # Connect to update stats when changed. Only one needed for the group.
+        self.include_negatives_radio.toggled.connect(self.update_summary_statistics)
+
+        layout.addWidget(self.include_negatives_radio)
+        layout.addWidget(self.exclude_negatives_radio)
+
+        group_box.setLayout(layout)
+        return group_box
 
     def setup_table_layout(self):
         """Setup the label counts table layout."""
@@ -424,6 +456,11 @@ class Base(QDialog):
         else:
             images = self.image_window.raster_manager.image_paths
 
+        # If "Exclude Negatives" is checked, only use images that have selected annotations.
+        if self.exclude_negatives_radio.isChecked():
+            image_paths_with_annotations = {a.image_path for a in self.selected_annotations}
+            images = [img for img in images if img in image_paths_with_annotations]
+
         random.shuffle(images)
 
         train_split = int(len(images) * self.train_ratio)
@@ -551,9 +588,6 @@ class Base(QDialog):
 
         self.updating_summary_statistics = True
 
-        # Split the data by images
-        self.split_data()
-
         # Selected labels based on user's selection
         self.selected_labels = []
         for row in range(self.label_counts_table.rowCount()):
@@ -564,6 +598,9 @@ class Base(QDialog):
 
         # Filter annotations based on the selected annotation types and current tab
         self.selected_annotations = self.filter_annotations()
+        
+        # Split the data by images
+        self.split_data()
 
         # Split the data by annotations
         self.determine_splits()
@@ -704,4 +741,4 @@ class Base(QDialog):
         raise NotImplementedError("Method must be implemented in the subclass.")
 
     def process_annotations(self, annotations, split_dir, split):
-        raise NotImplementedError("Method must be implemented in the subclass.")
+        raise NotImplementedError("Method must be implemented in the subclass.")

coralnet_toolbox/MachineLearning/ExportDataset/QtClassify.py

@@ -60,6 +60,10 @@ class Classify(Base):
         self.include_polygons_checkbox.setChecked(True)
         self.include_polygons_checkbox.setEnabled(True)
 
+        # Disable negative sample options for classification
+        self.include_negatives_radio.setEnabled(False)
+        self.exclude_negatives_radio.setEnabled(False)
+
     def create_dataset(self, output_dir_path):
         """
         Create an image classification dataset.
@@ -219,4 +223,4 @@ class Classify(Base):
             progress_bar.stop_progress()
             progress_bar.close()
             progress_bar = None
-            gc.collect()
+            gc.collect()