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

coralnet_toolbox/Tools/QtRectangleTool.py

@@ -113,6 +113,36 @@ class RectangleTool(Tool):
         # Ensure top_left and bottom_right are correctly calculated
         top_left = QPointF(min(self.start_point.x(), end_point.x()), min(self.start_point.y(), end_point.y()))
         bottom_right = QPointF(max(self.start_point.x(), end_point.x()), max(self.start_point.y(), end_point.y()))
+        
+        # Calculate width and height of the rectangle
+        width = bottom_right.x() - top_left.x()
+        height = bottom_right.y() - top_left.y()
+        
+        # Define minimum dimensions for a valid rectangle (e.g., 3x3 pixels)
+        MIN_DIMENSION = 3.0
+        
+        # If rectangle is too small and we're finalizing it, enforce minimum size
+        if finished and (width < MIN_DIMENSION or height < MIN_DIMENSION):
+            if width < MIN_DIMENSION:
+                # Expand width while maintaining center
+                center_x = (top_left.x() + bottom_right.x()) / 2
+                top_left.setX(center_x - MIN_DIMENSION / 2)
+                bottom_right.setX(center_x + MIN_DIMENSION / 2)
+                
+            if height < MIN_DIMENSION:
+                # Expand height while maintaining center
+                center_y = (top_left.y() + bottom_right.y()) / 2
+                top_left.setY(center_y - MIN_DIMENSION / 2)
+                bottom_right.setY(center_y + MIN_DIMENSION / 2)
+            
+            # Show a message if we had to adjust a very small rectangle
+            if width < 1 or height < 1:
+                QMessageBox.information(
+                    self.annotation_window, 
+                    "Rectangle Adjusted",
+                    f"The rectangle was too small and has been adjusted to a minimum size of "
+                    f"{MIN_DIMENSION}x{MIN_DIMENSION} pixels."
+                )
 
         # Create the rectangle annotation
         annotation = RectangleAnnotation(top_left,

coralnet_toolbox/Tools/QtSAMTool.py

@@ -6,6 +6,8 @@ from PyQt5.QtGui import QMouseEvent, QKeyEvent, QPen, QColor, QBrush, QPainterPa
 from PyQt5.QtWidgets import QMessageBox, QGraphicsEllipseItem, QGraphicsRectItem, QGraphicsPathItem, QApplication
 
 from coralnet_toolbox.Tools.QtTool import Tool
+
+from coralnet_toolbox.Annotations.QtRectangleAnnotation import RectangleAnnotation
 from coralnet_toolbox.Annotations.QtPolygonAnnotation import PolygonAnnotation
 
 from coralnet_toolbox.QtWorkArea import WorkArea
@@ -374,45 +376,21 @@ class SAMTool(Tool):
             top1_index = np.argmax(results.boxes.conf)
             mask_tensor = results[top1_index].masks.data
 
-            # Check if holes are allowed from the SAM dialog
+            # Check which output type is selected and get allow_holes settings
+            output_type = self.sam_dialog.get_output_type()
             allow_holes = self.sam_dialog.get_allow_holes()
-
-            # Polygonize the mask to get the exterior and holes
-            exterior_coords, holes_coords_list = polygonize_mask_with_holes(mask_tensor)
-
-            # Safety check: need at least 3 points for a valid polygon
-            if len(exterior_coords) < 3:
+            
+            # Create annotation using the helper method
+            self.temp_annotation = self.create_annotation_from_mask(
+                mask_tensor,
+                output_type,
+                allow_holes
+            )
+            
+            if not self.temp_annotation:
                 QApplication.restoreOverrideCursor()
                 return
-
-            # --- Process and Clean the Polygon Points ---
-            working_area_top_left = self.working_area.rect.topLeft()
-            offset_x, offset_y = working_area_top_left.x(), working_area_top_left.y()
-
-            # Simplify, offset, and convert the exterior points
-            simplified_exterior = simplify_polygon(exterior_coords, 0.1)
-            self.points = [QPointF(p[0] + offset_x, p[1] + offset_y) for p in simplified_exterior]
-
-            # Simplify, offset, and convert each hole only if allowed
-            final_holes = []
-            if allow_holes:
-                for hole_coords in holes_coords_list:
-                    if len(hole_coords) >= 3:  # Ensure holes are also valid polygons
-                        simplified_hole = simplify_polygon(hole_coords, 0.1)
-                        final_holes.append([QPointF(p[0] + offset_x, p[1] + offset_y) for p in simplified_hole])
-
-            # Create the temporary annotation, now with holes (or not)
-            self.temp_annotation = PolygonAnnotation(
-                points=self.points,
-                holes=final_holes,
-                short_label_code=self.annotation_window.selected_label.short_label_code,
-                long_label_code=self.annotation_window.selected_label.long_label_code,
-                color=self.annotation_window.selected_label.color,
-                image_path=self.annotation_window.current_image_path,
-                label_id=self.annotation_window.selected_label.id,
-                transparency=self.main_window.label_window.active_label.transparency
-            )
-
+                
             # Create the graphics item for the temporary annotation
             self.temp_annotation.create_graphics_item(self.annotation_window.scene)
             
@@ -616,17 +594,31 @@ class SAMTool(Tool):
             elif self.has_active_prompts:
                 # Create the final annotation
                 if self.temp_annotation:
-                    # Use existing temporary annotation
-                    final_annotation = PolygonAnnotation(
-                        self.points,
-                        self.temp_annotation.label.short_label_code,
-                        self.temp_annotation.label.long_label_code,
-                        self.temp_annotation.label.color,
-                        self.temp_annotation.image_path,
-                        self.temp_annotation.label.id,
-                        self.temp_annotation.label.transparency,
-                        holes=self.temp_annotation.holes
-                    )
+                    # Check if temp_annotation is a PolygonAnnotation or RectangleAnnotation
+                    if isinstance(self.temp_annotation, PolygonAnnotation):
+                        # For polygon annotations, use the points and holes
+                        final_annotation = PolygonAnnotation(
+                            self.points,
+                            self.temp_annotation.label.short_label_code,
+                            self.temp_annotation.label.long_label_code,
+                            self.temp_annotation.label.color,
+                            self.temp_annotation.image_path,
+                            self.temp_annotation.label.id,
+                            self.temp_annotation.label.transparency,
+                            holes=self.temp_annotation.holes
+                        )
+                    elif isinstance(self.temp_annotation, RectangleAnnotation):
+                        # For rectangle annotations, use the top_left and bottom_right
+                        final_annotation = RectangleAnnotation(
+                            top_left=self.temp_annotation.top_left,
+                            bottom_right=self.temp_annotation.bottom_right,
+                            short_label_code=self.temp_annotation.label.short_label_code,
+                            long_label_code=self.temp_annotation.label.long_label_code,
+                            color=self.temp_annotation.label.color,
+                            image_path=self.temp_annotation.image_path,
+                            label_id=self.temp_annotation.label.id,
+                            transparency=self.temp_annotation.label.transparency
+                        )
 
                     # Copy confidence data
                     final_annotation.update_machine_confidence(
@@ -740,54 +732,23 @@ class SAMTool(Tool):
         top1_index = np.argmax(results.boxes.conf)
         mask_tensor = results[top1_index].masks.data
 
-        # Check if holes are allowed from the SAM dialog
+        # Check which output type is selected and get allow_holes settings
+        output_type = self.sam_dialog.get_output_type()
         allow_holes = self.sam_dialog.get_allow_holes()
-
-        # Polygonize the mask using the new method to get the exterior and holes
-        exterior_coords, holes_coords_list = polygonize_mask_with_holes(mask_tensor)
-
-        # Safety check for an empty result
-        if not exterior_coords:
-            QApplication.restoreOverrideCursor()
-            return None
-
-        # --- Process and Clean the Polygon Points ---
-        working_area_top_left = self.working_area.rect.topLeft()
-        offset_x, offset_y = working_area_top_left.x(), working_area_top_left.y()
-
-        # Simplify, offset, and convert the exterior points
-        simplified_exterior = simplify_polygon(exterior_coords, 0.1)
-        self.points = [QPointF(p[0] + offset_x, p[1] + offset_y) for p in simplified_exterior]
-
-        # Simplify, offset, and convert each hole only if allowed
-        final_holes = []
-        if allow_holes:
-            for hole_coords in holes_coords_list:
-                if len(hole_coords) >= 3:
-                    simplified_hole = simplify_polygon(hole_coords, 0.1)
-                    final_holes.append([QPointF(p[0] + offset_x, p[1] + offset_y) for p in simplified_hole])
-
-        # Require at least 3 points for valid polygon
-        if len(self.points) < 3:
+        
+        # Create annotation using the helper method
+        annotation = self.create_annotation_from_mask(
+            mask_tensor,
+            output_type,
+            allow_holes
+        )
+        
+        if not annotation:
             QApplication.restoreOverrideCursor()
             return None
 
-        # Get confidence score
-        confidence = results.boxes.conf[top1_index].item()
-
-        # Create final annotation, now passing the holes argument
-        annotation = PolygonAnnotation(
-            points=self.points,
-            holes=final_holes,
-            short_label_code=self.annotation_window.selected_label.short_label_code,
-            long_label_code=self.annotation_window.selected_label.long_label_code,
-            color=self.annotation_window.selected_label.color,
-            image_path=self.annotation_window.current_image_path,
-            label_id=self.annotation_window.selected_label.id,
-            transparency=self.main_window.label_window.active_label.transparency
-        )
-
-        # Update confidence
+        # Update confidence - make sure to extract confidence from results
+        confidence = float(results.boxes.conf[top1_index])
         annotation.update_machine_confidence({self.annotation_window.selected_label: confidence})
 
         # Create cropped image
@@ -799,6 +760,94 @@ class SAMTool(Tool):
 
         return annotation
 
+    def create_annotation_from_mask(self, mask_tensor, output_type, allow_holes=True):
+        """
+        Create annotation (Rectangle or Polygon) from a mask tensor.
+        
+        Args:
+            mask_tensor: The tensor containing the mask data
+            output_type (str): "Rectangle" or "Polygon"
+            allow_holes (bool): Whether to include holes in polygon annotations
+        
+        Returns:
+            Annotation object or None if creation fails
+        """
+        if not self.working_area:
+            return None
+            
+        if output_type == "Rectangle":
+            # For rectangle output, just get the bounding box of the mask
+            # Find the bounding rectangle of the mask
+            y_indices, x_indices = np.where(mask_tensor.cpu().numpy()[0] > 0)
+            if len(y_indices) == 0 or len(x_indices) == 0:
+                return None
+                
+            # Get the min/max coordinates
+            min_x, max_x = np.min(x_indices), np.max(x_indices)
+            min_y, max_y = np.min(y_indices), np.max(y_indices)
+            
+            # Apply the offset from working area
+            working_area_top_left = self.working_area.rect.topLeft()
+            offset_x, offset_y = working_area_top_left.x(), working_area_top_left.y()
+            
+            top_left = QPointF(min_x + offset_x, min_y + offset_y)
+            bottom_right = QPointF(max_x + offset_x, max_y + offset_y)
+            
+            # Create a rectangle annotation
+            annotation = RectangleAnnotation(
+                top_left=top_left,
+                bottom_right=bottom_right,
+                short_label_code=self.annotation_window.selected_label.short_label_code,
+                long_label_code=self.annotation_window.selected_label.long_label_code,
+                color=self.annotation_window.selected_label.color,
+                image_path=self.annotation_window.current_image_path,
+                label_id=self.annotation_window.selected_label.id,
+                transparency=self.main_window.label_window.active_label.transparency
+            )
+        else:
+            # Original polygon code
+            # Polygonize the mask using the new method to get the exterior and holes
+            exterior_coords, holes_coords_list = polygonize_mask_with_holes(mask_tensor)
+            
+            # Safety check for an empty result
+            if not exterior_coords:
+                return None
+                
+            # --- Process and Clean the Polygon Points ---
+            working_area_top_left = self.working_area.rect.topLeft()
+            offset_x, offset_y = working_area_top_left.x(), working_area_top_left.y()
+            
+            # Simplify, offset, and convert the exterior points
+            simplified_exterior = simplify_polygon(exterior_coords, 0.1)
+            self.points = [QPointF(p[0] + offset_x, p[1] + offset_y) for p in simplified_exterior]
+            
+            # Simplify, offset, and convert each hole only if allowed
+            final_holes = []
+            if allow_holes:
+                for hole_coords in holes_coords_list:
+                    simplified_hole = simplify_polygon(hole_coords, 0.1)
+                    if len(simplified_hole) >= 3:
+                        hole_points = [QPointF(p[0] + offset_x, p[1] + offset_y) for p in simplified_hole]
+                        final_holes.append(hole_points)
+            
+            # Require at least 3 points for valid polygon
+            if len(self.points) < 3:
+                return None
+                
+            # Create final annotation, now passing the holes argument
+            annotation = PolygonAnnotation(
+                points=self.points,
+                holes=final_holes,
+                short_label_code=self.annotation_window.selected_label.short_label_code,
+                long_label_code=self.annotation_window.selected_label.long_label_code,
+                color=self.annotation_window.selected_label.color,
+                image_path=self.annotation_window.current_image_path,
+                label_id=self.annotation_window.selected_label.id,
+                transparency=self.main_window.label_window.active_label.transparency
+            )
+            
+        return annotation
+
     def cancel_working_area(self):
         """
         Cancel the working area and clean up all associated resources.

coralnet_toolbox/Transformers/Models/GroundingDINO.py

@@ -0,0 +1,72 @@
+from dataclasses import dataclass
+
+import torch
+
+from ultralytics.engine.results import Results
+
+from transformers import AutoProcessor, AutoModelForZeroShotObjectDetection
+
+from autodistill.detection import CaptionOntology
+
+from coralnet_toolbox.Transformers.Models.QtBase import QtBaseModel
+
+
+# ----------------------------------------------------------------------------------------------------------------------
+# Classes
+# ----------------------------------------------------------------------------------------------------------------------
+
+
+@dataclass
+class GroundingDINOModel(QtBaseModel):
+    def __init__(self, ontology: CaptionOntology, model="SwinB", device: str = "cpu"):
+        super().__init__(ontology, device)
+        
+        if model == "SwinB":
+            model_name = "IDEA-Research/grounding-dino-base"
+        else:
+            model_name = "IDEA-Research/grounding-dino-tiny"
+            
+        self.processor = AutoProcessor.from_pretrained(model_name, use_fast=True)
+        self.model = AutoModelForZeroShotObjectDetection.from_pretrained(model_name).to(self.device)
+
+    def _process_predictions(self, image, texts, confidence):
+        """Process model predictions for a single image."""
+        inputs = self.processor(text=texts, images=image, return_tensors="pt").to(self.device)
+        outputs = self.model(**inputs)
+
+        results_processed = self.processor.post_process_grounded_object_detection(
+            outputs,
+            inputs.input_ids,
+            threshold=confidence,
+            target_sizes=[image.shape[:2]],
+        )[0]
+
+        boxes = results_processed["boxes"]
+        scores = results_processed["scores"]
+        
+        # If no objects are detected, return an empty list to match the original behavior.
+        if scores.nelement() == 0:
+            return []
+
+        # Per original logic, assign all detections to class_id 0.
+        # TODO: We are only supporting a single class right now
+        class_ids = torch.zeros(scores.shape[0], 1, device=self.device)
+
+        # Combine boxes, scores, and class_ids into the (N, 6) tensor format
+        # required by the Results object: [x1, y1, x2, y2, confidence, class_id]
+        combined_data = torch.cat([
+            boxes,
+            scores.unsqueeze(1),
+            class_ids
+        ], dim=1)
+
+        # Create the dictionary mapping class indices to class names.
+        names = {idx: text for idx, text in enumerate(self.ontology.classes())}
+        
+        # Create the Results object with a DETACHED tensor
+        result = Results(orig_img=image, 
+                         path=None, 
+                         names=names, 
+                         boxes=combined_data.detach().cpu())
+        
+        return result

coralnet_toolbox/Transformers/Models/OWLViT.py

@@ -0,0 +1,72 @@
+from dataclasses import dataclass
+
+import torch
+
+from ultralytics.engine.results import Results
+
+from transformers import OwlViTForObjectDetection, OwlViTProcessor
+
+from autodistill.detection import CaptionOntology
+
+from coralnet_toolbox.Transformers.Models.QtBase import QtBaseModel
+
+
+# ----------------------------------------------------------------------------------------------------------------------
+# Classes
+# ----------------------------------------------------------------------------------------------------------------------
+
+
+@dataclass
+class OWLViTModel(QtBaseModel):
+    def __init__(self, ontology: CaptionOntology, device: str = "cpu"):
+        super().__init__(ontology, device)
+        
+        model_name = "google/owlvit-base-patch32"
+        self.processor = OwlViTProcessor.from_pretrained(model_name, use_fast=True)
+        self.model = OwlViTForObjectDetection.from_pretrained(model_name).to(self.device)
+
+    def _process_predictions(self, image, texts, confidence):
+        """
+        Process model predictions for a single image, converting directly
+        to an Ultralytics Results object without an intermediate Supervision object.
+        """
+        inputs = self.processor(text=texts, images=image, return_tensors="pt").to(self.device)
+        outputs = self.model(**inputs)
+
+        # Post-process the outputs to get detections.
+        # The confidence threshold is applied during this step.
+        results_processed = self.processor.post_process_object_detection(
+            outputs,
+            threshold=confidence,
+            target_sizes=[image.shape[:2]]
+        )[0]
+
+        boxes = results_processed["boxes"]
+        scores = results_processed["scores"]
+        
+        # If no objects are detected, return an empty list to match the original behavior.
+        if scores.nelement() == 0:
+            return []
+
+        # Per original logic, assign all detections to class_id 0.
+        # TODO: We are only supporting a single class right now
+        class_ids = torch.zeros(scores.shape[0], 1, device=self.device)
+
+        # Combine boxes, scores, and class_ids into the (N, 6) tensor format
+        # required by the Results object: [x1, y1, x2, y2, confidence, class_id]
+        combined_data = torch.cat([
+            boxes,
+            scores.unsqueeze(1),
+            class_ids
+        ], dim=1)
+
+        # Create the dictionary mapping class indices to class names.
+        names = {idx: text for idx, text in enumerate(self.ontology.classes())}
+        
+        # Create the Results object with a DETACHED tensor
+        result = Results(orig_img=image, 
+                         path=None, 
+                         names=names, 
+                         boxes=combined_data.detach().cpu())
+        
+        return result

coralnet_toolbox/Transformers/Models/OmDetTurbo.py

@@ -0,0 +1,68 @@
+from dataclasses import dataclass
+
+import torch
+
+from ultralytics.engine.results import Results
+
+from transformers import AutoProcessor, OmDetTurboForObjectDetection
+
+from autodistill.detection import CaptionOntology
+
+from coralnet_toolbox.Transformers.Models.QtBase import QtBaseModel
+
+
+# ----------------------------------------------------------------------------------------------------------------------
+# Classes
+# ----------------------------------------------------------------------------------------------------------------------
+
+
+@dataclass
+class OmDetTurboModel(QtBaseModel):
+    def __init__(self, ontology: CaptionOntology, device: str = "cpu"):
+        super().__init__(ontology, device)
+        
+        model_name = "omlab/omdet-turbo-swin-tiny-hf"
+        self.processor = AutoProcessor.from_pretrained(model_name, use_fast=True)
+        self.model = OmDetTurboForObjectDetection.from_pretrained(model_name).to(self.device)
+
+    def _process_predictions(self, image, texts, confidence):
+        """Process model predictions for a single image."""
+        inputs = self.processor(text=texts, images=image, return_tensors="pt").to(self.device)
+        outputs = self.model(**inputs)
+
+        results_processed = self.processor.post_process_grounded_object_detection(
+            outputs,
+            threshold=confidence,
+            target_sizes=[image.shape[:2]],
+            text_labels=texts,
+        )[0]
+
+        boxes = results_processed["boxes"]
+        scores = results_processed["scores"]
+        
+        # If no objects are detected, return an empty list to match the original behavior.
+        if scores.nelement() == 0:
+            return []
+
+        # Per original logic, assign all detections to class_id 0.
+        # TODO: We are only supporting a single class right now
+        class_ids = torch.zeros(scores.shape[0], 1, device=self.device)
+
+        # Combine boxes, scores, and class_ids into the (N, 6) tensor format
+        # required by the Results object: [x1, y1, x2, y2, confidence, class_id]
+        combined_data = torch.cat([
+            boxes,
+            scores.unsqueeze(1),
+            class_ids
+        ], dim=1)
+
+        # Create the dictionary mapping class indices to class names.
+        names = {idx: text for idx, text in enumerate(self.ontology.classes())}
+        
+        # Create the Results object with a DETACHED tensor
+        result = Results(orig_img=image, 
+                         path=None, 
+                         names=names, 
+                         boxes=combined_data.detach().cpu())
+        
+        return result

coralnet_toolbox/Transformers/Models/QtBase.py

@@ -0,0 +1,120 @@
+from dataclasses import dataclass
+from abc import ABC, abstractmethod
+
+import cv2
+import numpy as np
+
+from ultralytics.engine.results import Results
+
+from autodistill.detection import CaptionOntology, DetectionBaseModel
+from autodistill.helpers import load_image
+
+from coralnet_toolbox.Results import CombineResults
+
+
+# ----------------------------------------------------------------------------------------------------------------------
+# Classes
+# ----------------------------------------------------------------------------------------------------------------------
+
+
+@dataclass
+class QtBaseModel(DetectionBaseModel, ABC):
+    """
+    Base class for Transformer foundation models that provides common functionality for 
+    handling inputs, processing image data, and formatting detection results.
+    """
+    ontology: CaptionOntology
+
+    def __init__(self, ontology: CaptionOntology, device: str = "cpu"):
+        """
+        Initialize the base model with ontology and device.
+        
+        Args:
+            ontology: The CaptionOntology containing class labels
+            device: The compute device (cpu, cuda, etc.)
+        """
+        self.ontology = ontology
+        self.device = device
+        self.processor = None
+        self.model = None
+        
+    def _normalize_input(self, input) -> list[np.ndarray]:
+        """
+        Normalizes various input types into a list of images in CV2 (BGR) format.
+
+        Args:
+            input: Can be an image path, a list of paths, a numpy array, or a list of numpy arrays.
+
+        Returns:
+            A list of images, each as a numpy array in CV2 (BGR) format.
+        """
+        images = []
+        if isinstance(input, str):
+            # Single image path
+            images = [load_image(input, return_format="cv2")]
+        elif isinstance(input, np.ndarray):
+            # Single image numpy array (RGB) or a batch of images (NHWC, RGB)
+            if input.ndim == 3:
+                images = [cv2.cvtColor(input, cv2.COLOR_RGB2BGR)]
+            elif input.ndim == 4:
+                images = [cv2.cvtColor(img, cv2.COLOR_RGB2BGR) for img in input]
+            else:
+                raise ValueError(f"Unsupported numpy array dimensions: {input.ndim}")
+        elif isinstance(input, list):
+            if all(isinstance(i, str) for i in input):
+                # List of image paths
+                images = [load_image(path, return_format="cv2") for path in input]
+            elif all(isinstance(i, np.ndarray) for i in input):
+                # List of image arrays (RGB)
+                images = [cv2.cvtColor(img, cv2.COLOR_RGB2BGR) for img in input]
+            else:
+                raise ValueError("A list input must contain either all image paths or all numpy arrays.")
+        else:
+            raise TypeError(f"Unsupported input type: {type(input)}")
+        
+        return images
+        
+    @abstractmethod
+    def _process_predictions(self, image: np.ndarray, texts: list[str], confidence: float) -> Results:
+        """
+        Process model predictions for a single image.
+        
+        Args:
+            image: The input image in CV2 (BGR) format.
+            texts: The text prompts from the ontology.
+            confidence: Confidence threshold.
+            
+        Returns:
+            A single Ultralytics Results object, which may be empty if no detections are found.
+        """
+        pass
+
+    def predict(self, inputs, confidence=0.01) -> list[Results]:
+        """
+        Run inference on input images.
+        
+        Args:
+            inputs: Can be an image path, a list of image paths, a numpy array, or a list of numpy arrays.
+            confidence: Detection confidence threshold.
+            
+        Returns:
+            A flat list of Ultralytics Results objects, one for each input image.
+        """
+        # Step 1: Normalize the input into a consistent list of images
+        normalized_inputs = self._normalize_input(inputs)
+
+        # Step 2: Prepare for inference
+        results = []
+        texts = self.ontology.prompts()
+        
+        # Step 3: Loop through images and process predictions
+        for normalized_input in normalized_inputs:
+            result = self._process_predictions(normalized_input, texts, confidence)
+            if result:
+                results.append(result)
+        
+        if len(results):
+            # Combine the results into one, then wrap in a list
+            results = CombineResults().combine_results(results)
+
+        return [results] if results else []

coralnet_toolbox/{AutoDistill → Transformers}/Models/__init__.py

@@ -1,4 +1,4 @@
-# coralnet_toolbox/AutoDistill/Models/__init__.py
+# coralnet_toolbox/Transformers/Models/__init__.py
 
 from .GroundingDINO import GroundingDINOModel
 from .OWLViT import OWLViTModel