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

coralnet_toolbox/Tools/QtSeeAnythingTool.py

@@ -71,9 +71,17 @@ class SeeAnythingTool(Tool):
         self.current_rect_graphics = None  # For the rectangle currently being drawn
         self.rectangles_processed = False  # Track if rectangles have been processed
 
+        # Add state variables for custom working area creation
+        self.creating_working_area = False
+        self.working_area_start = None
+        self.working_area_temp_graphics = None
+        
+        # Add hover position tracking
+        self.hover_pos = None
+        
         self.annotations = []
         self.results = None
-
+    
     def activate(self):
         """
         Activates the tool.
@@ -98,6 +106,9 @@ class SeeAnythingTool(Tool):
 
         # Clean up working area and shadow
         self.cancel_working_area()
+        
+        # Cancel working area creation if in progress
+        self.cancel_working_area_creation()
 
         # Clear detection data
         self.results = None
@@ -165,6 +176,117 @@ class SeeAnythingTool(Tool):
 
         self.annotation_window.setCursor(Qt.CrossCursor)
         self.annotation_window.scene.update()
+        
+    def set_custom_working_area(self, start_point, end_point):
+        """
+        Create a working area from custom points selected by the user.
+        
+        Args:
+            start_point (QPointF): First corner of the working area
+            end_point (QPointF): Opposite corner of the working area
+        """
+        self.annotation_window.setCursor(Qt.WaitCursor)
+        
+        # Cancel any existing working area
+        self.cancel_working_area()
+        
+        # Calculate the rectangle bounds
+        left = max(0, int(min(start_point.x(), end_point.x())))
+        top = max(0, int(min(start_point.y(), end_point.y())))
+        right = min(int(self.annotation_window.pixmap_image.size().width()), 
+                    int(max(start_point.x(), end_point.x())))
+        bottom = min(int(self.annotation_window.pixmap_image.size().height()),
+                     int(max(start_point.y(), end_point.y())))
+        
+        # Ensure minimum size (at least 10x10 pixels)
+        if right - left < 10:
+            right = min(left + 10, int(self.annotation_window.pixmap_image.size().width()))
+        if bottom - top < 10:
+            bottom = min(top + 10, int(self.annotation_window.pixmap_image.size().height()))
+            
+        # Original image information
+        self.image_path = self.annotation_window.current_image_path
+        self.original_image = pixmap_to_numpy(self.annotation_window.pixmap_image)
+        self.original_width = self.annotation_window.pixmap_image.size().width()
+        self.original_height = self.annotation_window.pixmap_image.size().height()
+            
+        # Create the WorkArea instance
+        self.working_area = WorkArea(left, top, right - left, bottom - top, self.image_path)
+        
+        # Get the thickness for the working area graphics
+        pen_width = self.graphics_utility.get_workarea_thickness(self.annotation_window)
+        
+        # Create and add the working area graphics
+        self.working_area.create_graphics(self.annotation_window.scene, pen_width)
+        self.working_area.set_remove_button_visibility(False)
+        self.working_area.removed.connect(self.on_working_area_removed)
+        
+        # Create shadow overlay
+        shadow_brush = QBrush(QColor(0, 0, 0, 150))
+        shadow_path = QPainterPath()
+        shadow_path.addRect(self.annotation_window.scene.sceneRect())
+        shadow_path.addRect(self.working_area.rect)
+        shadow_path = shadow_path.simplified()
+        
+        self.shadow_area = QGraphicsPathItem(shadow_path)
+        self.shadow_area.setBrush(shadow_brush)
+        self.shadow_area.setPen(QPen(Qt.NoPen))
+        self.annotation_window.scene.addItem(self.shadow_area)
+        
+        # Crop the image based on the working area
+        self.work_area_image = self.original_image[top:bottom, left:right]
+        
+        # Set the image in the SeeAnything dialog
+        self.see_anything_dialog.set_image(self.work_area_image, self.image_path)
+        
+        self.annotation_window.setCursor(Qt.CrossCursor)
+        self.annotation_window.scene.update()
+
+    def display_working_area_preview(self, current_pos):
+        """
+        Display a preview rectangle for the working area being created.
+        
+        Args:
+            current_pos (QPointF): Current mouse position
+        """
+        if not self.working_area_start:
+            return
+            
+        # Remove previous preview if it exists
+        if self.working_area_temp_graphics:
+            self.annotation_window.scene.removeItem(self.working_area_temp_graphics)
+            self.working_area_temp_graphics = None
+            
+        # Create preview rectangle
+        rect = QRectF(
+            min(self.working_area_start.x(), current_pos.x()),
+            min(self.working_area_start.y(), current_pos.y()),
+            abs(current_pos.x() - self.working_area_start.x()),
+            abs(current_pos.y() - self.working_area_start.y())
+        )
+        
+        # Create a dashed blue pen for the working area preview
+        pen = QPen(QColor(0, 120, 215))
+        pen.setStyle(Qt.DashLine)
+        pen.setWidth(2)
+        
+        self.working_area_temp_graphics = QGraphicsRectItem(rect)
+        self.working_area_temp_graphics.setPen(pen)
+        self.working_area_temp_graphics.setBrush(QBrush(QColor(0, 120, 215, 30)))  # Light blue transparent fill
+        self.annotation_window.scene.addItem(self.working_area_temp_graphics)
+
+    def cancel_working_area_creation(self):
+        """
+        Cancel the process of creating a working area.
+        """
+        self.creating_working_area = False
+        self.working_area_start = None
+        
+        if self.working_area_temp_graphics:
+            self.annotation_window.scene.removeItem(self.working_area_temp_graphics)
+            self.working_area_temp_graphics = None
+            
+        self.annotation_window.scene.update()
 
     def on_working_area_removed(self, work_area):
         """
