Add confirmation request in case of ROI override

StefanoPierini-Codra · StefanoPierini-Codra · commit 49410ef080b0 · 2026-06-11T15:22:22.000+02:00
diff --git a/datalab/gui/processor/base.py b/datalab/gui/processor/base.py
@@ -792,6 +792,30 @@ def register_computations(self) -> None:
         self.register_processing()
         self.register_analysis()
 
+    # pylint: disable=unused-argument
+    def preprocess_1_to_0(
+        self,
+        func: Callable,
+        param: gds.DataSet | None,
+        objs: list[SignalObj | ImageObj],
+    ) -> bool:
+        """Pre-check hook for 1-to-0 operations (hook method).
+
+        This method is called before a 1-to-0 computation starts, before the
+        progress dialog is opened. Subclasses can override this method to perform
+        pre-checks or ask for user confirmation.  Return ``False`` to abort the
+        computation.
+
+        Args:
+            func: The computation function that will be called
+            param: Optional parameter set
+            objs: List of objects that will be processed
+
+        Returns:
+            True to proceed with the computation, False to abort
+        """
+        return True
+
     # pylint: disable=unused-argument
     def postprocess_1_to_0_result(
         self, obj: SignalObj | ImageObj, result: GeometryResult | TableResult
@@ -1401,6 +1425,8 @@ def compute_1_to_0(
             if target_objs is not None
             else self.panel.objview.get_sel_objects(include_groups=True)
         )
+        if not self.preprocess_1_to_0(func, param, objs):
+            return None
         current_obj = self.panel.objview.get_current_object()
         title = func.__name__ if title is None else title
         refresh_needed = False
diff --git a/datalab/gui/processor/image.py b/datalab/gui/processor/image.py
@@ -8,6 +8,7 @@
 
 from __future__ import annotations
 
+import guidata.dataset as gds
 import numpy as np
 import sigima.params
 import sigima.proc.base as sipb
@@ -25,6 +26,7 @@
 )
 from sigima.objects.scalar import GeometryResult, TableResult
 
