coralnet-toolbox 0.0.66__tar.gz → 0.0.67__tar.gz

{coralnet_toolbox-0.0.66 → coralnet_toolbox-0.0.67}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: coralnet-toolbox
-Version: 0.0.66
+Version: 0.0.67
 Summary: Tools for annotating and developing ML models for benthic imagery
 Author-email: Jordan Pierce <jordan.pierce@noaa.gov>
 License: MIT License
@@ -21,6 +21,7 @@ Requires-Dist: lap>=0.5.12
 Requires-Dist: open-clip-torch>=2.20.0
 Requires-Dist: supervision>=0.24.0
 Requires-Dist: scikit-learn
+Requires-Dist: umap-learn
 Requires-Dist: pycocotools
 Requires-Dist: ujson
 Requires-Dist: timm==0.9.2

{coralnet_toolbox-0.0.66 → coralnet_toolbox-0.0.67}/coralnet_toolbox/Annotations/QtMultiPolygonAnnotation.py

@@ -152,7 +152,7 @@ class MultiPolygonAnnotation(Annotation):
         result_painter.drawPixmap(0, 0, self.cropped_image)
 
         # Draw dashed outline for each polygon
-        pen = QPen(self.label.color)
+        pen = QPen(Qt.black)
         pen.setStyle(Qt.SolidLine)  # Solid line
         pen.setWidth(1)  # Line width
         result_painter.setPen(pen)

{coralnet_toolbox-0.0.66 → coralnet_toolbox-0.0.67}/coralnet_toolbox/Annotations/QtPatchAnnotation.py

@@ -157,7 +157,7 @@ class PatchAnnotation(Annotation):
         result_painter.drawPixmap(0, 0, self.cropped_image)
 
         # Draw the dotted line outline on top
-        pen = QPen(self.label.color)
+        pen = QPen(Qt.black)
         pen.setStyle(Qt.SolidLine)  # Solid line
         pen.setWidth(1)  # Line width
         result_painter.setPen(pen)

{coralnet_toolbox-0.0.66 → coralnet_toolbox-0.0.67}/coralnet_toolbox/Annotations/QtPolygonAnnotation.py

@@ -178,7 +178,7 @@ class PolygonAnnotation(Annotation):
         result_painter.drawPixmap(0, 0, self.cropped_image)
 
         # Draw the dotted line outline on top
-        pen = QPen(self.label.color)
+        pen = QPen(Qt.black)
         pen.setStyle(Qt.SolidLine)  # Solid line
         pen.setWidth(1)  # Line width
         result_painter.setPen(pen)

{coralnet_toolbox-0.0.66 → coralnet_toolbox-0.0.67}/coralnet_toolbox/Annotations/QtRectangleAnnotation.py

@@ -153,7 +153,7 @@ class RectangleAnnotation(Annotation):
         result_painter.drawPixmap(0, 0, self.cropped_image)
 
         # Draw the dotted line outline on top
-        pen = QPen(self.label.color)
+        pen = QPen(Qt.black)
         pen.setStyle(Qt.SolidLine)  # Solid line
         pen.setWidth(1)  # Line width
         result_painter.setPen(pen)

{coralnet_toolbox-0.0.66 → coralnet_toolbox-0.0.67}/coralnet_toolbox/AutoDistill/QtDeployModel.py

@@ -555,6 +555,10 @@ class DeployModelDialog(QDialog):
         self.update_sam_task_state()
         if self.task != 'segment':
             return results_list
+        
+        if not self.sam_dialog or self.use_sam_dropdown.currentText() == "False":
+            # If SAM is not deployed or not selected, return the results as is
+            return results_list
 
         if self.sam_dialog.loaded_model is None:
             # If SAM is not loaded, ensure we do not use it accidentally

coralnet_toolbox-0.0.67/coralnet_toolbox/Explorer/QtAnnotationDataItem.py