@@ -277,12 +399,25 @@ class SeeAnythingTool(Tool):
                                 "A label must be selected before adding an annotation.")
             return None
 
+        # Get position in scene coordinates
+        scene_pos = self.annotation_window.mapToScene(event.pos())
+        
+        # Handle working area creation mode
+        if not self.working_area and event.button() == Qt.LeftButton:
+            if not self.creating_working_area:
+                # Start working area creation
+                self.creating_working_area = True
+                self.working_area_start = scene_pos
+                return
+            elif self.creating_working_area and self.working_area_start:
+                # Finish working area creation
+                self.set_custom_working_area(self.working_area_start, scene_pos)
+                self.cancel_working_area_creation()
+                return
+
         if not self.working_area:
             return
 
-        # Position in the scene
-        scene_pos = self.annotation_window.mapToScene(event.pos())
-
         # Check if the position is within the working area
         if not self.working_area.contains_point(scene_pos):
             return
@@ -319,6 +454,14 @@ class SeeAnythingTool(Tool):
         Args:
             event (QMouseEvent): The mouse move event.
         """
+        scene_pos = self.annotation_window.mapToScene(event.pos())
+        self.hover_pos = scene_pos
+        
+        # Update working area preview during creation
+        if self.creating_working_area and self.working_area_start:
+            self.display_working_area_preview(scene_pos)
+            return
+            
         if self.working_area and self.drawing_rectangle:
             # Update the end point while drawing the rectangle
             self.end_point = self.annotation_window.mapToScene(event.pos())
@@ -334,6 +477,12 @@ class SeeAnythingTool(Tool):
             event (QKeyEvent): The key press event
         """
         if event.key() == Qt.Key_Space:
+            # If creating working area, confirm it
+            if self.creating_working_area and self.working_area_start and self.hover_pos:
+                self.set_custom_working_area(self.working_area_start, self.hover_pos)
+                self.cancel_working_area_creation()
+                return
+        
             # If there is no working area, set it
             if not self.working_area:
                 self.set_working_area()
@@ -359,6 +508,11 @@ class SeeAnythingTool(Tool):
                 self.cancel_working_area()
 
         elif event.key() == Qt.Key_Backspace:
+            # If creating working area, cancel it
+            if self.creating_working_area:
+                self.cancel_working_area_creation()
+                return
+                
             # Cancel current rectangle being drawn
             if self.drawing_rectangle:
                 self.drawing_rectangle = False
