Migrate unit tests from cdl to sigima_ (finished image tests)

Author: PierreRaybaut

cdl/plugins/cdl_testdata.py

@@ -83,7 +83,7 @@ def create_peak2d_image(self) -> None:
             param = test_data.PeakDataParam.create(size=max(obj.data.shape))
             self.imagepanel.processor.update_param_defaults(param)
             if param.edit(self.main):
-                obj.data = test_data.get_peak2d_data(param)
+                obj.data, _coords = test_data.get_peak2d_data(param)
                 self.proxy.add_object(obj)
 
     def create_sincos_image(self) -> None:

…/features/images/imagebgdlg_unit_test.py …eatures/images/background_dialog_test.pycdl/tests/features/images/imagebgdlg_unit_test.py renamed to cdl/tests/features/images/background_dialog_test.py cdl/tests/features/images/imagebgdlg_unit_test.py renamed to cdl/tests/features/images/background_dialog_test.py

@@ -10,6 +10,7 @@
 
 from __future__ import annotations
 
+import numpy as np
 from guidata.qthelpers import exec_dialog, qt_app_context
 
 import sigima_.computation.image as sigima_image
@@ -21,8 +22,27 @@
 from sigima_.tests.data import create_noisygauss_image
 
 
-def test_image_background_dialog() -> None:
-    """Image background dialog test."""
+def test_image_background_selection() -> None:
+    """Image background selection test."""
+    with qt_app_context():
+        img = create_noisygauss_image()
+        dlg = ImageBackgroundDialog(img)
+        dlg.resize(640, 480)
+        dlg.setObjectName(dlg.objectName() + "_00")  # to avoid timestamp suffix
+        with execenv.context(delay=200):
+            # For more details about the why of the delay, see the comment in
+            # cdl\tests\features\image\offset_correction_unit_test.py
+            exec_dialog(dlg)
+        execenv.print(f"background: {dlg.get_background()}")
+        execenv.print(f"rect coords: {dlg.get_rect_coords()}")
+        # Check background value:
+        x0, y0, x1, y1 = dlg.get_rect_coords()
+        ix0, iy0, ix1, iy1 = dlg.imageitem.get_closest_index_rect(x0, y0, x1, y1)
+        assert np.isclose(img.data[iy0:iy1, ix0:ix1].mean(), dlg.get_background())
+
+
+def test_image_offset_correction_with_background_dialog() -> None:
+    """Image offset correction interactive test using the background dialog."""
     with qt_app_context():
         i1 = create_noisygauss_image()
         dlg = ImageBackgroundDialog(i1)
@@ -51,4 +71,5 @@ def test_image_background_dialog() -> None:
 
 
 if __name__ == "__main__":
-    test_image_background_dialog()
+    test_image_background_selection()
+    test_image_offset_correction_with_background_dialog()

cdl/tests/features/images/peak2d_unit_test.py

