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

coralnet_toolbox/SeeAnything/QtDeployPredictor.py

@@ -6,6 +6,13 @@ import ujson as json
 
 import numpy as np
 
+from torch.cuda import empty_cache
+from ultralytics.utils import ops
+
+from ultralytics import YOLOE
+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,
@@ -13,13 +20,6 @@ from PyQt5.QtWidgets import (QApplication, QComboBox, QDialog, QFormLayout,
                              QSlider, QSpinBox, QVBoxLayout, QGroupBox, QTabWidget,
                              QWidget, QLineEdit, QFileDialog)
 
-from ultralytics import YOLOE
-from ultralytics.models.yolo.yoloe import YOLOEVPSegPredictor
-from ultralytics.models.yolo.yoloe import YOLOEVPDetectPredictor
-
-from torch.cuda import empty_cache
-from ultralytics.utils import ops
-
 from coralnet_toolbox.Results import ResultsProcessor
 
 from coralnet_toolbox.QtProgressBar import ProgressBar
@@ -179,37 +179,6 @@ class DeployPredictorDialog(QDialog):
         group_box.setLayout(layout)
         self.layout.addWidget(group_box)
 
-    def browse_model_file(self):
-        """
-        Open a file dialog to browse for a model file.
-        """
-        file_path, _ = QFileDialog.getOpenFileName(self,
-                                                   "Select Model File",
-                                                   "",
-                                                   "Model Files (*.pt *.pth);;All Files (*)")
-        if file_path:
-            self.model_path_edit.setText(file_path)
-
-            # Load the class mapping if it exists
-            dir_path = os.path.dirname(os.path.dirname(file_path))
-            class_mapping_path = f"{dir_path}/class_mapping.json"
-            if os.path.exists(class_mapping_path):
-                self.class_mapping = json.load(open(class_mapping_path, 'r'))
-                self.mapping_edit.setText(class_mapping_path)
-
-    def browse_class_mapping_file(self):
-        """
-        Browse and select a class mapping file.
-        """
-        file_path, _ = QFileDialog.getOpenFileName(self,
-                                                   "Select Class Mapping File",
-                                                   "",
-                                                   "JSON Files (*.json)")
-        if file_path:
-            # Load the class mapping
-            self.class_mapping = json.load(open(file_path, 'r'))
-            self.mapping_edit.setText(file_path)
-
     def setup_parameters_layout(self):
         """
         Setup parameter control section in a group box.
@@ -335,6 +304,37 @@ class DeployPredictorDialog(QDialog):
 
         group_box.setLayout(layout)
         self.layout.addWidget(group_box)
+        
+    def browse_model_file(self):
+        """
+        Open a file dialog to browse for a model file.
+        """
+        file_path, _ = QFileDialog.getOpenFileName(self,
+                                                   "Select Model File",
+                                                   "",
+                                                   "Model Files (*.pt *.pth);;All Files (*)")
+        if file_path:
+            self.model_path_edit.setText(file_path)
+
+            # Load the class mapping if it exists
+            dir_path = os.path.dirname(os.path.dirname(file_path))
+            class_mapping_path = f"{dir_path}/class_mapping.json"
+            if os.path.exists(class_mapping_path):
+                self.class_mapping = json.load(open(class_mapping_path, 'r'))
+                self.mapping_edit.setText(class_mapping_path)
+
+    def browse_class_mapping_file(self):
+        """
+        Browse and select a class mapping file.
+        """
+        file_path, _ = QFileDialog.getOpenFileName(self,
+                                                   "Select Class Mapping File",
+                                                   "",
+                                                   "JSON Files (*.json)")
+        if file_path:
+            # Load the class mapping
+            self.class_mapping = json.load(open(file_path, 'r'))
+            self.mapping_edit.setText(file_path)
 
     def initialize_uncertainty_threshold(self):
         """Initialize the uncertainty threshold slider with the current value"""
@@ -517,9 +517,6 @@ class DeployPredictorDialog(QDialog):
             # Open the image using rasterio
             image = rasterio_to_numpy(self.main_window.image_window.rasterio_images[image_path])
 
-        # Preprocess the image
-        # image = preprocess_image(image)
-
         # Save the original image
         self.original_image = image
         self.image_path = image_path
@@ -530,19 +527,19 @@ class DeployPredictorDialog(QDialog):
         else:
             self.resized_image = image
 
-    def predict_from_prompts(self, bboxes):
+    def predict_from_prompts(self, bboxes, masks=None):
         """
         Make predictions using the currently loaded model using prompts.
 
         Args:
