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

coralnet_toolbox/Explorer/transformer_models.py

@@ -0,0 +1,59 @@
+"""
+Transformer models configuration for the Explorer tool.
+
+This module contains the transformer models dictionary used in the Explorer tool.
+It's extracted into a separate module to allow easy importing in tests without
+Qt dependencies.
+"""
+
+TRANSFORMER_MODELS = {
+    'DINOv2 (Small)': 'facebook/dinov2-small',
+    'DINOv2 (Base)': 'facebook/dinov2-base',
+    'DINOv2 (Large)': 'facebook/dinov2-large',
+    'DINOv3 ConvNext (Tiny)': 'facebook/dinov3-convnext-tiny-pretrain-lvd1689m',
+    'ResNet-50': 'microsoft/resnet-50',
+    'ResNet-101': 'microsoft/resnet-101',
+    'Swin Transformer (Tiny)': 'microsoft/swin-tiny-patch4-window7-224',
+    'Swin Transformer (Base)': 'microsoft/swin-base-patch4-window7-224',
+    'ViT (Base)': 'google/vit-base-patch16-224',
+    'ViT (Large)': 'google/vit-large-patch16-224',
+}
+
+
+def is_transformer_model(model_name):
+    """
+    Determine if a model name refers to a transformer model.
+    
+    This function checks if the model name indicates a HuggingFace transformer model
+    that should be handled by the transformer feature extraction pipeline.
+    
+    Args:
+        model_name (str): The model name to check
+        
+    Returns:
+        bool: True if this is a transformer model, False otherwise
+    """
+    if not model_name or not isinstance(model_name, str):
+        return False
+        
+    # Check if it's one of our known transformer model IDs
+    if model_name in TRANSFORMER_MODELS.values():
+        return True
+    
+    # Check for common HuggingFace model naming patterns
+    # Models from HuggingFace typically contain '/' in their names
+    if "/" in model_name:
+        # Check for known organization prefixes
+        known_prefixes = ("facebook/", 
+                          "microsoft/", 
+                          "google/", 
+                          "openai/", 
+                          "imageomics/")
+        
+        if model_name.startswith(known_prefixes):
+            return True
+        
+        # Any model with '/' is likely a HuggingFace model
+        return True
+    
+    return False

coralnet_toolbox/Explorer/yolo_models.py

@@ -0,0 +1,112 @@
+"""
+YOLO models configuration for the Explorer tool.
+
+This module contains the YOLO models dictionary used in the Explorer tool.
+It's extracted into a separate module to allow easy importing in tests without
+Qt dependencies.
+"""
+
+from coralnet_toolbox.MachineLearning.Community.cfg import get_available_configs
+
+# Dictionary mapping display names to model file names (classification models only)
+YOLO_MODELS = {
+    # YOLOv8 classification models
+    'YOLOv8 (Nano)': 'yolov8n-cls.pt',
+    'YOLOv8 (Small)': 'yolov8s-cls.pt',
+    'YOLOv8 (Medium)': 'yolov8m-cls.pt',
+    'YOLOv8 (Large)': 'yolov8l-cls.pt',
+    'YOLOv8 (X-Large)': 'yolov8x-cls.pt',
+    
+    # YOLOv11 classification models
+    'YOLOv11 (Nano)': 'yolov11n-cls.pt',
+    'YOLOv11 (Small)': 'yolov11s-cls.pt',
+    'YOLOv11 (Medium)': 'yolov11m-cls.pt',
+    'YOLOv11 (Large)': 'yolov11l-cls.pt',
+    'YOLOv11 (X-Large)': 'yolov11x-cls.pt',
+    
+    # YOLOv12 classification models
+    'YOLOv12 (Nano)': 'yolov12n-cls.pt',
+    'YOLOv12 (Small)': 'yolov12s-cls.pt',
+    'YOLOv12 (Medium)': 'yolov12m-cls.pt',
+    'YOLOv12 (Large)': 'yolov12l-cls.pt',
+    'YOLOv12 (X-Large)': 'yolov12x-cls.pt',
+}
+
+
+def get_community_models(task='classify'):
+    """
+    Get available community models for a specific task.
+    
+    Args:
+        task (str): The task type, default is 'classify'
+        
+    Returns:
+        dict: Dictionary of community models
+    """
+    return get_available_configs(task=task)
+
+
+def is_yolo_model(model_name):
+    """
+    Determine if a model name refers to a YOLO model.
+    
+    This function checks if the model name indicates a YOLO model
+    that should be handled by the YOLO feature extraction pipeline.
+    
+    Args:
+        model_name (str): The model name to check
+        
+    Returns:
+        bool: True if this is a YOLO model, False otherwise
+    """
+    if not model_name or not isinstance(model_name, str):
+        return False
+        
+    # Check if it's one of our known YOLO model IDs
+    if model_name in YOLO_MODELS.values():
+        return True
+    
+    # Check if it's a community model (check both keys and values)
+    community_models = get_community_models()
+    if community_models:
+        if model_name in community_models or model_name in community_models.values():
+            return True
+    
+    # Check for .pt file extension (any PyTorch model file)
+    if model_name.lower().endswith('.pt'):
+        return True
+    
+    return False
+
+
+def get_yolo_model_task(model_name):
+    """
+    Determine the task type of a YOLO model based on its name.
+    
+    Args:
+        model_name (str): The model name or path
+        
+    Returns:
+        str: One of 'classify', 'detect', 'segment', or 'unknown'
+    """
+    if not model_name or not isinstance(model_name, str):
+        return 'unknown'
+    
+    # Check if it's a community model - all community models are classify
+    community_models = get_community_models()
+    if community_models:
+        if model_name in community_models or model_name in community_models.values():
+            return 'classify'
+    
+    # Extract just the filename if a full path is provided
+    filename = model_name.split('/')[-1].split('\\')[-1].lower()
+    
+    if '-cls' in filename:
+        return 'classify'
+    elif '-seg' in filename:
+        return 'segment'
+    elif filename.endswith('.pt'):
+        # Default YOLO models without specific suffixes are detection models
+        return 'detect'
+    
+    return 'unknown'

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/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")