@@ -0,0 +1,56 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Profile extraction unit test
+"""
+
+# pylint: disable=invalid-name  # Allows short reference names like x, y, ...
+# guitest: show
+
+from guidata.qthelpers import exec_dialog, qt_app_context
+
+import sigima_.param
+from cdl.env import execenv
+from cdl.gui.profiledialog import ProfileExtractionDialog
+from sigima_.tests.data import create_noisygauss_image
+
+
+def test_profile_unit():
+    """Run profile extraction test"""
+    with qt_app_context():
+        obj = create_noisygauss_image(center=(0.0, 0.0), add_annotations=False)
+        for mode in ("line", "segment", "rectangle"):
+            for initial_param in (True, False):
+                if initial_param:
+                    if mode == "line":
+                        param = sigima_.param.LineProfileParam.create(row=100, col=200)
+                    elif mode == "segment":
+                        param = sigima_.param.SegmentProfileParam.create(
+                            row1=10, col1=20, row2=200, col2=300
+                        )
+                    else:
+                        param = sigima_.param.AverageProfileParam.create(
+                            row1=10, col1=20, row2=200, col2=300
+                        )
+                else:
+                    if mode == "line":
+                        param = sigima_.param.LineProfileParam()
+                    elif mode == "segment":
+                        param = sigima_.param.SegmentProfileParam()
+                    else:
+                        param = sigima_.param.AverageProfileParam()
+                execenv.print("-" * 80)
+                execenv.print(f"Testing mode: {mode} - initial_param: {initial_param}")
+                dialog = ProfileExtractionDialog(
+                    mode, param, add_initial_shape=initial_param
+                )
+                dialog.set_obj(obj)
+                if initial_param:
+                    dialog.edit_values()
+                ok = exec_dialog(dialog)
+                execenv.print(f"Returned code: {ok}")
+                execenv.print(f"Param: {param}")
+
+
+if __name__ == "__main__":
+    test_profile_unit()

cdl/tests/features/images/profile_dialog_test.py

@@ -57,11 +57,12 @@ def find_contours(data):
 @pytest.mark.gui
 def test_contour_interactive():
     """2D peak detection test"""
+    data, _coords = get_peak2d_data()
     # pylint: disable=import-outside-toplevel
     from guidata.qthelpers import qt_app_context
 
     with qt_app_context():
-        find_contours(get_peak2d_data())
+        find_contours(data)
 
 
 if __name__ == "__main__":

cdl/tests/features/images/select_background_unit_test.py

@@ -56,11 +56,12 @@ def __exec_hough_circle_test(data):
 @pytest.mark.gui
 def test_hough_circle():
     """2D peak detection test"""
+    data, _coords = get_peak2d_data(multi=False)
     # pylint: disable=import-outside-toplevel
     from guidata.qthelpers import qt_app_context
 
     with qt_app_context():
-        __exec_hough_circle_test(get_peak2d_data(multi=False))
+        __exec_hough_circle_test(data)
 
 
 if __name__ == "__main__":

cdl/tests/sigima_tests/images/contour_unit_test.py

@@ -5,23 +5,28 @@
 """
 
 # pylint: disable=invalid-name  # Allows short reference names like x, y, ...
-# guitest: skip
 
-from guidata.qthelpers import qt_app_context
+import pytest
 
-from cdl.env import execenv
-from cdl.tests.features.images.peak2d_unit_test import exec_image_peak_detection_func
+from cdl.tests.sigima_tests.images.peak2d_unit_test import (
+    exec_image_peak_detection_func,
+)
 from sigima_.algorithms.image import get_2d_peaks_coords
+from sigima_.env import execenv
 from sigima_.tests.data import get_peak2d_data
 
 
-def peak2d_limit_test():
+@pytest.mark.skip(reason="Limit testing, not required for automated testing")
+def test_peak2d_limit():
     """2D peak detection test"""
+    # pylint: disable=import-outside-toplevel
+    from guidata.qthelpers import qt_app_context
+
     with qt_app_context():
         execenv.print("Testing peak detection algorithm with random generated data:")
         for idx in range(100):
             execenv.print(f"  Iteration #{idx:02d}: ", end="")
-            generated_data = get_peak2d_data(multi=True)
+            generated_data, _coords = get_peak2d_data(multi=True)
             coords = get_2d_peaks_coords(generated_data)
             if coords.shape[0] != 4:
                 execenv.print(f"KO - {coords.shape[0]}/4 peaks were detected")
@@ -33,4 +38,4 @@ def peak2d_limit_test():
 
 
 if __name__ == "__main__":
-    peak2d_limit_test()
+    test_peak2d_limit()

cdl/tests/sigima_tests/images/hough_circle_unit_test.py