-            bbox (np.ndarray): The bounding boxes to use as prompts.
+            bboxes (np.ndarray): The bounding boxes to use as prompts.
+            masks (list, optional): A list of polygons to use as prompts for segmentation.
 
         Returns:
             results (Results): Ultralytics Results object
         """
         if not self.loaded_model:
-            QMessageBox.critical(self.annotation_window,
-                                 "Model Not Loaded",
+            QMessageBox.critical(self.annotation_window, "Model Not Loaded",
                                  "Model not loaded, cannot make predictions")
             return None
 
@@ -556,14 +553,30 @@ class DeployPredictorDialog(QDialog):
         bboxes[:, 2] = (bboxes[:, 2] / self.original_image.shape[1]) * self.resized_image.shape[1]
         bboxes[:, 3] = (bboxes[:, 3] / self.original_image.shape[0]) * self.resized_image.shape[0]
 
+        # Set the predictor
+        self.task = self.task_dropdown.currentText()
+
         # Create a visual dictionary
         visuals = {
             'bboxes': np.array(bboxes),
-            'cls': np.zeros(len(bboxes))  # TODO figure this out
+            'cls': np.zeros(len(bboxes))
         }
+        if self.task == 'segment':
+            if masks:
+                scaled_masks = []
+                for mask in masks:
+                    scaled_mask = np.array(mask, dtype=np.float32)
+                    scaled_mask[:, 0] = (scaled_mask[:, 0] / self.original_image.shape[1]) * self.resized_image.shape[1]
+                    scaled_mask[:, 1] = (scaled_mask[:, 1] / self.original_image.shape[0]) * self.resized_image.shape[0]
+                    scaled_masks.append(scaled_mask)
+                visuals['masks'] = scaled_masks
+            else:  # Fallback to creating masks from bboxes if no masks are provided
+                fallback_masks = []
+                for bbox in bboxes:
+                    x1, y1, x2, y2 = bbox
+                    fallback_masks.append(np.array([[x1, y1], [x2, y1], [x2, y2], [x1, y2]]))
+                visuals['masks'] = fallback_masks
 
-        # Set the predictor
-        self.task = self.task_dropdown.currentText()
         predictor = YOLOEVPSegPredictor if self.task == "segment" else YOLOEVPDetectPredictor
 
         try:
@@ -590,7 +603,7 @@ class DeployPredictorDialog(QDialog):
 
         return results
 
-    def predict_from_annotations(self, refer_image, refer_label, refer_annotations, target_images):
+    def predict_from_annotations(self, refer_image, refer_label, refer_bboxes, refer_masks, target_images):
         """"""
         # Create a class mapping
         class_mapping = {0: refer_label}
@@ -605,14 +618,17 @@ class DeployPredictorDialog(QDialog):
             max_area_thresh=self.main_window.get_area_thresh_max()
         )
 
+        # Set the predictor
+        self.task = self.task_dropdown.currentText()
+
         # Create a visual dictionary
         visuals = {
-            'bboxes': np.array(refer_annotations),
-            'cls': np.zeros(len(refer_annotations))
+            'bboxes': np.array(refer_bboxes),
+            'cls': np.zeros(len(refer_bboxes))
         }
+        if self.task == 'segment':
+            visuals['masks'] = refer_masks
 
-        # Set the predictor
-        self.task = self.task_dropdown.currentText()
         predictor = YOLOEVPSegPredictor if self.task == "segment" else YOLOEVPDetectPredictor
 
         # Create a progress bar

coralnet_toolbox/SeeAnything/QtTrainModel.py

@@ -13,7 +13,7 @@ from ultralytics.models.yolo.yoloe import YOLOEPESegTrainer
 from PyQt5.QtCore import Qt, QThread, pyqtSignal
 from PyQt5.QtWidgets import (QFileDialog, QScrollArea, QMessageBox, QCheckBox, QWidget, QVBoxLayout,
                              QLabel, QLineEdit, QDialog, QHBoxLayout, QPushButton, QComboBox, QSpinBox,
-                             QFormLayout, QTabWidget, QDoubleSpinBox, QGroupBox, )
+                             QFormLayout, QTabWidget, QDoubleSpinBox, QGroupBox)
 
 from torch.cuda import empty_cache
 
@@ -109,7 +109,7 @@ class TrainModelWorker(QThread):
 
             # Train the model
             self.model.train(**self.params,
-                             trainer=YOLOEPESegTrainer,
+                             trainer=YOLOEVPTrainer  , #YOLOEPESegTrainer,
                              device=self.device)
 
             # Post-run cleanup
@@ -222,6 +222,13 @@ class TrainModelDialog(QDialog):
         # Task specific parameters
         self.imgsz = 640
         self.batch = 4
+        
+        # Training parameters with defaults for linear-probing
+        self._lr0 = 1e-3
+        self._warmup_bias_lr = 0.0
+        self._weight_decay = 0.025
+        self._momentum = 0.9
+        self._close_mosaic = 0  # Default for linear-probing
 
         # Create the layout
         self.layout = QVBoxLayout(self)
@@ -232,6 +239,8 @@ class TrainModelDialog(QDialog):
         self.setup_dataset_layout()
         # Create the model layout (new)
         self.setup_model_layout()
+        # Create the output parameters layout
+        self.setup_output_parameters_layout()
         # Create and set up the parameters layout
         self.setup_parameters_layout()
         # Create the buttons layout
@@ -327,6 +336,29 @@ class TrainModelDialog(QDialog):
         layout.addWidget(tab_widget)
         group_box.setLayout(layout)
         self.layout.addWidget(group_box)
+        
+    def setup_output_parameters_layout(self):
+        """
+        Set up the layout and widgets for output parameters (project directory and name).
+        """
+        group_box = QGroupBox("Output")
+        layout = QFormLayout()
+
+        # Project
+        self.project_edit = QLineEdit()
+        self.project_button = QPushButton("Browse...")
+        self.project_button.clicked.connect(self.browse_project_dir)
+        project_layout = QHBoxLayout()
+        project_layout.addWidget(self.project_edit)
+        project_layout.addWidget(self.project_button)
+        layout.addRow("Project:", project_layout)
+
+        # Name
+        self.name_edit = QLineEdit()
+        layout.addRow("Name:", self.name_edit)
+
+        group_box.setLayout(layout)
+        self.layout.addWidget(group_box)
 
     def setup_parameters_layout(self):
         """