@@ -0,0 +1,97 @@
+import warnings
+
+import os
+
+warnings.filterwarnings("ignore", category=DeprecationWarning)
+
+
+# ----------------------------------------------------------------------------------------------------------------------
+# Classes
+# ----------------------------------------------------------------------------------------------------------------------
+
+
+class AnnotationDataItem:
+    """Holds annotation information for consistent display across viewers."""
+
+    def __init__(self, annotation, embedding_x=None, embedding_y=None, embedding_id=None):
+        self.annotation = annotation
+        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._is_selected = False
+        self._preview_label = None
+        self._original_label = annotation.label
+        self._marked_for_deletion = False  # Track deletion status
+
+    @property
+    def effective_label(self):
+        """Get the current effective label (preview if exists, otherwise original)."""
+        return self._preview_label if self._preview_label else self.annotation.label
+
+    @property
+    def effective_color(self):
+        """Get the effective color for this annotation."""
+        return self.effective_label.color
+
+    @property
+    def is_selected(self):
+        """Check if this annotation is selected."""
+        return self._is_selected
+
+    def set_selected(self, selected):
+        """Set the selection state."""
+        self._is_selected = selected
+
+    def set_preview_label(self, label):
+        """Set a preview label for this annotation."""
+        self._preview_label = label
+
+    def clear_preview_label(self):
+        """Clear the preview label and revert to original."""
+        self._preview_label = None
+
+    def has_preview_changes(self):
+        """Check if this annotation has preview changes."""
+        return self._preview_label is not None
+
+    def mark_for_deletion(self):
+        """Mark this annotation for deletion."""
+        self._marked_for_deletion = True
+
+    def unmark_for_deletion(self):
+        """Unmark this annotation for deletion."""
+        self._marked_for_deletion = False
+
+    def is_marked_for_deletion(self):
+        """Check if this annotation is marked for deletion."""
+        return self._marked_for_deletion
+
+    def apply_preview_permanently(self):
+        """Apply the preview label permanently to the annotation."""
+        if self._preview_label:
+            self.annotation.update_label(self._preview_label)
+            self.annotation.update_user_confidence(self._preview_label)
+            self._original_label = self._preview_label
+            self._preview_label = None
+            return True
+        return False
+
+    def get_display_info(self):
+        """Get display information for this annotation."""
+        return {
+            'id': self.annotation.id,
+            'label': self.effective_label.short_label_code,
+            'confidence': self.get_effective_confidence(),
+            'type': type(self.annotation).__name__,
+            'image': os.path.basename(self.annotation.image_path),
+            'embedding_id': self.embedding_id,
+            'color': self.effective_color
+        }
+
+    def get_effective_confidence(self):
+        """Get the effective confidence value."""
+        if self.annotation.verified and hasattr(self.annotation, 'user_confidence') and self.annotation.user_confidence:
+            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

coralnet_toolbox-0.0.67/coralnet_toolbox/Explorer/QtAnnotationImageWidget.py