+from datalab import env
 from datalab.config import APP_NAME, _
 from datalab.gui.processor.base import BaseProcessor
 from datalab.gui.processor.geometry_postprocess import (
@@ -55,6 +57,50 @@ def _wrap_geometric_transform(self, func, operation: str):
         """
         return GeometricTransformWrapper(func, operation)
 
+    def preprocess_1_to_0(
+        self,
+        func,
+        param: gds.DataSet | None,
+        objs: list[ImageObj],
+    ) -> bool:
+        """Override to confirm ROI replacement before the progress bar opens.
+
+        When the parameter has ``create_rois=True`` and at least one selected
+        image already has ROIs, the user is warned that the existing ROIs will
+        be replaced.
+
+        Args:
+            func: The computation function that will be called
+            param: Optional parameter set
+            objs: List of image objects that will be processed
+
+        Returns:
+            True to proceed with the computation, False to abort
+        """
+        if (
+            param is not None
+            and getattr(param, "create_rois", False)
+            and not env.execenv.unattended
+            and any(obj.roi is not None and not obj.roi.is_empty() for obj in objs)
+        ):
+            return (
+                QW.QMessageBox.question(
+                    self.mainwindow,
+                    _("Warning"),
+                    _(
+                        "Regions of interest are already defined for this "
+                        "image.<br><br>"
+                        "Creating new ROIs from detection will replace the "
+                        "existing ones, which will be lost.<br><br>"
+                        "Do you want to continue?"
+                    ),
+                    QW.QMessageBox.Yes | QW.QMessageBox.No,
+                    QW.QMessageBox.No,
+                )
+                == QW.QMessageBox.Yes
+            )
+        return True
+
     def postprocess_1_to_0_result(
         self, obj: ImageObj, result: GeometryResult | TableResult
     ) -> bool:
diff --git a/datalab/locale/fr/LC_MESSAGES/datalab.po b/datalab/locale/fr/LC_MESSAGES/datalab.po
@@ -2430,6 +2430,9 @@ msgstr "Détection de taches basée sur SimpleBlobDetector d'OpenCV"
 msgid "Creating a ROI grid will overwrite any existing ROI.<br><br>Do you want to continue?"
 msgstr "La création d'une grille de ROI écrasera toute ROI existante.<br><br>Voulez-vous continuer ?"
 
+msgid "Regions of interest are already defined for this image.<br><br>Creating new ROIs from detection will replace the existing ones, which will be lost.<br><br>Do you want to continue?"
+msgstr "Des régions d'intérêt sont déjà définies pour cette image.<br><br>La création de nouvelles ROI par détection remplacera les existantes, qui seront perdues.<br><br>Voulez-vous continuer ?"
+
 msgid "Extract ROI"
 msgstr "Extraire une ROI"
 
diff --git a/datalab/tests/features/image/detection_roi_replace_unit_test.py b/datalab/tests/features/image/detection_roi_replace_unit_test.py
@@ -0,0 +1,200 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Detection ROI replacement confirmation test
+
+Testing the following:
+  - When create_rois=True and image already has ROIs, the preprocess hook
+    runs before the progress bar and can abort the computation
+  - In unattended mode (automated tests) the dialog is skipped and ROIs
+    are always replaced
+  - When create_rois=False, existing ROIs are left untouched
+  - When no existing ROIs are present, ROI creation proceeds normally
+  - When the user cancels the confirmation dialog, existing ROIs are preserved
+  - The confirmation dialog is shown only when ROIs already exist
+"""
+
+# guitest: show
+
+from __future__ import annotations
+
+from unittest.mock import patch
+
+import sigima.params
+import sigima.proc.image as sipi
+from qtpy import QtWidgets as QW
+from sigima.objects import NewImageParam, create_image_roi
+from sigima.tests.data import create_multigaussian_image, create_peak_image
+
+from datalab.env import execenv
+from datalab.tests import datalab_test_app_context
+from datalab.tests.features.image.roi_app_test import IROI1, IROI2
+
+
+def _create_image_with_roi():
+    """Return a multigaussian image that already has ROIs defined."""
+    newparam = NewImageParam.create(height=200, width=200)
+    ima = create_multigaussian_image(newparam)
+    roi = create_image_roi("rectangle", IROI1)
+    roi.add_roi(create_image_roi("circle", IROI2))
+    ima.roi = roi
+    return ima
+
+
+def test_create_rois_no_existing_roi():
+    """ROIs are created normally when the image has no pre-existing ROI."""
+    with datalab_test_app_context() as win:
+        panel = win.imagepanel
+        ima = create_peak_image()
+        assert ima.roi is None
+        panel.add_object(ima)
+
+        param = sigima.params.Peak2DDetectionParam.create(create_rois=True)
+        result = panel.processor.compute_peak_detection(param)
+        assert result is not None, "Peak detection should return results"
+
+        obj = panel.objview.get_current_object()
+        assert obj.roi is not None, "ROI should be created when create_rois=True"
+        assert not obj.roi.is_empty(), "Created ROI should not be empty"
+
+
+def test_create_rois_with_existing_roi_unattended():
+    """In unattended mode, existing ROIs are silently replaced (no dialog)."""
+    with datalab_test_app_context() as win:
+        panel = win.imagepanel
+        ima = _create_image_with_roi()
+        initial_roi = ima.roi
+        panel.add_object(ima)
+
+        # execenv.unattended is True in the test suite: the dialog is skipped
+        assert execenv.unattended, "This test requires unattended mode"
+
+        param = sigima.params.Peak2DDetectionParam.create(create_rois=True)
+        result = panel.processor.compute_peak_detection(param)
+        assert result is not None, "Peak detection should return results"
+
+        obj = panel.objview.get_current_object()
+        assert obj.roi is not None, "ROI should be present after detection"
+        assert obj.roi != initial_roi, (
+            "Existing ROI should have been replaced in unattended mode"
+        )
+
+
+def test_create_rois_false_preserves_existing_roi():
+    """When create_rois=False, existing ROIs are never touched."""
+    with datalab_test_app_context() as win:
+        panel = win.imagepanel
+        ima = _create_image_with_roi()
+        panel.add_object(ima)
+
+        obj = panel.objview.get_current_object()
+        roi_before = obj.roi
+
+        param = sigima.params.Peak2DDetectionParam.create(create_rois=False)
+        panel.processor.compute_peak_detection(param)
+
+        obj = panel.objview.get_current_object()
+        assert obj.roi == roi_before, (
+            "Existing ROI must not be modified when create_rois=False"
+        )
+
+
+def test_dialog_shown_only_when_roi_exists():
+    """The confirmation dialog is triggered only when the image already has ROIs.
+
+    - With existing ROIs and create_rois=True: preprocess_1_to_0 calls the dialog
+    - Without existing ROIs and create_rois=True: preprocess_1_to_0 returns True
+      directly, without opening any dialog
+    """
+    with datalab_test_app_context() as win:
+        panel = win.imagepanel
+        param = sigima.params.Peak2DDetectionParam.create(create_rois=True)
+
+        # Case 1: image with no ROI — dialog must NOT be shown
+        ima_no_roi = create_peak_image()
+        panel.add_object(ima_no_roi)
+        objs_no_roi = panel.objview.get_sel_objects(include_groups=True)
+
+        with patch.object(QW.QMessageBox, "question") as mock_question:
+            execenv.unattended = False
+            try:
+                result = panel.processor.preprocess_1_to_0(
+                    sipi.peak_detection, param, objs_no_roi
+                )
+            finally:
+                execenv.unattended = True
+
+        assert result is True, "Should proceed when no existing ROIs"
+        mock_question.assert_not_called()
+
+        # Case 2: image with existing ROI — dialog MUST be shown
+        ima_with_roi = _create_image_with_roi()
+        panel.add_object(ima_with_roi)
+        objs_with_roi = panel.objview.get_sel_objects(include_groups=True)
+
+        with patch.object(
+            QW.QMessageBox, "question", return_value=QW.QMessageBox.Yes
+        ) as mock_question:
+            execenv.unattended = False
+            try:
+                result = panel.processor.preprocess_1_to_0(
+                    sipi.peak_detection, param, objs_with_roi
+                )
+            finally:
+                execenv.unattended = True
+
+        assert result is True, "Should proceed when user confirms"
+        mock_question.assert_called_once()
+
+
+def test_cancel_dialog_preserves_existing_roi():
+    """When the user cancels the confirmation dialog, existing ROIs are preserved."""
+    with datalab_test_app_context() as win:
+        panel = win.imagepanel
+        ima = _create_image_with_roi()
+        panel.add_object(ima)
+
+        obj = panel.objview.get_current_object()
+        roi_before = obj.roi
+
+        param = sigima.params.Peak2DDetectionParam.create(create_rois=True)
+
+        # Simulate the user clicking "No" in the confirmation dialog
+        with patch.object(QW.QMessageBox, "question", return_value=QW.QMessageBox.No):
+            execenv.unattended = False
+            try:
+                result = panel.processor.compute_peak_detection(param)
+            finally:
+                execenv.unattended = True
+
+        assert result is None, "Computation should be aborted when user cancels"
+        obj = panel.objview.get_current_object()
+        assert obj.roi == roi_before, (
+            "Existing ROI must be preserved when user cancels the dialog"
+        )
+
+
+def test_preprocess_hook_abort_skipped_in_unattended():
+    """preprocess_1_to_0 returns True in unattended mode (no blocking dialog)."""
+    with datalab_test_app_context() as win:
+        panel = win.imagepanel
+        ima = _create_image_with_roi()
+        panel.add_object(ima)
+
+        assert execenv.unattended, "This test requires unattended mode"
+
+        param = sigima.params.Peak2DDetectionParam.create(create_rois=True)
+        objs = panel.objview.get_sel_objects(include_groups=True)
+
+        # In unattended mode the hook must always return True (no dialog shown)
+        result = panel.processor.preprocess_1_to_0(sipi.peak_detection, param, objs)
+        assert result is True, "preprocess_1_to_0 must return True in unattended mode"
+
+
+if __name__ == "__main__":
+    test_create_rois_no_existing_roi()
+    test_create_rois_with_existing_roi_unattended()
+    test_create_rois_false_preserves_existing_roi()
+    test_dialog_shown_only_when_roi_exists()
+    test_cancel_dialog_preserves_existing_roi()
+    test_preprocess_hook_abort_skipped_in_unattended()