@@ -352,19 +384,6 @@ class TrainModelDialog(QDialog):
         group_layout = QVBoxLayout(group_box)
         group_layout.addWidget(scroll_area)
 
-        # Project
-        self.project_edit = QLineEdit()
-        self.project_button = QPushButton("Browse...")
-        self.project_button.clicked.connect(self.browse_project_dir)
-        project_layout = QHBoxLayout()
-        project_layout.addWidget(self.project_edit)
-        project_layout.addWidget(self.project_button)
-        form_layout.addRow("Project:", project_layout)
-
-        # Name
-        self.name_edit = QLineEdit()
-        form_layout.addRow("Name:", self.name_edit)
-
         # Fine-tune or Linear Probing
         self.training_mode = QComboBox()
         self.training_mode.addItems(["linear-probe", "fine-tune"])
@@ -381,11 +400,60 @@ class TrainModelDialog(QDialog):
 
         # Patience
         self.patience_spinbox = QSpinBox()
-        self.patience_spinbox.setMinimum(1)
+        self.patience_spinbox.setMinimum(0)  # Changed minimum to 0 to allow for 0 patience
         self.patience_spinbox.setMaximum(1000)
-        self.patience_spinbox.setValue(30)
+        self.patience_spinbox.setValue(0)  # Default for linear-probing
         form_layout.addRow("Patience:", self.patience_spinbox)
 
