datalab-platform 0.0.1.dev0__py3-none-any.whl → 1.0.0__py3-none-any.whl

datalab/tests/features/image/average_app_test.py

@@ -0,0 +1,46 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Average application test
+========================
+
+The purpose of this test is to check that we can average a set of images without
+overflowing the data type.
+
+This test was written following a regression where the average of 10 images of
+size 256x256 with a Gaussian distribution of values was overflowing the data type
+uint8.
+"""
+
+# pylint: disable=invalid-name  # Allows short reference names like x, y, ...
+# pylint: disable=duplicate-code
+# guitest: show
+
+import numpy as np
+import sigima.objects
+import sigima.tests.data as ctd
+
+from datalab.tests import datalab_test_app_context, helpers
+
+
+def test_image_average() -> None:
+    """Average application test."""
+    with datalab_test_app_context() as win:
+        panel = win.imagepanel
+        N, size = 10, 256
+        dtype = sigima.objects.ImageDatatypes.UINT8
+        p = sigima.objects.NewImageParam.create(height=size, width=size, dtype=dtype)
+        data = ctd.create_2d_gaussian(size, dtype.to_numpy_dtype())
+        for _idx in range(N):
+            obj = sigima.objects.create_image_from_param(p)
+            obj.data = data
+            panel.add_object(obj)
+        panel.objview.select_groups([0])
+        panel.processor.run_feature("average")
+        res_data = panel.objview.get_sel_objects(include_groups=True)[0].data
+    exp_data = np.array(data, dtype=float)
+    helpers.check_array_result("Average", res_data, exp_data)
+
+
+if __name__ == "__main__":
+    test_image_average()

datalab/tests/features/image/background_dialog_test.py

@@ -0,0 +1,70 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Image background dialog unit test.
+"""
+
+# pylint: disable=invalid-name  # Allows short reference names like x, y, ...
+# pylint: disable=duplicate-code
+# guitest: show
+
+from __future__ import annotations
+
+import numpy as np
+import sigima.objects
+import sigima.params
+import sigima.proc.image as sipi
+from guidata.qthelpers import exec_dialog, qt_app_context
+from sigima.tests import vistools
+from sigima.tests.data import create_noisy_gaussian_image
+
+from datalab.env import execenv
+from datalab.widgets.imagebackground import ImageBackgroundDialog
+
+
+def test_image_background_selection() -> None:
+    """Image background selection test."""
+    with qt_app_context():
+        img = create_noisy_gaussian_image()
+        # Switch to non-uniform coordinates to test the background dialog handling:
+        xcoords = np.linspace(0, 10, img.data.shape[1])
+        img.set_coords(xcoords, 0.02 * xcoords**3)
+        dlg = ImageBackgroundDialog(img)
+        dlg.resize(640, 480)
+        dlg.setObjectName(dlg.objectName() + "_00")  # to avoid timestamp suffix
+        exec_dialog(dlg)
+        if execenv.unattended:
+            dlg.test_compute_background()
+        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_noisy_gaussian_image()
+        dlg = ImageBackgroundDialog(i1)
+        ok = exec_dialog(dlg)
+        if ok:
+            if execenv.unattended:
+                dlg.test_compute_background()
+            param = sigima.objects.ROI2DParam()
+            # pylint: disable=unbalanced-tuple-unpacking
+            ix0, iy0, ix1, iy1 = i1.physical_to_indices(dlg.get_rect_coords())
+            param.x0, param.y0, param.dx, param.dy = ix0, iy0, ix1 - ix0, iy1 - iy0
+            i2 = sipi.offset_correction(i1, param)
+            i3 = sipi.clip(i2, sigima.params.ClipParam.create(lower=0))
+            vistools.view_images_side_by_side(
+                [i1, i3],
+                titles=["Original image", "Corrected image"],
+                title="Image offset correction and thresholding",
+            )
+
+
+if __name__ == "__main__":
+    test_image_background_selection()
+    test_image_offset_correction_with_background_dialog()

datalab/tests/features/image/blobs_app_test.py