@@ -398,8 +552,16 @@ class SeeAnythingTool(Tool):
         # Move the points back to the original image space
         working_area_top_left = self.working_area.rect.topLeft()
 
-        # Predict the mask provided prompts (using only the current user-drawn rectangles)
-        results = self.see_anything_dialog.predict_from_prompts(self.rectangles)[0]
+        task = self.see_anything_dialog.task_dropdown.currentText()
+        masks = None
+        if task == 'segment':
+            masks = []
+            for r in self.rectangles:
+                x1, y1, x2, y2 = r
+                masks.append(np.array([[x1, y1], [x2, y1], [x2, y2], [x1, y2]]))
+
+        # Predict from prompts, providing masks if the task is segmentation
+        results = self.see_anything_dialog.predict_from_prompts(self.rectangles, masks=masks)[0]
 
         if not results:
             # Make cursor normal
@@ -425,54 +587,58 @@ class SeeAnythingTool(Tool):
         # Clear previous annotations if any
         self.clear_annotations()
 
-        # Loop through the results from the current prediction
-        for result in self.results:
-            # Extract values from result
-            confidence = result.boxes.conf.item()
-
-            if confidence < self.main_window.get_uncertainty_thresh():
-                continue
-
-            # Get the bounding box coordinates (x1, y1, x2, y2) in normalized format
-            box = result.boxes.xyxyn.detach().cpu().numpy().squeeze()
-
-            # Convert from normalized coordinates directly to absolute pixel coordinates in the whole image
-            box_abs = box.copy() * np.array([self.work_area_image.shape[1],
-                                             self.work_area_image.shape[0],
-                                             self.work_area_image.shape[1],
-                                             self.work_area_image.shape[0]])
-
-            # Add working area offset to get coordinates in the whole image
-            box_abs[0] += working_area_top_left.x()
-            box_abs[1] += working_area_top_left.y()
-            box_abs[2] += working_area_top_left.x()
-            box_abs[3] += working_area_top_left.y()
-
-            # Check box area relative to **work area view** area
-            box_area = (box_abs[2] - box_abs[0]) * (box_abs[3] - box_abs[1])
-
-            # self.main_window.get_area_thresh_min()
-            if box_area < self.main_window.get_area_thresh_min() * image_area:
-                continue
-
-            if box_area > self.main_window.get_area_thresh_max() * image_area:
-                continue
-
-            if self.see_anything_dialog.task == "segment":
-                # Use polygons from result.masks.data.xyn (list of polygons, each Nx2, normalized to crop)
-                polygon = result.masks.xyn[0]  # np.array of polygons, each as Nx2 array
-
-                # Convert normalized polygon points directly to whole image coordinates
-                polygon[:, 0] = polygon[:, 0] * self.work_area_image.shape[1] + working_area_top_left.x()
-                polygon[:, 1] = polygon[:, 1] * self.work_area_image.shape[0] + working_area_top_left.y()
-
-                polygon = simplify_polygon(polygon, 0.1)
-
-                # Create the polygon annotation and add it to self.annotations
-                self.create_polygon_annotation(polygon, confidence)
-            else:
-                # Create the rectangle annotation and add it to self.annotations
-                self.create_rectangle_annotation(box_abs, confidence)
+        # Process results based on the task type
+        if self.see_anything_dialog.task == "segment":
+            if self.results.masks:
+                for i, polygon in enumerate(self.results.masks.xyn):
+                    confidence = self.results.boxes.conf[i].item()
+                    if confidence < self.main_window.get_uncertainty_thresh():
+                        continue
+
+                    # Get absolute bounding box for area check (relative to work area)
+                    box_work_area = self.results.boxes.xyxy[i].detach().cpu().numpy()
+                    box_area = (box_work_area[2] - box_work_area[0]) * (box_work_area[3] - box_work_area[1])
+
+                    # Area filtering
+                    min_area = self.main_window.get_area_thresh_min() * image_area
+                    max_area = self.main_window.get_area_thresh_max() * image_area
+                    if not (min_area <= box_area <= max_area):
+                        continue
+
+                    # Convert normalized polygon points to absolute coordinates in the whole image
+                    polygon_abs = polygon.copy()
+                    polygon_abs[:, 0] = polygon_abs[:, 0] * self.work_area_image.shape[1] + working_area_top_left.x()
+                    polygon_abs[:, 1] = polygon_abs[:, 1] * self.work_area_image.shape[0] + working_area_top_left.y()
+
+                    polygon_abs = simplify_polygon(polygon_abs, 0.1)
+                    self.create_polygon_annotation(polygon_abs, confidence)
+                    
+        else:  # Task is 'detect'
+            if self.results.boxes:
+                for i, box_norm in enumerate(self.results.boxes.xyxyn):
+                    confidence = self.results.boxes.conf[i].item()
+                    if confidence < self.main_window.get_uncertainty_thresh():
+                        continue
+
+                    # Convert normalized box to absolute coordinates in the work area
+                    box_abs_work_area = box_norm.detach().cpu().numpy() * np.array(
+                        [self.work_area_image.shape[1], self.work_area_image.shape[0],
+                         self.work_area_image.shape[1], self.work_area_image.shape[0]])
+                    box_area = (box_abs_work_area[2] - box_abs_work_area[0]) * (box_abs_work_area[3] - box_abs_work_area[1])
+
+                    # Area filtering
+                    min_area = self.main_window.get_area_thresh_min() * image_area
+                    max_area = self.main_window.get_area_thresh_max() * image_area
+                    if not (min_area <= box_area <= max_area):
+                        continue
+
+                    # Add working area offset to get coordinates in the whole image
+                    box_abs_full = box_abs_work_area.copy()
+                    box_abs_full[0] += working_area_top_left.x()
+                    box_abs_full[1] += working_area_top_left.y()
+                    box_abs_full[2] += working_area_top_left.x()
+                    box_abs_full[3] += working_area_top_left.y()
+                    self.create_rectangle_annotation(box_abs_full, confidence)
 
         self.annotation_window.scene.update()
 