+        # Close Mosaic
+        self.close_mosaic_spinbox = QSpinBox()
+        self.close_mosaic_spinbox.setMinimum(0)
+        self.close_mosaic_spinbox.setMaximum(1000)
+        self.close_mosaic_spinbox.setValue(0)  # Default for linear-probing
+        form_layout.addRow("Close Mosaic:", self.close_mosaic_spinbox)
+        
+        # Optimizer
+        self.optimizer_combo = QComboBox()
+        self.optimizer_combo.addItems(["auto", "SGD", "Adam", "AdamW", "NAdam", "RAdam", "RMSProp"])
+        self.optimizer_combo.setCurrentText("AdamW")
+        form_layout.addRow("Optimizer:", self.optimizer_combo)
+
+        # Learning Rate (lr0)
+        self.lr0_spinbox = QDoubleSpinBox()
+        self.lr0_spinbox.setDecimals(6)
+        self.lr0_spinbox.setMinimum(0.000001)
+        self.lr0_spinbox.setMaximum(1.0)
+        self.lr0_spinbox.setSingleStep(0.0001)
+        self.lr0_spinbox.setValue(self._lr0)
+        form_layout.addRow("Learning Rate:", self.lr0_spinbox)
+
+        # Warmup Bias Learning Rate
+        self.warmup_bias_lr_spinbox = QDoubleSpinBox()
+        self.warmup_bias_lr_spinbox.setDecimals(6)
+        self.warmup_bias_lr_spinbox.setMinimum(0.0)
+        self.warmup_bias_lr_spinbox.setMaximum(1.0)
+        self.warmup_bias_lr_spinbox.setSingleStep(0.0001)
+        self.warmup_bias_lr_spinbox.setValue(self._warmup_bias_lr)
+        form_layout.addRow("Warmup Bias LR:", self.warmup_bias_lr_spinbox)
+
+        # Weight Decay
+        self.weight_decay_spinbox = QDoubleSpinBox()
+        self.weight_decay_spinbox.setDecimals(6)
+        self.weight_decay_spinbox.setMinimum(0.0)
+        self.weight_decay_spinbox.setMaximum(1.0)
+        self.weight_decay_spinbox.setSingleStep(0.001)
+        self.weight_decay_spinbox.setValue(self._weight_decay)
+        form_layout.addRow("Weight Decay:", self.weight_decay_spinbox)
+
+        # Momentum
+        self.momentum_spinbox = QDoubleSpinBox()
+        self.momentum_spinbox.setDecimals(2)
+        self.momentum_spinbox.setMinimum(0.0)
+        self.momentum_spinbox.setMaximum(1.0)
+        self.momentum_spinbox.setSingleStep(0.01)
+        self.momentum_spinbox.setValue(self._momentum)
+        form_layout.addRow("Momentum:", self.momentum_spinbox)
+
         # Imgsz
         self.imgsz_spinbox = QSpinBox()
         self.imgsz_spinbox.setMinimum(16)
@@ -393,10 +461,6 @@ class TrainModelDialog(QDialog):
         self.imgsz_spinbox.setValue(self.imgsz)
         form_layout.addRow("Image Size:", self.imgsz_spinbox)
 
-        # Multi Scale
-        self.multi_scale_combo = create_bool_combo()
-        form_layout.addRow("Multi-Scale:", self.multi_scale_combo)
-
         # Batch
         self.batch_spinbox = QSpinBox()
         self.batch_spinbox.setMinimum(1)
@@ -421,20 +485,6 @@ class TrainModelDialog(QDialog):
         self.save_period_spinbox.setMaximum(1000)
         self.save_period_spinbox.setValue(-1)
         form_layout.addRow("Save Period:", self.save_period_spinbox)
-
-        # Dropout
-        self.dropout_spinbox = QDoubleSpinBox()
-        self.dropout_spinbox.setMinimum(0.0)
-        self.dropout_spinbox.setMaximum(1.0)
-        self.dropout_spinbox.setValue(0.0)
-        form_layout.addRow("Dropout:", self.dropout_spinbox)
-
-        # Optimizer
-        self.optimizer_combo = QComboBox()
-        self.optimizer_combo.addItems(["auto", "SGD", "Adam", "AdamW", "NAdam", "RAdam", "RMSProp"])
-        self.optimizer_combo.setCurrentText("AdamW")
-        form_layout.addRow("Optimizer:", self.optimizer_combo)
-
         # Val
         self.val_combo = create_bool_combo()
         form_layout.addRow("Validation:", self.val_combo)
@@ -489,9 +539,32 @@ class TrainModelDialog(QDialog):
             # Fine-tune mode
             self.epochs_spinbox.setValue(80)
             self.patience_spinbox.setValue(20)
+            self.close_mosaic_spinbox.setValue(10)
+            self._close_mosaic = 10
+            
+            # These parameters stay the same for both modes
+            self.lr0_spinbox.setValue(1e-3)
+            self.warmup_bias_lr_spinbox.setValue(0.0)
+            self.weight_decay_spinbox.setValue(0.025)
+            self.momentum_spinbox.setValue(0.9)
+            
+            # Ensure optimizer is set to AdamW
+            self.optimizer_combo.setCurrentText("AdamW")
         else:
