coralnet-toolbox 0.0.72__py2.py3-none-any.whl → 0.0.74__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
@@ -162,9 +173,121 @@ class SeeAnythingTool(Tool):
 
         # Set the image in the SeeAnything dialog
         self.see_anything_dialog.set_image(self.work_area_image, self.image_path)
+        # self.see_anything_dialog.reload_model()
 
         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 +400,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 +455,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 +478,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 +509,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 +553,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]
+        masks = None
+        # Create masks from the rectangles (these are not polygons)
+        if self.see_anything_dialog.task_dropdown.currentText() == '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 +588,60 @@ 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 (creates polygons or rectangle annotations)
+        if self.see_anything_dialog.task_dropdown.currentText() == "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]])
+                    # Calculate the area of the bounding box
+                    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 +919,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

@@ -11,6 +11,7 @@ from coralnet_toolbox.Tools.QtMoveSubTool import MoveSubTool
 from coralnet_toolbox.Tools.QtResizeSubTool import ResizeSubTool
 from coralnet_toolbox.Tools.QtSelectSubTool import SelectSubTool
 from coralnet_toolbox.Tools.QtCutSubTool import CutSubTool
+from coralnet_toolbox.Tools.QtSubtractSubTool import SubtractSubTool
 
 from coralnet_toolbox.Annotations import (PatchAnnotation, 
                                           PolygonAnnotation, 
@@ -45,6 +46,9 @@ class SelectTool(Tool):
         self.resize_subtool = ResizeSubTool(self)
         self.select_subtool = SelectSubTool(self)
         self.cut_subtool = CutSubTool(self)
+        self.subtract_subtool = SubtractSubTool(self)
+        
+        # --- State for the currently active sub-tool ---
         self.active_subtool: SubTool | None = None
 
         # --- State for transient UI (like resize handles) ---
@@ -175,9 +179,14 @@ class SelectTool(Tool):
             if modifiers & Qt.ShiftModifier and len(self.selected_annotations) == 1:
                 self._show_resize_handles()
             
-            # Ctrl+X: Start cutting mode
-            if event.key() == Qt.Key_X and len(self.selected_annotations) == 1:
-                self.set_active_subtool(self.cut_subtool, event, annotation=self.selected_annotations[0])
+            # --- Ctrl+X Hotkey Overload ---
+            if event.key() == Qt.Key_X:
+                if len(self.selected_annotations) > 1:
+                    # If more than one annotation is selected, perform subtraction.
+                    self.subtract_selected_annotations(event)
+                elif len(self.selected_annotations) == 1:
+                    # If only one is selected, start cutting mode.
+                    self.set_active_subtool(self.cut_subtool, event, annotation=self.selected_annotations[0])
 
             # Ctrl+C: Combine selected annotations
             elif event.key() == Qt.Key_C and len(self.selected_annotations) > 1:
@@ -315,6 +324,16 @@ class SelectTool(Tool):
                 annotation.update_user_confidence(top_label)
         if len(self.selected_annotations) == 1:
             self.annotation_window.main_window.confidence_window.refresh_display()
+            
+    def subtract_selected_annotations(self, event):
+        """
+        Initiates the subtraction operation by activating the SubtractSubTool.
+        """
+        self.set_active_subtool(
+            self.subtract_subtool, 
+            event, 
+            selected_annotations=self.selected_annotations.copy()
+        )
 
     def combine_selected_annotations(self):
         """Combine multiple selected annotations of the same type."""
@@ -437,6 +456,11 @@ class SelectTool(Tool):
         # Add the newly created annotations from the cut.
         for new_anno in new_annotations:
             self.annotation_window.add_annotation_from_tool(new_anno)
+            
+    def cancel_cutting_mode(self):
+        """Safely cancels cutting mode."""
+        if self.active_subtool and isinstance(self.active_subtool, CutSubTool):
+            self.deactivate_subtool()
 
     # --- Convenience Properties ---
     @property

coralnet_toolbox/Tools/QtSubtractSubTool.py

@@ -0,0 +1,66 @@
+from coralnet_toolbox.Tools.QtSubTool import SubTool
+from coralnet_toolbox.Annotations import PolygonAnnotation
+from coralnet_toolbox.Annotations import MultiPolygonAnnotation
+
+
+# ----------------------------------------------------------------------------------------------------------------------
+# Classes
+# ----------------------------------------------------------------------------------------------------------------------    
+
+class SubtractSubTool(SubTool):
+    """
+    A SubTool to perform a "cookie cutter" subtraction operation on selected annotations.
+    This tool activates, performs its action, and immediately deactivates.
+    """
+
+    def __init__(self, parent_tool):
+        super().__init__(parent_tool)
+
+    def activate(self, event, **kwargs):
+        """
+        Activates the subtraction operation.
+        Expects 'selected_annotations' in kwargs.
+        """
+        super().activate(event)
+        
+        selected_annotations = kwargs.get('selected_annotations', [])
+
+        # --- 1. Perform Pre-activation Checks ---
+        if len(selected_annotations) < 2:
+            self.parent_tool.deactivate_subtool()
+            return
+
+        # Check if all annotations are verified Polygon or MultiPolygon Annotations
+        allowed_types = (PolygonAnnotation, MultiPolygonAnnotation)
+        if not all(isinstance(anno, allowed_types) and anno.verified for anno in selected_annotations):
+            self.parent_tool.deactivate_subtool()
+            return
+
+        # --- 2. Identify Base and Cutters ---
+        # The last selected annotation is the base, the rest are cutters.
+        base_annotation = selected_annotations[-1]
+        cutter_annotations = selected_annotations[:-1]
+
+        # --- 3. Perform the Subtraction ---
+        result_annotations = PolygonAnnotation.subtract(base_annotation, cutter_annotations)
+
+        if not result_annotations:
+            self.parent_tool.deactivate_subtool()
+            return
+
+        # --- 4. Update the Annotation Window ---
+        # Delete the original annotations that were used in the operation
+        for anno in selected_annotations:
+            self.annotation_window.delete_annotation(anno.id)
+        
+        # Add the new resulting annotations to the scene
+        for new_anno in result_annotations:
+            self.annotation_window.add_annotation_from_tool(new_anno)
+        
+        # Select the new annotations
+        self.annotation_window.unselect_annotations()
+        for new_anno in result_annotations:
+            self.annotation_window.select_annotation(new_anno, multi_select=True)
+
+        # --- 5. Deactivate Immediately ---
+        self.parent_tool.deactivate_subtool()

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/Tools/__init__.py

@@ -14,6 +14,7 @@ from .QtCutSubTool import CutSubTool
 from .QtMoveSubTool import MoveSubTool
 from .QtResizeSubTool import ResizeSubTool
 from .QtSelectSubTool import SelectSubTool
+from .QtSubtractSubTool import SubtractSubTool
 
 __all__ = [
     'PanTool',
@@ -29,4 +30,5 @@ __all__ = [
     'MoveSubTool',
     'ResizeSubTool',
     'SelectSubTool',
+    'SubtractSubTool',
 ]

coralnet_toolbox/__init__.py

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