@@ -750,4 +916,3 @@ class SeeAnythingTool(Tool):
 
         # Force update to ensure graphics are removed visually
         self.annotation_window.scene.update()
-

coralnet_toolbox/Tools/QtSelectSubTool.py

@@ -1,5 +1,5 @@
 from PyQt5.QtCore import Qt, QRectF
-from PyQt5.QtGui import QPen, QColor
+from PyQt5.QtGui import QPen, QColor, QBrush
 from PyQt5.QtWidgets import QGraphicsRectItem
 
 from coralnet_toolbox.Tools.QtSubTool import SubTool
@@ -22,15 +22,17 @@ class SelectSubTool(SubTool):
         super().activate(event)
         self.selection_start_pos = self.annotation_window.mapToScene(event.pos())
         
-        # Create and style the selection rectangle
+        # Create and style the selection rectangle (dashed blue, light blue fill)
         self.selection_rectangle = QGraphicsRectItem()
         width = self.parent_tool.graphics_utility.get_rectangle_graphic_thickness(self.annotation_window)
-        pen = QPen(QColor(255, 255, 255), 2, Qt.DashLine)
+        pen = QPen(QColor(0, 120, 215))
+        pen.setStyle(Qt.DashLine)
         pen.setWidth(width)
         self.selection_rectangle.setPen(pen)
+        self.selection_rectangle.setBrush(QBrush(QColor(0, 120, 215, 30)))  # Light blue transparent fill
         self.selection_rectangle.setRect(QRectF(self.selection_start_pos, self.selection_start_pos))
         self.annotation_window.scene.addItem(self.selection_rectangle)
-
+        
     def deactivate(self):
         super().deactivate()
         if self.selection_rectangle:

coralnet_toolbox/Tools/QtSelectTool.py

@@ -49,6 +49,7 @@ class SelectTool(Tool):
 
         # --- State for transient UI (like resize handles) ---
         self.resize_handles_visible = False
+        self.selection_locked = False
 
         self._connect_signals()
 
@@ -81,16 +82,36 @@ class SelectTool(Tool):
         self.deactivate_subtool()
         self._hide_resize_handles()
         self.annotation_window.viewport().setCursor(self.cursor)