+            # Linear-probing mode
             self.epochs_spinbox.setValue(2)
-            self.patience_spinbox.setValue(1)
+            self.patience_spinbox.setValue(0)
+            self.close_mosaic_spinbox.setValue(0)
+            self._close_mosaic = 0
+            
+            # These parameters stay the same for both modes
+            self.lr0_spinbox.setValue(1e-3)
+            self.warmup_bias_lr_spinbox.setValue(0.0)
+            self.weight_decay_spinbox.setValue(0.025)
+            self.momentum_spinbox.setValue(0.9)
+            
+            # Ensure optimizer is set to AdamW
+            self.optimizer_combo.setCurrentText("AdamW")
 
     def load_model_combobox(self):
         """Load the model combobox with the available models."""
@@ -605,13 +678,16 @@ class TrainModelDialog(QDialog):
             'patience': self.patience_spinbox.value(),
             'batch': self.batch_spinbox.value(),
             'imgsz': self.imgsz_spinbox.value(),
-            'multi_scale': self.multi_scale_combo.currentText() == "True",
+            'optimizer': self.optimizer_combo.currentText(),
+            'lr0': self.lr0_spinbox.value(),
+            'warmup_bias_lr': self.warmup_bias_lr_spinbox.value(),
+            'weight_decay': self.weight_decay_spinbox.value(),
+            'momentum': self.momentum_spinbox.value(),
+            'close_mosaic': self.close_mosaic_spinbox.value(),
             'save': self.save_combo.currentText() == "True",
             'save_period': self.save_period_spinbox.value(),
             'workers': self.workers_spinbox.value(),
-            'optimizer': self.optimizer_combo.currentText(),
             'verbose': self.verbose_combo.currentText() == "True",
-            'dropout': self.dropout_spinbox.value(),
             'val': self.val_combo.currentText() == "True",
             'exist_ok': True,
             'plots': True,
@@ -644,12 +720,6 @@ class TrainModelDialog(QDialog):
                         except ValueError:
                             params[name] = value
 
-        params['lr0'] = 1e-3 if 'lr0' not in params else params['lr0']
-        params['warmup_bias_lr'] = 0.0 if 'warmup_bias_lr' not in params else params['warmup_bias_lr']
-        params['weight_decay'] = 0.025 if 'weight_decay' not in params else params['weight_decay']
-        params['momentum'] = 0.9 if 'momentum' not in params else params['momentum']
-        params['close_mosaic'] = 10 if 'close_mosaic' not in params else params['close_mosaic']
-
         # Return the dictionary of parameters
         return params
 

coralnet_toolbox/SeeAnything/__init__.py

@@ -2,9 +2,11 @@
 from .QtTrainModel import TrainModelDialog
 from .QtBatchInference import BatchInferenceDialog
 from .QtDeployPredictor import DeployPredictorDialog
+from .QtDeployGenerator import DeployGeneratorDialog
 
 __all__ = [
     'TrainModelDialog',
     'BatchInferenceDialog'
     'DeployPredictorDialog',
+    'DeployGeneratorDialog',
 ]

coralnet_toolbox/Tools/QtResizeSubTool.py

@@ -59,9 +59,14 @@ class ResizeSubTool(SubTool):
     def mouseReleaseEvent(self, event):
         """Finalize the resize, update related windows, and deactivate."""
         if self.target_annotation:
+            # Normalize the coordinates after resize is complete
+            if hasattr(self.target_annotation, 'normalize_coordinates'):
+                self.target_annotation.normalize_coordinates()
+                
             self.target_annotation.create_cropped_image(self.annotation_window.rasterio_image)
             self.parent_tool.main_window.confidence_window.display_cropped_image(self.target_annotation)
-
+            self.annotation_window.annotationModified.emit(self.target_annotation.id)  # Emit modified signal
+            
         self.parent_tool.deactivate_subtool()
 
     # --- Handle Management Logic (moved from original class) ---

coralnet_toolbox/Tools/QtSAMTool.py

@@ -64,6 +64,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 +87,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 +147,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.
@@ -357,11 +472,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 +558,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 +594,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:
@@ -507,6 +645,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()