@@ -0,0 +1,183 @@
+import warnings
+
+from PyQt5.QtGui import QPen, QColor, QPainter
+from PyQt5.QtCore import Qt, QTimer
+
+from PyQt5.QtWidgets import (QVBoxLayout, QLabel, QWidget)
+
+
+warnings.filterwarnings("ignore", category=DeprecationWarning)
+
+
+# ----------------------------------------------------------------------------------------------------------------------
+# Constants
+# ----------------------------------------------------------------------------------------------------------------------
+
+ANNOTATION_WIDTH = 5
+
+# ----------------------------------------------------------------------------------------------------------------------
+# Classes
+# ----------------------------------------------------------------------------------------------------------------------
+
+
+class AnnotationImageWidget(QWidget):
+    """Widget to display a single annotation image crop with selection support."""
+
+    def __init__(self, data_item, widget_height=96, annotation_viewer=None, parent=None):
+        super(AnnotationImageWidget, self).__init__(parent)
+        self.data_item = data_item
+        self.annotation = data_item.annotation
+        self.annotation_viewer = annotation_viewer
+
+        self.widget_height = widget_height
+        self.aspect_ratio = 1.0  # Default to a square aspect ratio
+        self.pixmap = None       # Cache the original, unscaled pixmap
+
+        self.animation_offset = 0
+        self.animation_timer = QTimer(self)
+        self.animation_timer.timeout.connect(self._update_animation_frame)
+        self.animation_timer.setInterval(75)
+
+        self.setup_ui()
+        self.load_and_set_image()  # Changed from load_annotation_image
+
+    def setup_ui(self):
+        """Set up the basic UI with a label for the image."""
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(4, 4, 4, 4)
+
+        self.image_label = QLabel()
+        self.image_label.setAlignment(Qt.AlignCenter)
+        self.image_label.setScaledContents(True)
+        self.image_label.setStyleSheet("border: none;")
+
+        layout.addWidget(self.image_label)
+
+    def load_and_set_image(self):
+        """Load image, calculate its aspect ratio, and set the widget's initial size."""
+        try:
+            # Use get_cropped_image_graphic() to get the QPixmap
+            cropped_pixmap = self.annotation.get_cropped_image_graphic()
+            if cropped_pixmap and not cropped_pixmap.isNull():
+                self.pixmap = cropped_pixmap
+                # Safely calculate aspect ratio
+                if self.pixmap.height() > 0:
+                    self.aspect_ratio = self.pixmap.width() / self.pixmap.height()
+                else:
+                    self.aspect_ratio = 1.0
+            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
+
+        # Trigger an initial size update
+        self.update_height(self.widget_height)
+
+    def update_height(self, new_height):
+        """Updates the widget's height and rescales its width and content accordingly."""
+        self.widget_height = new_height
+
+        # Calculate the new width based on the stored aspect ratio
+        new_width = int(self.widget_height * self.aspect_ratio)
+
+        # Set the new fixed size for the entire widget
+        self.setFixedSize(new_width, new_height)
+
+        if self.pixmap:
+            # Scale the cached pixmap to fit the new widget size, leaving room for the border
+            # Note: We use the widget's new dimensions directly
+            scaled_pixmap = self.pixmap.scaled(
+                new_width - 8,  # Account for horizontal margins
+                new_height - 8,  # Account for vertical margins
+                Qt.KeepAspectRatio,
+                Qt.SmoothTransformation
+            )
+            self.image_label.setPixmap(scaled_pixmap)
+
+        self.update()  # Schedule a repaint if needed
+
+    # Replace update_size with update_height
+    def update_size(self, new_size):
+        """Kept for compatibility, redirects to update_height."""
+        self.update_height(new_size)
+
+    def set_selected(self, selected):
+        """Set the selection state and update visual appearance."""
+        was_selected = self.is_selected()
+
+        # Update the shared data item
+        self.data_item.set_selected(selected)
+
+        # Start or stop the animation timer based on the new selection state
+        if selected:
+            if not self.animation_timer.isActive():
+                self.animation_timer.start()
+        else:
+            if self.animation_timer.isActive():
+                self.animation_timer.stop()
+            # Reset offset when deselected to ensure a consistent starting look
+            self.animation_offset = 0
+
+        # A repaint is needed if the selection state changed OR if the item remains
+        # selected (to keep the animation running).
+        if was_selected != selected or selected:
+            self.update()
+
+    def is_selected(self):
+        """Return whether this widget is selected via the data item."""
+        return self.data_item.is_selected
+
+    def _update_animation_frame(self):
+        """Update the animation offset and schedule a repaint."""
+        self.animation_offset = (self.animation_offset + 1) % 20
+        self.update()
+
+    def paintEvent(self, event):
+        """Handle custom drawing for the widget, including the border."""
+        super().paintEvent(event)
+        painter = QPainter(self)
+        painter.setRenderHint(QPainter.Antialiasing)
+
+        # Get the label that is currently active (which could be a preview)
+        effective_label = self.data_item.effective_label
+
+        # Check if the active label is the special "Review" label (id == "-1")
+        if effective_label and effective_label.id == "-1":
+            # If it is, ALWAYS use a black pen for visibility against the white background.
+            pen_color = QColor("black")
+        else:
+            # Otherwise, use the effective color from the data item.
+            pen_color = self.data_item.effective_color
+
+        if self.is_selected():
+            pen = QPen(pen_color, ANNOTATION_WIDTH)
+            pen.setStyle(Qt.CustomDashLine)
+            pen.setDashPattern([2, 3])
+            pen.setDashOffset(self.animation_offset)
+        else:
+            pen = QPen(pen_color, ANNOTATION_WIDTH)
+            pen.setStyle(Qt.SolidLine)
+
+        painter.setPen(pen)
+        painter.setBrush(Qt.NoBrush)
+
+        width = pen.width()
+        half_width = (width - 1) // 2
+        rect = self.rect().adjusted(half_width, half_width, -half_width, -half_width)
+        painter.drawRect(rect)
+
+    def mousePressEvent(self, event):
+        """Handle mouse press events for selection."""
+        if event.button() == Qt.LeftButton:
+            if self.annotation_viewer and hasattr(self.annotation_viewer, 'handle_annotation_selection'):
+                self.annotation_viewer.handle_annotation_selection(self, event)
+        # Ignore right mouse button clicks - don't call super() to prevent any selection
+        elif event.button() == Qt.RightButton:
+            event.ignore()
+            return
+        super().mousePressEvent(event)

coralnet_toolbox-0.0.67/coralnet_toolbox/Explorer/QtEmbeddingPointItem.py

@@ -0,0 +1,30 @@
+import warnings
+
+from PyQt5.QtWidgets import QGraphicsEllipseItem, QStyle
+
+warnings.filterwarnings("ignore", category=DeprecationWarning)
+
+
+# ----------------------------------------------------------------------------------------------------------------------
+# Classes
+# ----------------------------------------------------------------------------------------------------------------------
+
+
+class EmbeddingPointItem(QGraphicsEllipseItem):
+    """
+    A custom QGraphicsEllipseItem that prevents the default selection
+    rectangle from being drawn, and dynamically gets its color from the
+    shared AnnotationDataItem.
+    """
+
+    def paint(self, painter, option, widget):
+        # Get the shared data item, which holds the current state
+        data_item = self.data(0)
+        if data_item:
+            # Set the brush color based on the item's effective color
+            # This ensures preview colors are reflected instantly.
+            self.setBrush(data_item.effective_color)
+
+        # Remove the 'State_Selected' flag to prevent the default box
+        option.state &= ~QStyle.State_Selected
+        super(EmbeddingPointItem, self).paint(painter, option, widget)