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

coralnet_toolbox/Annotations/QtRectangleAnnotation.py

@@ -57,9 +57,14 @@ class RectangleAnnotation(Annotation):
 
     def set_cropped_bbox(self):
         """Set the cropped bounding box for the annotation."""
+        # Store the raw coordinates, keeping the top_left and bottom_right as they are
+        # to maintain the user's dragging experience
         self.cropped_bbox = (self.top_left.x(), self.top_left.y(), self.bottom_right.x(), self.bottom_right.y())
-        self.annotation_size = int(max(self.bottom_right.x() - self.top_left.x(),
-                                       self.bottom_right.y() - self.top_left.y()))
+        
+        # Calculate annotation_size using absolute differences to handle inverted coordinates
+        width = abs(self.bottom_right.x() - self.top_left.x())
+        height = abs(self.bottom_right.y() - self.top_left.y())
+        self.annotation_size = int(max(width, height))
 
     def contains_point(self, point: QPointF) -> bool:
         """Check if the given point is within the rectangle."""
@@ -172,6 +177,10 @@ class RectangleAnnotation(Annotation):
         self.set_cropped_bbox()
         # Get the bounding box of the rectangle
         min_x, min_y, max_x, max_y = self.cropped_bbox
+        
+        # Ensure min/max values are correctly ordered to avoid negative width/height
+        min_x, max_x = min(min_x, max_x), max(min_x, max_x)
+        min_y, max_y = min(min_y, max_y), max(min_y, max_y)
 
         # Calculate the window for rasterio
         window = Window(
@@ -275,10 +284,30 @@ class RectangleAnnotation(Annotation):
         elif handle == "bottom_right":
             self.bottom_right = new_pos
 
+        # Normalize coordinates to ensure top_left has smaller values than bottom_right
+        self.normalize_coordinates()
+        
         self.set_precision(self.top_left, self.bottom_right)
         self.set_centroid()
         self.update_graphics_item()
         self.annotationUpdated.emit(self)
+        
+    def normalize_coordinates(self):
+        """Ensure that top_left has smaller coordinates than bottom_right."""
+        # Create temporary points to store the normalized coordinates
+        x_min = min(self.top_left.x(), self.bottom_right.x())
+        y_min = min(self.top_left.y(), self.bottom_right.y())
+        x_max = max(self.top_left.x(), self.bottom_right.x())
+        y_max = max(self.top_left.y(), self.bottom_right.y())
+        
+        # Update the points
+        self.top_left.setX(x_min)
+        self.top_left.setY(y_min)
+        self.bottom_right.setX(x_max)
+        self.bottom_right.setY(y_max)
+        
+        # Update centroid after normalization
+        self.set_centroid()
 
     @classmethod
     def combine(cls, annotations: list):

coralnet_toolbox/AutoDistill/QtDeployModel.py

@@ -52,7 +52,7 @@ class DeployModelDialog(QDialog):
         self.annotation_window = main_window.annotation_window
 
         self.setWindowIcon(get_icon("coral.png"))
-        self.setWindowTitle("AutoDistill Deploy Model (Ctrl + 5)")
+        self.setWindowTitle("AutoDistill Deploy Model (Ctrl + 6)")
         self.resize(400, 325)
 
         # Initialize variables
@@ -350,18 +350,29 @@ class DeployModelDialog(QDialog):
 
     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/Explorer/QtDataItem.py

@@ -94,6 +94,7 @@ class AnnotationImageWidget(QWidget):
         self.widget_height = widget_height
         self.aspect_ratio = 1.0
         self.pixmap = None
+        self.is_loaded = False  # Flag for lazy loading
 
         self.animation_offset = 0
         self.animation_timer = QTimer(self)
@@ -101,7 +102,9 @@ class AnnotationImageWidget(QWidget):
         self.animation_timer.setInterval(75)
 
         self.setup_ui()
-        self.load_and_set_image()
+        self.recalculate_aspect_ratio()  # Calculate aspect ratio from geometry
+        self.update_height(self.widget_height)  # Set initial size
+        self.update_tooltip()
 
     def setup_ui(self):
         """Set up the basic UI with a label for the image."""
@@ -117,43 +120,72 @@ class AnnotationImageWidget(QWidget):
         """Updates the tooltip by fetching the latest text from the data item."""
         self.setToolTip(self.data_item.get_tooltip_text())
 
-    def load_and_set_image(self):
-        """Load image, calculate its aspect ratio, and set the widget's initial size."""
+    def recalculate_aspect_ratio(self):
+        """Calculate aspect ratio from annotation geometry without loading image."""
+        try:
+            if hasattr(self.annotation, 'rect'):  # RectangleAnnotation
+                rect = self.annotation.rect
+                if rect.height() > 0:
+                    self.aspect_ratio = rect.width() / rect.height()
+            elif hasattr(self.annotation, 'size'):  # PatchAnnotation
+                self.aspect_ratio = 1.0
+            elif hasattr(self.annotation, 'polygon'):  # PolygonAnnotation
+                rect = self.annotation.polygon.boundingRect()
+                if rect.height() > 0:
+                    self.aspect_ratio = rect.width() / rect.height()
+            else:
+                # Fallback for other types or if geometry is not available
+                self.aspect_ratio = 1.0
+        except Exception as e:
+            print(f"Could not determine aspect ratio for {self.annotation.id}: {e}")
+            self.aspect_ratio = 1.0
+
+    def load_image(self):
+        """Loads the image pixmap if it hasn't been loaded yet."""
+        if self.is_loaded:
+            return
+
         try:
             cropped_pixmap = self.annotation.get_cropped_image_graphic()
             if cropped_pixmap and not cropped_pixmap.isNull():
                 self.pixmap = cropped_pixmap
-                if self.pixmap.height() > 0:
-                    self.aspect_ratio = self.pixmap.width() / self.pixmap.height()
-                else:
-                    self.aspect_ratio = 1.0
+                self.is_loaded = True
+                self._display_pixmap()
             else:
                 self.image_label.setText("No Image\nAvailable")
                 self.pixmap = None
-                self.aspect_ratio = 1.0
         except Exception as e:
             print(f"Error loading annotation image: {e}")
             self.image_label.setText("Error\nLoading Image")
             self.pixmap = None
-            self.aspect_ratio = 1.0
-            
-        self.update_height(self.widget_height)
-        # Set the initial tooltip
-        self.update_tooltip()
 
-    def update_height(self, new_height):
-        """Updates the widget's height and rescales its width and content accordingly."""
-        self.widget_height = new_height
-        new_width = int(self.widget_height * self.aspect_ratio)
-        self.setFixedSize(new_width, new_height)
+    def unload_image(self):
+        """Unloads the pixmap to free memory."""
+        if not self.is_loaded:
+            return
+        self.pixmap = None
+        self.image_label.clear()
+        self.is_loaded = False
+
+    def _display_pixmap(self):
+        """Scales and displays the currently loaded pixmap."""
         if self.pixmap:
+            new_width = int(self.widget_height * self.aspect_ratio)
             scaled_pixmap = self.pixmap.scaled(
                 new_width - 8,
-                new_height - 8,
+                self.widget_height - 8,
                 Qt.KeepAspectRatio,
                 Qt.SmoothTransformation
             )
             self.image_label.setPixmap(scaled_pixmap)
+
+    def update_height(self, new_height):
+        """Updates the widget's height and rescales its width and content accordingly."""
+        self.widget_height = new_height
+        new_width = int(self.widget_height * self.aspect_ratio)
+        self.setFixedSize(new_width, new_height)
+        if self.pixmap:
+            self._display_pixmap()
         self.update()
 
     def update_selection_visuals(self):
@@ -240,7 +272,7 @@ class AnnotationDataItem:
         
         self.embedding_x = embedding_x if embedding_x is not None else 0.0
         self.embedding_y = embedding_y if embedding_y is not None else 0.0
-        self.embedding_id = embedding_id if embedding_id is not None else 0
+        self.embedding_id = embedding_id
         
         self._is_selected = False
         self._preview_label = None
@@ -336,4 +368,4 @@ class AnnotationDataItem:
             return list(self.annotation.user_confidence.values())[0]
         elif hasattr(self.annotation, 'machine_confidence') and self.annotation.machine_confidence:
             return list(self.annotation.machine_confidence.values())[0]
-        return 0.0
+        return 0.0