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

coralnet_toolbox/Tools/QtCutSubTool.py

@@ -87,9 +87,16 @@ class CutSubTool(SubTool):
         self._update_cut_line_path(position)
 
     def keyPressEvent(self, event):
-        """Handle key press events for canceling the cut."""
-        if event.key() in (Qt.Key_Backspace, Qt.Key_Escape):
+        """Handle key press events for cutting operations."""
+        # Check for Ctrl+X to toggle cutting mode off
+        if event.modifiers() & Qt.ControlModifier and event.key() == Qt.Key_X:
             self.parent_tool.deactivate_subtool()
+            return
+            
+        # Handle Backspace to clear the current cutting line but stay in cutting mode
+        if event.key() == Qt.Key_Backspace:
+            self._clear_cutting_line()
+            return
 
     def _start_drawing_cut_line(self, position):
         """Start drawing the cut line from the given position."""
@@ -115,6 +122,15 @@ class CutSubTool(SubTool):
                 path.lineTo(point)
             self.cutting_path_item.setPath(path)
             
+    def _clear_cutting_line(self):
+        """Clear the current cutting line but remain in cutting mode."""
+        self.cutting_points = []
+        self.drawing_in_progress = False
+        if self.cutting_path_item:
+            self.annotation_window.scene.removeItem(self.cutting_path_item)
+            self.cutting_path_item = None
+            self.annotation_window.scene.update()
+            
     def _break_apart_multipolygon(self):
         """Handle the special case of 'cutting' a MultiPolygonAnnotation."""
         new_annotations = self.target_annotation.cut()

coralnet_toolbox/Tools/QtResizeSubTool.py

@@ -124,5 +124,22 @@ class ResizeSubTool(SubTool):
         }
 
     def _get_polygon_handles(self, annotation):
-        """Return resize handles for a polygon annotation."""
-        return {f"point_{i}": QPointF(p.x(), p.y()) for i, p in enumerate(annotation.points)}
+        """
+        Return resize handles for a polygon, including its outer boundary and all holes.
+        Uses the new handle format: 'point_{poly_index}_{vertex_index}'.
+        """
+        handles = {}
+
+        # 1. Create handles for the outer boundary using the 'outer' keyword.
+        for i, p in enumerate(annotation.points):
+            handle_name = f"point_outer_{i}"
+            handles[handle_name] = QPointF(p.x(), p.y())
+
+        # 2. Create handles for each of the inner holes using their index.
+        if hasattr(annotation, 'holes'):
+            for hole_index, hole in enumerate(annotation.holes):
+                for vertex_index, p in enumerate(hole):
+                    handle_name = f"point_{hole_index}_{vertex_index}"
+                    handles[handle_name] = QPointF(p.x(), p.y())
+        
+        return handles

coralnet_toolbox/Tools/QtSAMTool.py

@@ -1,7 +1,7 @@
 import warnings
 import numpy as np
 
-from PyQt5.QtCore import Qt, QPointF, QRectF, QTimer
+from PyQt5.QtCore import Qt, QPointF, QRectF
 from PyQt5.QtGui import QMouseEvent, QKeyEvent, QPen, QColor, QBrush, QPainterPath
 from PyQt5.QtWidgets import QMessageBox, QGraphicsEllipseItem, QGraphicsRectItem, QGraphicsPathItem, QApplication
 
@@ -12,6 +12,7 @@ from coralnet_toolbox.QtWorkArea import WorkArea
 
 from coralnet_toolbox.utilities import pixmap_to_numpy
 from coralnet_toolbox.utilities import simplify_polygon
+from coralnet_toolbox.utilities import polygonize_mask_with_holes
 
 warnings.filterwarnings("ignore", category=DeprecationWarning)
 
@@ -64,6 +65,11 @@ class SAMTool(Tool):
 
         # Flag to track if we have active prompts
         self.has_active_prompts = False
+        
+        # Add state variables for custom working area creation
+        self.creating_working_area = False
+        self.working_area_start = None
+        self.working_area_temp_graphics = None
 
     def activate(self):
         """
@@ -82,6 +88,7 @@ class SAMTool(Tool):
         self.sam_dialog = None
         self.cancel_working_area()
         self.has_active_prompts = False
+        self.cancel_working_area_creation()
 
     def set_working_area(self):
         """