+        self.selection_locked = False
 
     def deactivate(self):
         self.deactivate_subtool()
         self._hide_resize_handles()
         self.annotation_window.viewport().setCursor(self.default_cursor)
+        self.selection_locked = False
         super().deactivate()
 
     # --- Event Handlers (Dispatcher Logic) ---
 
     def mousePressEvent(self, event: QMouseEvent):
+        if self.selection_locked:
+            # If selection is locked, only allow interaction with resize handles.
+            # Check if a handle was clicked to start a resize operation.
+            position = self.annotation_window.mapToScene(event.pos())
+            items = self.annotation_window.scene.items(position)
+            if self.resize_handles_visible:
+                for item in items:
+                    if item in self.resize_subtool.resize_handles_items:
+                        handle_name = item.data(1)
+                        if handle_name and len(self.selected_annotations) == 1:
+                            self.set_active_subtool(
+                                self.resize_subtool, event,
+                                annotation=self.selected_annotations[0],
+                                handle_name=handle_name
+                            )
+                            return  # Exit after starting resize
+            return  # Otherwise, ignore the click entirely
+        
         # Ignore right mouse button events (used for panning)
         if event.button() == Qt.RightButton:
             return
@@ -215,14 +236,35 @@ class SelectTool(Tool):
         return self.annotation_window.annotations_dict.get(annotation_id) if annotation_id else None
 
     def _get_annotation_from_items(self, items, position):
-        """Finds the first valid annotation at a position from a list of items."""
-        for item in items:
-            # We don't want to select by clicking a resize handle
-            if item in self.resize_subtool.resize_handles_items:
-                continue
+        """
+        Finds the first valid annotation at a position from a list of items.
+        First prioritizes annotations where the center graphic contains the point,
+        then falls back to any annotation that contains the point.
+        """
+        # Filter out resize handles
+        valid_items = [item for item in items if item not in self.resize_subtool.resize_handles_items]
+        
+        center_threshold = 10.0  # Distance threshold in pixels to consider a click "on center"
+        center_candidates = []
+        general_candidates = []
+        
+        # Gather all potential candidates
+        for item in valid_items:
             annotation = self._get_annotation_from_item(item)
             if annotation and annotation.contains_point(position):
-                return annotation
+                # Calculate distance to center
+                center_distance = (position - annotation.center_xy).manhattanLength()
+                if center_distance <= center_threshold:
+                    center_candidates.append(annotation)
+                else:
+                    general_candidates.append(annotation)
+        
+        # Return priority: center candidates first, then general candidates
+        if center_candidates:
+            return center_candidates[0]
+        elif general_candidates:
+            return general_candidates[0]
+                
         return None
 
     def _handle_annotation_selection(self, position, items, modifiers):

coralnet_toolbox/Tools/QtWorkAreaTool.py

@@ -1,7 +1,7 @@
 import warnings
 
-from PyQt5.QtCore import Qt, QPointF, QRectF
-from PyQt5.QtGui import QMouseEvent, QPen, QColor
+from PyQt5.QtCore import Qt, QRectF
+from PyQt5.QtGui import QMouseEvent, QPen, QColor, QBrush
 from PyQt5.QtWidgets import (QGraphicsRectItem, QMessageBox, QGraphicsPixmapItem)
 
 from coralnet_toolbox.Tools.QtTool import Tool
@@ -30,8 +30,8 @@ class WorkAreaTool(Tool):
         self.current_rect = None
         self.work_areas = []  # List to store WorkArea objects for the current image
         
-        # Style settings for drawing the work area rectangle
-        self.work_area_pen = QPen(QColor(255, 255, 255), 2, Qt.DashLine)
+        # Style settings for drawing the work area rectangle - update to use blue dashed line
+        self.work_area_pen = QPen(QColor(0, 120, 215), 2, Qt.DashLine)
         
         # Track if Ctrl key is pressed
         self.ctrl_pressed = False
@@ -43,6 +43,9 @@ class WorkAreaTool(Tool):
         # Track current image path to detect image changes
         self.current_image_path = None
         