@@ -0,0 +1,50 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Blob detection application test
+"""
+
+# pylint: disable=invalid-name  # Allows short reference names like x, y, ...
+# guitest: show
+
+import sigima.params
+from sigima.objects import create_image
+from sigima.tests.data import get_test_image
+
+from datalab.adapters_plotpy import create_adapter_from_object
+from datalab.tests import datalab_test_app_context, skip_if_opencv_missing
+
+
+def test_blobs():
+    """Run blob detection application test scenario"""
+    with datalab_test_app_context() as win:
+        panel = win.imagepanel
+        proc = panel.processor
+        data = get_test_image("flower.npy").data
+
+        # Testing blob detection
+        # ======================
+        for paramclass, compute_method, name in (
+            (sigima.params.BlobDOGParam, "blob_dog", "BlobDOG"),
+            (sigima.params.BlobDOHParam, "blob_doh", "BlobDOH"),
+            (sigima.params.BlobLOGParam, "blob_log", "BlobLOG"),
+            (sigima.params.BlobOpenCVParam, "blob_opencv", "BlobOpenCV"),
+        ):
+            param = paramclass()
+            param.min_sigma = 10.0
+            param.max_sigma = 30.0
+            image = create_image(name, data)
+            create_adapter_from_object(image).add_label_with_title()
+            panel.add_object(image)
+            with skip_if_opencv_missing():
+                proc.run_feature(compute_method, param)
+
+        # Testing distribute_on_grid and reset_positions
+        # ==============================================
+        panel.objview.selectAll()
+        param = sigima.params.GridParam.create(cols=2, colspac=10, rowspac=10)
+        proc.distribute_on_grid(param)
+
+
+if __name__ == "__main__":
+    test_blobs()

datalab/tests/features/image/contour_app_test.py

@@ -0,0 +1,42 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Contour finding application test
+"""
+
+# pylint: disable=invalid-name  # Allows short reference names like x, y, ...
+# guitest: show
+
+import sigima.enums
+import sigima.params
+from sigima.objects import NewImageParam
+from sigima.tests.data import create_multigaussian_image
+
+from datalab.env import execenv
+from datalab.tests import datalab_test_app_context, take_plotwidget_screenshot
+from datalab.tests.features.image.roi_app_test import create_test_image_with_roi
+
+
+def test_contour_app():
+    """Run contour finding application test scenario"""
+    newparam = NewImageParam.create(height=200, width=200)
+    with datalab_test_app_context() as win:
+        panel = win.imagepanel
+        for shape in sigima.enums.ContourShape:
+            ima1 = create_multigaussian_image(newparam)
+            ima1.set_metadata_option("colormap", "gray")
+            panel.add_object(ima1)
+            param = sigima.params.ContourShapeParam.create(shape=shape)
+            panel.processor.run_feature("contour_shape", param)
+            take_plotwidget_screenshot(panel, "contour_test")
+            ima2 = create_test_image_with_roi(newparam)
+            ima2.set_metadata_option("colormap", "gray")
+            panel.add_object(ima2)
+            panel.processor.edit_roi_graphically()
+            panel.processor.run_feature("contour_shape", param)
+            if not execenv.unattended:
+                break
+
+
+if __name__ == "__main__":
+    test_contour_app()

datalab/tests/features/image/contour_fabryperot_app_test.py

@@ -0,0 +1,51 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Contour finding application test with Fabry-Perot images
+"""
+
+# pylint: disable=invalid-name  # Allows short reference names like x, y, ...
+# guitest: show
+
+import sigima.enums
+import sigima.objects
+import sigima.params
+from sigima.tests.data import get_test_image
+
+from datalab.tests import datalab_test_app_context, take_plotwidget_screenshot
+
+
+def test_contour_app() -> None:
+    """Run contour finding application test scenario"""
+    with datalab_test_app_context() as win:
+        panel = win.imagepanel
+
+        shape = sigima.enums.ContourShape.CIRCLE
+
+        ima1 = get_test_image("fabry-perot1.jpg")
+        ima1.set_metadata_option("colormap", "gray")
+        xc, yc, r = 601.0, 556.0, 457.0
+        roi = sigima.objects.create_image_roi("circle", [xc, yc, r])
+        ima1.roi = roi
+        panel.add_object(ima1)
+        param = sigima.params.ContourShapeParam.create(shape=shape)
+        panel.processor.run_feature("contour_shape", param)
+        take_plotwidget_screenshot(panel, "contour_fabryperot_test")
+
+        ima2 = get_test_image("fabry-perot2.jpg")
+        ima2.set_metadata_option("colormap", "gray")
+        ima2.roi = roi
+        panel.add_object(ima2)
+        panel.processor.run_feature("contour_shape", param)
+
+        param = sigima.params.LineProfileParam.create(direction="horizontal", row=554)
+        panel.processor.run_feature("line_profile", param)
+
+        param = sigima.params.AverageProfileParam.create(
+            direction="horizontal", row1=550, row2=560
+        )
+        panel.processor.run_feature("average_profile", param)
+
+
+if __name__ == "__main__":
+    test_contour_app()

datalab/tests/features/image/denoise_app_test.py

@@ -0,0 +1,31 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Denoise processing application test
+"""
+
+# pylint: disable=invalid-name  # Allows short reference names like x, y, ...
+# guitest: show
+
+import sigima.params
+from sigima.tests.data import get_test_image
+
+from datalab.tests import datalab_test_app_context
+
+
+def test_denoise():
+    """Run denoise application test scenario"""
+    with datalab_test_app_context() as win:
+        win.showMaximized()
+        panel = win.imagepanel
+        panel.add_object(get_test_image("flower.npy"))
+        proc = panel.processor
+        proc.compute_all_denoise()
+        panel.objview.select_groups()
+        param = sigima.params.GridParam.create(cols=3)
+        proc.distribute_on_grid(param)
+        panel.add_label_with_title()
+
+
+if __name__ == "__main__":
+    test_denoise()