@@ -141,7 +148,116 @@ class SAMTool(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)
+        
+        # Update the working area image in the SAM model
+        self.image = self.original_image[top:bottom, left:right]
+        self.sam_dialog.set_image(self.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):
         """
         Handle when the work area is removed via its internal mechanism.
@@ -254,40 +370,47 @@ class SAMTool(Tool):
                 QApplication.restoreOverrideCursor()
                 return
 
-            # Get the points of the top1 mask
+            # Get the top confidence prediction's mask tensor
             top1_index = np.argmax(results.boxes.conf)
-            predictions = results[top1_index].masks.xy[0]
+            mask_tensor = results[top1_index].masks.data
 
-            # Safety check: make sure we have predicted points
-            if len(predictions) == 0:
-                QApplication.restoreOverrideCursor()
-                return
+            # Check if holes are allowed from the SAM dialog
+            allow_holes = self.sam_dialog.get_allow_holes()
 
-            # Clean the polygon using Ramer-Douglas-Peucker algorithm
-            predictions = simplify_polygon(predictions, 0.1)
+            # 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(predictions) < 3:
+            if len(exterior_coords) < 3:
                 QApplication.restoreOverrideCursor()
                 return
 
-            # Move the points back to the original image space
+            # --- Process and Clean the Polygon Points ---
             working_area_top_left = self.working_area.rect.topLeft()
-            points = [(point[0] + working_area_top_left.x(),
-                       point[1] + working_area_top_left.y()) for point in predictions]
+            offset_x, offset_y = working_area_top_left.x(), working_area_top_left.y()
 
-            # Convert to QPointF for graphics
-            self.points = [QPointF(*point) for point in points]
+            # 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]
 
-            # Create the temporary annotation
+            # 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(
-                self.points,
-                self.annotation_window.selected_label.short_label_code,
-                self.annotation_window.selected_label.long_label_code,
-                self.annotation_window.selected_label.color,
-                self.annotation_window.current_image_path,
-                self.annotation_window.selected_label.id,
-                self.main_window.label_window.active_label.transparency
+                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
@@ -357,11 +480,24 @@ class SAMTool(Tool):
                                 "A label must be selected before adding an annotation.")
             return
 
-        if not self.working_area:
-            return
-
         # 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
 
         # Check if position is within working area
         if not self.working_area.contains_point(scene_pos):
@@ -430,12 +566,17 @@ class SAMTool(Tool):
         """
         Handle mouse move events.
         """
-        if not self.working_area:
-            return
-
         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 not self.working_area:
+            return
+
         # Update rectangle during drawing
         if self.drawing_rectangle and self.start_point:
             self.end_point = scene_pos
@@ -461,6 +602,11 @@ class SAMTool(Tool):
         Handle key press events.
         """
         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 no working area, set it up
             if not self.working_area:
@@ -473,12 +619,13 @@ class SAMTool(Tool):
                     # Use existing temporary annotation
                     final_annotation = PolygonAnnotation(
                         self.points,
-                        self.annotation_window.selected_label.short_label_code,
-                        self.annotation_window.selected_label.long_label_code,
-                        self.annotation_window.selected_label.color,
-                        self.annotation_window.current_image_path,
-                        self.annotation_window.selected_label.id,
-                        self.main_window.label_window.active_label.transparency
+                        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
                     )
 
                     # Copy confidence data
@@ -499,7 +646,7 @@ class SAMTool(Tool):
                     final_annotation = self.create_annotation(True)
                     if final_annotation:
                         self.annotation_window.add_annotation_from_tool(final_annotation)
-                        self.clear_prompt_graphics()
+                        self.clear_prompt_graphics() 
             # If no active prompts, cancel the working area
             else:
                 self.cancel_working_area()
@@ -507,6 +654,11 @@ class SAMTool(Tool):
             self.annotation_window.scene.update()
 
         elif event.key() == Qt.Key_Backspace:
+            # If creating working area, cancel it
+            if self.creating_working_area:
+                self.cancel_working_area_creation()
+                return
+                
             # If drawing rectangle, cancel it
             if self.drawing_rectangle:
                 self.cancel_rectangle_drawing()
@@ -584,24 +736,36 @@ class SAMTool(Tool):
             QApplication.restoreOverrideCursor()
             return None
 
-        # Get the top confidence prediction
+        # Get the top confidence prediction's mask tensor
         top1_index = np.argmax(results.boxes.conf)
-        predictions = results[top1_index].masks.xy[0]
+        mask_tensor = results[top1_index].masks.data
+
+        # Check if holes are allowed from the SAM dialog
+        allow_holes = self.sam_dialog.get_allow_holes()
 
-        # Safety check for predictions
-        if len(predictions) == 0:
+        # 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
 
-        # Clean polygon points
-        predictions = simplify_polygon(predictions, 0.1)
-
-        # Move points back to original image space
+        # --- Process and Clean the Polygon Points ---
         working_area_top_left = self.working_area.rect.topLeft()
-        points = [(point[0] + working_area_top_left.x(),
-                   point[1] + working_area_top_left.y()) for point in predictions]
-        # Convert to QPointF for graphics
-        self.points = [QPointF(*point) for point in points]
+        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:
@@ -611,15 +775,16 @@ class SAMTool(Tool):
         # Get confidence score
         confidence = results.boxes.conf[top1_index].item()
 
-        # Create final annotation
+        # Create final annotation, now passing the holes argument
         annotation = PolygonAnnotation(
-            self.points,
-            self.annotation_window.selected_label.short_label_code,
-            self.annotation_window.selected_label.long_label_code,
-            self.annotation_window.selected_label.color,
-            self.annotation_window.current_image_path,
-            self.annotation_window.selected_label.id,
-            self.main_window.label_window.active_label.transparency
+            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