coralnet-toolbox 0.0.75__py2.py3-none-any.whl → 0.0.77__py2.py3-none-any.whl

coralnet_toolbox/SeeAnything/QtDeployPredictor.py

@@ -1,6 +1,5 @@
 import warnings
 
-import os
 import gc
 
 import numpy as np
@@ -14,7 +13,6 @@ from ultralytics.models.yolo.yoloe import YOLOEVPSegPredictor
 from ultralytics.models.yolo.yoloe import YOLOEVPDetectPredictor
 
 from PyQt5.QtCore import Qt
-from PyQt5.QtGui import QColor
 from PyQt5.QtWidgets import (QApplication, QComboBox, QDialog, QFormLayout,
                              QHBoxLayout, QLabel, QMessageBox, QPushButton,
                              QSlider, QSpinBox, QVBoxLayout, QGroupBox,
@@ -408,7 +406,7 @@ class DeployPredictorDialog(QDialog):
             self.loaded_model.predict(
                 np.zeros((640, 640, 3), dtype=np.uint8),
                 visual_prompts=visuals.copy(),  # This needs to happen to properly initialize the predictor
-                predictor=YOLOEVPSegPredictor,  # This also needs to be SegPredictor, no matter what
+                predictor=YOLOEVPDetectPredictor if self.task == 'detect' else YOLOEVPSegPredictor,
                 imgsz=640,
                 conf=0.99,
             )
@@ -545,12 +543,15 @@ class DeployPredictorDialog(QDialog):
 
         # Get the scaled visual prompts
         visual_prompts = self.scale_prompts(bboxes, masks)
+        
+        # Set the predictor
+        predictor=YOLOEVPDetectPredictor if self.task == 'detect' else YOLOEVPSegPredictor
 
         try:
             # Make predictions
             results = self.loaded_model.predict(self.resized_image,
-                                                visual_prompts=visual_prompts.copy(),  
-                                                predictor=YOLOEVPSegPredictor,
+                                                visual_prompts=visual_prompts.copy(),
+                                                predictor=predictor,
                                                 imgsz=max(self.resized_image.shape[:2]),
                                                 conf=self.main_window.get_uncertainty_thresh(),
                                                 iou=self.main_window.get_iou_thresh(),
@@ -615,6 +616,9 @@ class DeployPredictorDialog(QDialog):
         progress_bar = ProgressBar(self.annotation_window, title="Making Predictions")
         progress_bar.show()
         progress_bar.start_progress(len(target_images))
+        
+        # Set the predictor
+        predictor = YOLOEVPDetectPredictor if self.task == 'detect' else YOLOEVPSegPredictor
 
         for target_image in target_images:
 
@@ -623,7 +627,7 @@ class DeployPredictorDialog(QDialog):
                 results = self.loaded_model.predict(target_image,
                                                     refer_image=refer_image,
                                                     visual_prompts=visual_prompts.copy(),
-                                                    predictor=YOLOEVPSegPredictor,
+                                                    predictor=predictor,
                                                     imgsz=self.imgsz_spinbox.value(),
                                                     conf=self.main_window.get_uncertainty_thresh(),
                                                     iou=self.main_window.get_iou_thresh(),

coralnet_toolbox/Tile/QtTileBatchInference.py

@@ -37,8 +37,8 @@ class TileBatchInference(QDialog):
         self.detect_dialog = main_window.detect_deploy_model_dialog
         self.segment_dialog = main_window.segment_deploy_model_dialog
         self.sam_dialog = main_window.sam_deploy_generator_dialog
-        self.autodistill_dialog = main_window.auto_distill_deploy_model_dialog
-        
+        self.transformers_dialog = main_window.transformers_deploy_model_dialog
+
         # Create a dictionary of the different model dialogs and their loaded models
         self.model_dialogs = {}
 
@@ -167,8 +167,8 @@ class TileBatchInference(QDialog):
             self.model_dialogs["Segment"] = self.segment_dialog
         if self.sam_dialog and getattr(self.sam_dialog, "loaded_model", None):
             self.model_dialogs["SAM Generator"] = self.sam_dialog
-        if self.autodistill_dialog and getattr(self.autodistill_dialog, "loaded_model", None):
-            self.model_dialogs["Autodistill"] = self.autodistill_dialog
+        if self.transformers_dialog and getattr(self.transformers_dialog, "loaded_model", None):
+            self.model_dialogs["Transformers"] = self.transformers_dialog
             
         # Update the model combo box with the available models
         self.update_model_combo()

coralnet_toolbox/Tools/QtPatchTool.py

@@ -56,9 +56,13 @@ class PatchTool(Tool):
             self.update_cursor_annotation(scene_pos)
 
     def mouseMoveEvent(self, event: QMouseEvent):
-        # First clear any existing cursor annotation
+        # Call parent implementation to handle crosshair
+        super().mouseMoveEvent(event)
+        
+        # Then clear any existing cursor annotation
         self.clear_cursor_annotation()
-            
+        
+        # Continue with tool-specific behavior for cursor annotation
         if self.annotation_window.active_image and self.annotation_window.selected_label:
             scene_pos = self.annotation_window.mapToScene(event.pos())
             if self.annotation_window.cursorInWindow(event.pos()):

coralnet_toolbox/Tools/QtPolygonTool.py

@@ -78,15 +78,17 @@ class PolygonTool(Tool):
         else:
             self.cancel_annotation()
 
-    def mouseMoveEvent(self, event: QMouseEvent):
+    def mouseMoveEvent(self, event: QMouseEvent):       
+        # Tool-specific behavior (non-crosshair related) for mouse move events
         if self.drawing_continuous:
-            scene_pos = self.annotation_window.mapToScene(event.pos())
             active_image = self.annotation_window.active_image
             pixmap_image = self.annotation_window.pixmap_image
             cursor_in_window = self.annotation_window.cursorInWindow(event.pos())
+            scene_pos = self.annotation_window.mapToScene(event.pos())
+            
             if active_image and pixmap_image and cursor_in_window and self.points:
                 if self.ctrl_pressed and self.last_click_point:
-                    # Show a straight line preview from last point to cursor, do not modify self.points
+                    # Show a straight line preview
                     self.update_cursor_annotation(scene_pos)
                 else:
                     # Free-hand: add points as the mouse moves

coralnet_toolbox/Tools/QtRectangleTool.py

@@ -2,7 +2,7 @@ import warnings
 
 from PyQt5.QtCore import Qt, QPointF
 from PyQt5.QtGui import QMouseEvent, QKeyEvent
-from PyQt5.QtWidgets import QMessageBox
+from PyQt5.QtWidgets import QMessageBox, QGraphicsPixmapItem
 
 from coralnet_toolbox.Tools.QtTool import Tool
 from coralnet_toolbox.Annotations.QtRectangleAnnotation import RectangleAnnotation
@@ -29,9 +29,7 @@ class RectangleTool(Tool):
         self.annotation_window.setCursor(self.cursor)
 
     def deactivate(self):
-        self.active = False
-        self.annotation_window.setCursor(self.default_cursor)
-        self.clear_cursor_annotation()
+        super().deactivate()
         self.start_point = None
         self.end_point = None
         self.drawing_continuous = False
@@ -72,8 +70,11 @@ class RectangleTool(Tool):
             self.cancel_annotation()
 
     def mouseMoveEvent(self, event: QMouseEvent):
+        # Call parent implementation to handle crosshair
+        super().mouseMoveEvent(event)
+        
+        # Continue with tool-specific behavior
         if self.drawing_continuous:
-            # Update the end point while drawing the rectangle
             self.end_point = self.annotation_window.mapToScene(event.pos())
             
             # Update the cursor annotation if we're in the window
@@ -82,12 +83,19 @@ class RectangleTool(Tool):
             cursor_in_window = self.annotation_window.cursorInWindow(event.pos())
             if active_image and pixmap_image and cursor_in_window and self.start_point:
                 self.update_cursor_annotation(self.end_point)
+                
+                # Show crosshair at current cursor position during drawing
+                self.update_crosshair(self.end_point)
         else:
             # Show a preview rectangle at the cursor position when not drawing
             scene_pos = self.annotation_window.mapToScene(event.pos())
-            if self.annotation_window.cursorInWindow(event.pos()) and self.annotation_window.selected_label:
-                self.clear_cursor_annotation()
-                # No cursor annotation in non-drawing mode
+            cursor_in_window = self.annotation_window.cursorInWindow(event.pos())
+            
+            # Show crosshair guides when cursor is over the image
+            if cursor_in_window and self.active and self.annotation_window.selected_label:
+                self.update_crosshair(scene_pos)
+            else:
+                self.clear_crosshair()
 
     def keyPressEvent(self, event: QKeyEvent):
         if event.key() == Qt.Key_Backspace:
@@ -183,4 +191,4 @@ class RectangleTool(Tool):
     def update_cursor_annotation(self, scene_pos: QPointF = None):
         """Update the rectangle cursor annotation."""
         self.clear_cursor_annotation()
-        self.create_cursor_annotation(scene_pos)
+        self.create_cursor_annotation(scene_pos)

coralnet_toolbox/Tools/QtSAMTool.py

@@ -6,6 +6,8 @@ from PyQt5.QtGui import QMouseEvent, QKeyEvent, QPen, QColor, QBrush, QPainterPa
 from PyQt5.QtWidgets import QMessageBox, QGraphicsEllipseItem, QGraphicsRectItem, QGraphicsPathItem, QApplication
 
 from coralnet_toolbox.Tools.QtTool import Tool
+
+from coralnet_toolbox.Annotations.QtRectangleAnnotation import RectangleAnnotation
 from coralnet_toolbox.Annotations.QtPolygonAnnotation import PolygonAnnotation
 
 from coralnet_toolbox.QtWorkArea import WorkArea
@@ -374,45 +376,21 @@ class SAMTool(Tool):
             top1_index = np.argmax(results.boxes.conf)
             mask_tensor = results[top1_index].masks.data
 
-            # Check if holes are allowed from the SAM dialog
+            # Check which output type is selected and get allow_holes settings
+            output_type = self.sam_dialog.get_output_type()
             allow_holes = self.sam_dialog.get_allow_holes()
-
-            # 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(exterior_coords) < 3:
+            
+            # Create annotation using the helper method
+            self.temp_annotation = self.create_annotation_from_mask(
+                mask_tensor,
+                output_type,
+                allow_holes
+            )
+            
+            if not self.temp_annotation:
                 QApplication.restoreOverrideCursor()
                 return
-
-            # --- Process and Clean the Polygon Points ---
-            working_area_top_left = self.working_area.rect.topLeft()
-            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:  # 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(
-                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
             self.temp_annotation.create_graphics_item(self.annotation_window.scene)
             
@@ -566,6 +544,10 @@ class SAMTool(Tool):
         """
         Handle mouse move events.
         """
+        # Call parent implementation to handle crosshair
+        super().mouseMoveEvent(event)
+        
+        # Continue with tool-specific behavior
         scene_pos = self.annotation_window.mapToScene(event.pos())
         self.hover_pos = scene_pos
 
@@ -616,17 +598,31 @@ class SAMTool(Tool):
             elif self.has_active_prompts:
                 # Create the final annotation
                 if self.temp_annotation:
-                    # Use existing temporary annotation
-                    final_annotation = PolygonAnnotation(
-                        self.points,
-                        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
-                    )
+                    # Check if temp_annotation is a PolygonAnnotation or RectangleAnnotation
+                    if isinstance(self.temp_annotation, PolygonAnnotation):
+                        # For polygon annotations, use the points and holes
+                        final_annotation = PolygonAnnotation(
+                            self.points,
+                            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
+                        )
+                    elif isinstance(self.temp_annotation, RectangleAnnotation):
+                        # For rectangle annotations, use the top_left and bottom_right
+                        final_annotation = RectangleAnnotation(
+                            top_left=self.temp_annotation.top_left,
+                            bottom_right=self.temp_annotation.bottom_right,
+                            short_label_code=self.temp_annotation.label.short_label_code,
+                            long_label_code=self.temp_annotation.label.long_label_code,
+                            color=self.temp_annotation.label.color,
+                            image_path=self.temp_annotation.image_path,
+                            label_id=self.temp_annotation.label.id,
+                            transparency=self.temp_annotation.label.transparency
+                        )
 
                     # Copy confidence data
                     final_annotation.update_machine_confidence(
@@ -740,54 +736,23 @@ class SAMTool(Tool):
         top1_index = np.argmax(results.boxes.conf)
         mask_tensor = results[top1_index].masks.data
 
-        # Check if holes are allowed from the SAM dialog
+        # Check which output type is selected and get allow_holes settings
+        output_type = self.sam_dialog.get_output_type()
         allow_holes = self.sam_dialog.get_allow_holes()
-
-        # 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
-
-        # --- Process and Clean the Polygon Points ---
-        working_area_top_left = self.working_area.rect.topLeft()
-        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:
+        
+        # Create annotation using the helper method
+        annotation = self.create_annotation_from_mask(
+            mask_tensor,
+            output_type,
+            allow_holes
+        )
+        
+        if not annotation:
             QApplication.restoreOverrideCursor()
             return None
 
-        # Get confidence score
-        confidence = results.boxes.conf[top1_index].item()
-
-        # Create final annotation, now passing the holes argument
-        annotation = PolygonAnnotation(
-            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
+        # Update confidence - make sure to extract confidence from results
+        confidence = float(results.boxes.conf[top1_index])
         annotation.update_machine_confidence({self.annotation_window.selected_label: confidence})
 
         # Create cropped image
@@ -799,6 +764,94 @@ class SAMTool(Tool):
 
         return annotation
 
+    def create_annotation_from_mask(self, mask_tensor, output_type, allow_holes=True):
+        """
+        Create annotation (Rectangle or Polygon) from a mask tensor.
+        
+        Args:
+            mask_tensor: The tensor containing the mask data
+            output_type (str): "Rectangle" or "Polygon"
+            allow_holes (bool): Whether to include holes in polygon annotations
+        
+        Returns:
+            Annotation object or None if creation fails
+        """
+        if not self.working_area:
+            return None
+            
+        if output_type == "Rectangle":
+            # For rectangle output, just get the bounding box of the mask
+            # Find the bounding rectangle of the mask
+            y_indices, x_indices = np.where(mask_tensor.cpu().numpy()[0] > 0)
+            if len(y_indices) == 0 or len(x_indices) == 0:
+                return None
+                
+            # Get the min/max coordinates
+            min_x, max_x = np.min(x_indices), np.max(x_indices)
+            min_y, max_y = np.min(y_indices), np.max(y_indices)
+            
+            # Apply the offset from working area
+            working_area_top_left = self.working_area.rect.topLeft()
+            offset_x, offset_y = working_area_top_left.x(), working_area_top_left.y()
+            
+            top_left = QPointF(min_x + offset_x, min_y + offset_y)
+            bottom_right = QPointF(max_x + offset_x, max_y + offset_y)
+            
+            # Create a rectangle annotation
+            annotation = RectangleAnnotation(
+                top_left=top_left,
+                bottom_right=bottom_right,
+                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
+            )
+        else:
+            # Original polygon code
+            # 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:
+                return None
+                
+            # --- Process and Clean the Polygon Points ---
+            working_area_top_left = self.working_area.rect.topLeft()
+            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:
+                    simplified_hole = simplify_polygon(hole_coords, 0.1)
+                    if len(simplified_hole) >= 3:
+                        hole_points = [QPointF(p[0] + offset_x, p[1] + offset_y) for p in simplified_hole]
+                        final_holes.append(hole_points)
+            
+            # Require at least 3 points for valid polygon
+            if len(self.points) < 3:
+                return None
+                
+            # Create final annotation, now passing the holes argument
+            annotation = PolygonAnnotation(
+                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
+            )
+            
+        return annotation
+
     def cancel_working_area(self):
         """
         Cancel the working area and clean up all associated resources.

coralnet_toolbox/Tools/QtSeeAnythingTool.py

@@ -455,6 +455,10 @@ class SeeAnythingTool(Tool):
         Args:
             event (QMouseEvent): The mouse move event.
         """
+        # Call parent implementation to handle crosshair
+        super().mouseMoveEvent(event)
+        
+        # Continue with tool-specific behavior
         scene_pos = self.annotation_window.mapToScene(event.pos())
         self.hover_pos = scene_pos
         

coralnet_toolbox/Tools/QtTool.py

@@ -1,7 +1,8 @@
 import warnings
 
 from PyQt5.QtCore import Qt, QPointF
-from PyQt5.QtGui import QMouseEvent
+from PyQt5.QtGui import QMouseEvent, QColor
+from PyQt5.QtWidgets import QGraphicsPixmapItem
 
 warnings.filterwarnings("ignore", category=DeprecationWarning)
 
@@ -21,6 +22,11 @@ class Tool:
         self.cursor = Qt.ArrowCursor
         self.default_cursor = Qt.ArrowCursor
         self.cursor_annotation = None
+        
+        # Crosshair settings
+        self.show_crosshair = True  # Flag to toggle crosshair visibility for this tool
+        self.h_crosshair_line = None
+        self.v_crosshair_line = None
 
     def activate(self):
         self.active = True
@@ -30,12 +36,26 @@ class Tool:
         self.active = False
         self.annotation_window.setCursor(self.default_cursor)
         self.clear_cursor_annotation()
+        self.clear_crosshair()  # Clear any crosshair when tool is deactivated
 
     def mousePressEvent(self, event: QMouseEvent):
         pass
 
     def mouseMoveEvent(self, event: QMouseEvent):
-        pass
+        """
+        Base implementation of mouseMoveEvent that handles crosshair display.
+        Child classes should call super().mouseMoveEvent(event) in their implementation.
+        """
+        # Handle crosshair display
+        scene_pos = self.annotation_window.mapToScene(event.pos())
+        cursor_in_window = self.annotation_window.cursorInWindow(event.pos())
+        
+        if (cursor_in_window and self.active and 
+            self.annotation_window.selected_label and 
+            self.show_crosshair):
+            self.update_crosshair(scene_pos)
+        else:
+            self.clear_crosshair()
 
     def mouseReleaseEvent(self, event: QMouseEvent):
         pass
@@ -77,4 +97,60 @@ class Tool:
         """
         if self.cursor_annotation:
             self.cursor_annotation.delete()
-            self.cursor_annotation = None
+            self.cursor_annotation = None
+            
+    def draw_crosshair(self, scene_pos):
+        """
+        Draw crosshair guides at the current cursor position.
+        
+        Args:
+            scene_pos: Position in scene coordinates where to draw the crosshair
+        """
+        # Only draw if we have an active image and scene position
+        if (
+            not self.show_crosshair
+            or not self.annotation_window.active_image
+            or not scene_pos
+            or not self.annotation_window.pixmap_image
+        ):
+            return
+
+        # Remove any existing crosshair lines
+        self.clear_crosshair()
+        
+        # Get image bounds
+        image_rect = QGraphicsPixmapItem(self.annotation_window.pixmap_image).boundingRect()
+        
+        # Create horizontal line across the full width of the image
+        self.h_crosshair_line = self.graphics_utility.create_guide_line(
+            QPointF(image_rect.left(), scene_pos.y()),
+            QPointF(image_rect.right(), scene_pos.y())
+        )
+        self.annotation_window.scene.addItem(self.h_crosshair_line)
+        
+        # Create vertical line across the full height of the image
+        self.v_crosshair_line = self.graphics_utility.create_guide_line(
+            QPointF(scene_pos.x(), image_rect.top()),
+            QPointF(scene_pos.x(), image_rect.bottom())
+        )
+        self.annotation_window.scene.addItem(self.v_crosshair_line)
+        
+    def clear_crosshair(self):
+        """Remove any crosshair guide lines from the scene."""
+        if self.h_crosshair_line and self.h_crosshair_line.scene():
+            self.annotation_window.scene.removeItem(self.h_crosshair_line)
+            self.h_crosshair_line = None
+        if self.v_crosshair_line and self.v_crosshair_line.scene():
+            self.annotation_window.scene.removeItem(self.v_crosshair_line)
+            self.v_crosshair_line = None
+
+    def update_crosshair(self, scene_pos):
+        """
+        Update the crosshair position. This is a convenience method that
+        clears and redraws the crosshair.
+        
+        Args:
+            scene_pos: New position for the crosshair
+        """
+        self.clear_crosshair()
+        self.draw_crosshair(scene_pos)

coralnet_toolbox/Tools/QtWorkAreaTool.py

@@ -103,6 +103,10 @@ class WorkAreaTool(Tool):
                 
     def mouseMoveEvent(self, event: QMouseEvent):
         """Handle mouse move events to update the work area while drawing."""
+        # Call parent implementation to handle crosshair
+        super().mouseMoveEvent(event)
+        
+        # Continue with tool-specific behavior
         scene_pos = self.annotation_window.mapToScene(event.pos())
         self.hover_pos = scene_pos  # Track hover position for spacebar confirmation