datalab/tests/features/image/distribute_on_grid_app_test.py

@@ -0,0 +1,95 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Distribute on grid application test
+"""
+
+# pylint: disable=invalid-name  # Allows short reference names like x, y, ...
+# guitest: show
+
+import numpy as np
+import sigima.params
+from sigima.tests.data import get_test_image
+
+from datalab.env import execenv
+from datalab.tests import datalab_test_app_context
+
+
+def get_image_origin(obj):
+    """Get image origin (x0, y0) handling both uniform and non-uniform coordinates.
+
+    Args:
+        obj: Image object
+
+    Returns:
+        Tuple (x0, y0)
+    """
+    if obj.is_uniform_coords:
+        return obj.x0, obj.y0
+    return obj.xcoords[0], obj.ycoords[0]
+
+
+def test_distribute_on_grid():
+    """Run distribute on grid application test scenario"""
+    with execenv.context(unattended=True):
+        with datalab_test_app_context(console=False) as win:
+            panel = win.imagepanel
+            proc = panel.processor
+            panel.add_object(get_test_image("flower.npy"))
+            proc.compute_all_morphology(sigima.params.MorphologyParam.create(radius=10))
+            panel.objview.select_groups()
+
+            # Distribute on grid
+            params = [
+                sigima.params.GridParam.create(cols=4),
+                sigima.params.GridParam.create(
+                    rows=3, colspac=20, rowspac=20, direction="row"
+                ),
+                sigima.params.GridParam.create(cols=2, colspac=10, rowspac=10),
+            ]
+            origins = []
+            for param in params:
+                proc.distribute_on_grid(param)
+                objs = panel.objview.get_sel_objects(include_groups=True)
+                origins.append([get_image_origin(obj) for obj in objs])
+
+            # Reset positions
+            proc.reset_positions()
+            objs = panel.objview.get_sel_objects(include_groups=True)
+            origins.append([get_image_origin(obj) for obj in objs])
+
+        # Verify results with tolerance for floating point comparisons
+        tol = 1e-10
+
+        # First distribution (cols=4)
+        assert np.allclose(origins[0][0], (0.0, 0.0), atol=tol)
+        assert np.allclose(origins[0][1], (512.0, 0.0), atol=tol)
+        assert np.allclose(origins[0][2], (1024.0, 0.0), atol=tol)
+        assert np.allclose(origins[0][3], (1536.0, 0.0), atol=tol)
+        assert np.allclose(origins[0][4], (0.0, 512.0), atol=tol)
+        assert np.allclose(origins[0][5], (512.0, 512.0), atol=tol)
+        assert np.allclose(origins[0][6], (1024.0, 512.0), atol=tol)
+
+        # Second distribution (rows=3, colspac=20, rowspac=20, direction="row")
+        assert np.allclose(origins[1][0], (0.0, 0.0), atol=tol)
+        assert np.allclose(origins[1][1], (0.0, 532.0), atol=tol)
+        assert np.allclose(origins[1][2], (0.0, 1064.0), atol=tol)
+        assert np.allclose(origins[1][3], (532.0, 0.0), atol=tol)
+        assert np.allclose(origins[1][4], (532.0, 532.0), atol=tol)
+        assert np.allclose(origins[1][5], (532.0, 1064.0), atol=tol)
+
+        # Third distribution (cols=2, colspac=10, rowspac=10)
+        assert np.allclose(origins[2][0], (0.0, 0.0), atol=tol)
+        assert np.allclose(origins[2][1], (522.0, 0.0), atol=tol)
+        assert np.allclose(origins[2][2], (0.0, 522.0), atol=tol)
+        assert np.allclose(origins[2][3], (522.0, 522.0), atol=tol)
+        assert np.allclose(origins[2][4], (0.0, 1044.0), atol=tol)
+        assert np.allclose(origins[2][5], (522.0, 1044.0), atol=tol)
+
+        # After reset, all should be at origin
+        for x0, y0 in origins[3]:
+            assert np.allclose([x0, y0], [0.0, 0.0], atol=tol)
+
+
+if __name__ == "__main__":
+    test_distribute_on_grid()

datalab/tests/features/image/edges_app_test.py

@@ -0,0 +1,31 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Edges processing application test
+"""
+
+# pylint: disable=invalid-name  # Allows short reference names like x, y, ...
+# guitest: show
+
+import sigima.params
+from sigima.tests.data import get_test_image
+
+from datalab.tests import datalab_test_app_context
+
+
+def test_edges():
+    """Run edges processing application test scenario"""
+    with datalab_test_app_context() as win:
+        win.showMaximized()
+        panel = win.imagepanel
+        panel.add_object(get_test_image("flower.npy"))
+        proc = panel.processor
+        proc.compute_all_edges()
+        panel.objview.select_groups()
+        param = sigima.params.GridParam.create(cols=4)
+        proc.distribute_on_grid(param)
+        panel.add_label_with_title()
+
+
+if __name__ == "__main__":
+    test_edges()