@@ -0,0 +1,108 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Image peak detection test
+"""
+
+# pylint: disable=invalid-name  # Allows short reference names like x, y, ...
+# pylint: disable=duplicate-code
+
+from __future__ import annotations
+
+import time
+
+import numpy as np
+import pytest
+
+import sigima_.computation.image as sigima_image
+import sigima_.obj
+import sigima_.param
+from sigima_.algorithms.image import get_2d_peaks_coords
+from sigima_.env import execenv
+from sigima_.tests.data import get_peak2d_data
+from sigima_.tests.helpers import check_array_result
+from sigima_.tests.vistools import view_image_items
+
+
+def exec_image_peak_detection_func(data: np.ndarray) -> np.ndarray:
+    """Execute image peak detection function
+
+    Args:
+        data: 2D image data
+
+    Returns:
+        2D array of peak coordinates
+    """
+    t0 = time.time()
+    coords = get_2d_peaks_coords(data)
+    dt = time.time() - t0
+    execenv.print(f"Calculation time: {int(dt * 1e3):d} ms")
+    execenv.print(f"  => {coords.tolist()}")
+    return coords
+
+
+def view_image_peak_detection(data: np.ndarray, coords: np.ndarray) -> None:
+    """View image peak detection results
+
+    Args:
+        data: 2D image data
+        coords: Coordinates of detected peaks (shape: (n, 2))
+    """
+    from plotpy.builder import make  # pylint: disable=import-outside-toplevel
+
+    execenv.print("Peak detection results:")
+    items = [make.image(data, interpolation="linear", colormap="hsv")]
+    for x, y in coords:
+        items.append(make.marker((x, y)))
+    view_image_items(
+        items, name=view_image_peak_detection.__name__, title="Peak Detection"
+    )
+
+
+def test_peak2d_unit():
+    """2D peak detection unit test"""
+    data, coords_expected = get_peak2d_data(multi=False)
+    coords = exec_image_peak_detection_func(data)
+    assert coords.shape == coords_expected.shape, (
+        f"Expected {coords_expected.shape[0]} peaks, got {coords.shape[0]}"
+    )
+    # Absolute tolerance is set to 2 pixels, as coordinates are in pixel units
+    # and the algorithm may detect peaks at slightly different pixel locations
+    check_array_result("Peak coords (alg.)", coords, coords_expected, atol=2, sort=True)
+
+
+@pytest.mark.validation
+def test_image_peak_detection():
+    """2D peak detection unit test"""
+    data, coords_expected = get_peak2d_data(multi=False)
+    obj = sigima_.obj.create_image("peak2d_unit_test", data=data)
+    param = sigima_.param.Peak2DDetectionParam()
+    df = sigima_image.peak_detection(obj, param).to_dataframe()
+    coords = df.to_numpy(int)
+    assert coords.shape == coords_expected.shape, (
+        f"Expected {coords_expected.shape[0]} peaks, got {coords.shape[0]}"
+    )
+    # Absolute tolerance is set to 2 pixels, as coordinates are in pixel units
+    # and the algorithm may detect peaks at slightly different pixel locations
+    check_array_result(
+        "Peak coords (comp.)", coords, coords_expected, atol=2, sort=True
+    )
+
+
+@pytest.mark.gui
+def test_peak2d_interactive():
+    """2D peak detection interactive test"""
+    data, _coords = get_peak2d_data(multi=False)
+    coords = exec_image_peak_detection_func(data)
+
+    # pylint: disable=import-outside-toplevel
+    from guidata.qthelpers import qt_app_context
+
+    with qt_app_context():
+        view_image_peak_detection(data, coords)
+
+
+if __name__ == "__main__":
+    test_peak2d_unit()
+    test_image_peak_detection()
+    test_peak2d_interactive()

…ts/features/images/peak2d_limits_unit.py …_tests/images/peak2d_limits_unit_test.pycdl/tests/features/images/peak2d_limits_unit.py renamed to cdl/tests/sigima_tests/images/peak2d_limits_unit_test.py cdl/tests/features/images/peak2d_limits_unit.py renamed to cdl/tests/sigima_tests/images/peak2d_limits_unit_test.py

@@ -37,7 +37,6 @@
 
 # pylint: disable=invalid-name  # Allows short reference names like x, y, ...
 # pylint: disable=duplicate-code
-# guitest: show
 
 from __future__ import annotations