+        # Add hover position tracking for preview
+        self.hover_pos = None
+    
     def activate(self):
         """Activate the work area tool and set the appropriate cursor."""
         self.active = True
@@ -100,10 +103,12 @@ class WorkAreaTool(Tool):
                 
     def mouseMoveEvent(self, event: QMouseEvent):
         """Handle mouse move events to update the work area while drawing."""
+        scene_pos = self.annotation_window.mapToScene(event.pos())
+        self.hover_pos = scene_pos  # Track hover position for spacebar confirmation
+        
         if not self.drawing or not self.annotation_window.active_image:
             return
             
-        scene_pos = self.annotation_window.mapToScene(event.pos())
         self.update_drawing(scene_pos)
         
     def mouseReleaseEvent(self, event: QMouseEvent):
@@ -116,6 +121,11 @@ class WorkAreaTool(Tool):
         modifiers = event.modifiers()
         key = event.key()
 
+        # Confirm current drawing with spacebar
+        if key == Qt.Key_Space and self.drawing and self.hover_pos:
+            self.finish_drawing(self.hover_pos)
+            return
+
         # Ctrl+Alt for temporary work area
         if (modifiers & Qt.ControlModifier) and (modifiers & Qt.AltModifier):
             if not self.temporary_work_area:
@@ -139,12 +149,12 @@ class WorkAreaTool(Tool):
             return
 
         # Ctrl+Space to create a work area from current view
-        if key == Qt.Key_Space and self.annotation_window.active_image:
+        if key == Qt.Key_Space and self.annotation_window.active_image and not self.drawing:
             self.create_work_area_from_current_view()
             return
 
-        # Cancel current drawing (Backspace - without modifiers)
-        if key == Qt.Key_Backspace and self.drawing and not (modifiers & Qt.ControlModifier):
+        # Cancel current drawing (Backspace or Escape - without modifiers)
+        if (key == Qt.Key_Backspace or key == Qt.Key_Escape) and self.drawing and not (modifiers & Qt.ControlModifier):
             self.cancel_drawing()
             return
 
@@ -207,12 +217,13 @@ class WorkAreaTool(Tool):
         # Create an initial rectangle item for visual feedback
         self.current_rect = QGraphicsRectItem(QRectF(pos.x(), pos.y(), 0, 0))
         
-        # Get the width
-        width = self.graphics_utility.get_rectangle_graphic_thickness(self.annotation_window)
+        # Create a dashed blue pen for the working area preview
+        pen = QPen(QColor(0, 120, 215))
+        pen.setStyle(Qt.DashLine)
+        pen.setWidth(2)
         
-        # Set the pen properties
-        self.work_area_pen.setWidth(width)
-        self.current_rect.setPen(self.work_area_pen)
+        self.current_rect.setPen(pen)
+        self.current_rect.setBrush(QBrush(QColor(0, 120, 215, 30)))  # Light blue transparent fill
         self.annotation_window.scene.addItem(self.current_rect)
         
     def update_drawing(self, pos):
@@ -227,6 +238,7 @@ class WorkAreaTool(Tool):
         constrained_rect = self.constrain_rect_to_image_bounds(rect)
         
         self.current_rect.setRect(constrained_rect)
+        self.hover_pos = pos  # Update hover position for key events
         
     def finish_drawing(self, pos):
         """Finish drawing the work area and add it to the list."""

coralnet_toolbox/__init__.py

@@ -1,6 +1,6 @@
 """Top-level package for CoralNet-Toolbox."""
 
-__version__ = "0.0.71"
+__version__ = "0.0.73"
 __author__ = "Jordan Pierce"
 __email__ = "jordan.pierce@noaa.gov"
 __credits__ = "National Center for Coastal and Ocean Sciences (NCCOS)"

{coralnet_toolbox-0.0.71.dist-info → coralnet_toolbox-0.0.73.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: coralnet-toolbox
-Version: 0.0.71
+Version: 0.0.73
 Summary: Tools for annotating and developing ML models for benthic imagery
 Author-email: Jordan Pierce <jordan.pierce@noaa.gov>
 License: MIT License