datalab/tests/features/image/erase_app_test.py

@@ -0,0 +1,21 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""Image erase application test"""
+
+# pylint: disable=invalid-name  # Allows short reference names like x, y, ...
+# guitest: show
+
+from sigima.tests.data import get_test_image
+
+from datalab.tests import datalab_test_app_context
+
+
+def test_erase():
+    """Run erase application test scenario"""
+    with datalab_test_app_context() as win:
+        win.imagepanel.add_object(get_test_image("flower.npy"))
+        win.imagepanel.processor.compute_erase()
+
+
+if __name__ == "__main__":
+    test_erase()

datalab/tests/features/image/fft2d_app_test.py

@@ -0,0 +1,27 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Image FFT application test.
+"""
+
+# pylint: disable=invalid-name  # Allows short reference names like x, y, ...
+# guitest: show
+
+import sigima.objects
+
+from datalab.tests import datalab_test_app_context
+
+
+def test_fft2d_app() -> None:
+    """FFT application test."""
+    with datalab_test_app_context() as win:
+        panel = win.imagepanel
+        param = sigima.objects.Gauss2DParam.create(width=100, height=100)
+        i1 = sigima.objects.create_image_from_param(param)
+        panel.add_object(i1)
+        panel.processor.run_feature("fft")
+        panel.processor.run_feature("ifft")
+
+
+if __name__ == "__main__":
+    test_fft2d_app()

datalab/tests/features/image/flatfield_app_test.py

@@ -0,0 +1,40 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Flat field test
+
+Testing the following:
+  - Create a gaussian image (raw data)
+  - Create a random noised image (flat data)
+  - Compute the flat field image
+"""
+
+# guitest: show
+
+from sigima.objects import Gauss2DParam, UniformDistribution2DParam
+from sigima.proc.image import FlatFieldParam
+
+from datalab.config import _
+from datalab.tests import datalab_test_app_context
+
+
+def test_flatfield():
+    """Run flat field test scenario"""
+    with datalab_test_app_context() as win:
+        panel = win.imagepanel
+
+        param0 = Gauss2DParam.create(title=_("Raw data (2D-Gaussian)"))
+        ima0 = panel.new_object(param0, edit=False)
+        param1 = UniformDistribution2DParam.create(
+            title=_("Flat data (Uniform random)"), vmax=5
+        )
+        ima1 = panel.new_object(param1, edit=False)
+
+        panel.objview.select_objects([ima0])
+        ffp = FlatFieldParam()
+        ffp.threshold = 80
+        panel.processor.run_feature("flatfield", ima1, ffp)
+
+
+if __name__ == "__main__":
+    test_flatfield()