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

datalab/tests/features/image/geometry_transform_unit_test.py

@@ -0,0 +1,396 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""Unit test for geometry transformation operations."""
+
+from __future__ import annotations
+
+from typing import Callable
+
+import numpy as np
+import sigima.objects as sio
+import sigima.params as sip
+import sigima.proc.image as sipi
+from sigima.tests import data as test_data
+
+from datalab.adapters_metadata.geometry_adapter import GeometryAdapter
+from datalab.gui.processor.image import apply_geometry_transform
+from datalab.tests import datalab_test_app_context
+
+
+def __create_test_image() -> sio.ImageObj:
+    """Create a test image with geometry results for testing."""
+    param = sio.Gauss2DParam.create(
+        height=600,
+        width=600,
+        x0=2.5,
+        y0=7.5,
+        title="Test image (with geometry results)",
+        dtype=sio.ImageDatatypes.UINT16,
+    )
+    obj = sio.create_image_from_param(param)
+    for geometry in test_data.generate_geometry_results():
+        GeometryAdapter(geometry).add_to(obj)
+    obj.roi = sio.create_image_roi("rectangle", [10, 10, 50, 400])
+    return obj
+
+
+def __get_geometries(obj: sio.ImageObj) -> list[sio.GeometryResult]:
+    """Get geometries from an image object."""
+    return [ga.result for ga in GeometryAdapter.iterate_from_obj(obj)]
+
+
+def __get_expected_geometry_result(
+    orig_geom: sio.GeometryResult, operation: str
+) -> sio.GeometryResult:
+    """Get expected geometry result for a given operation.
+
+    Args:
+        orig_geom: Original geometry result
+        operation: Operation name (rotate90, rotate270, etc.)
+
+    Returns:
+        Expected geometry result after transformation
+    """
+    # For image transformations, rotations should be around the image center
+    # (300, 300 for our 600x600 test image)
+    xc, yc = (300.0, 300.0)
+
+    if operation == "rotate90":
+        exp_geom = sipi.transformer.rotate(orig_geom, -np.pi / 2, (xc, yc))
+    elif operation == "rotate270":
+        exp_geom = sipi.transformer.rotate(orig_geom, np.pi / 2, (xc, yc))
+    elif operation == "fliph":
+        exp_geom = sipi.transformer.fliph(orig_geom, xc)
+    elif operation == "flipv":
+        exp_geom = sipi.transformer.flipv(orig_geom, yc)
+    elif operation == "transpose":
+        exp_geom = sipi.transformer.transpose(orig_geom)
+    elif operation == "resize":
+        # Resize changes pixel resolution but keeps physical coordinates unchanged
+        exp_geom = orig_geom
+    elif operation == "binning":
+        # Binning changes pixel resolution but keeps physical coordinates unchanged
+        exp_geom = orig_geom
+    else:
+        raise ValueError(f"Unknown operation: {operation}")
+    return exp_geom
+
+
+def __validate_geometry_transformation(
+    tr_geometries: list[sio.GeometryResult],
+    or_geometries: list[sio.GeometryResult],
+    operation: str,
+    test_context: str = "geometry",
+) -> None:
+    """Validate that geometry transformation was applied correctly.
+
+    Args:
+        tr_geometries: List of transformed geometry results
+        or_geometries: List of original geometry results
+        operation: Operation name (rotate90, rotate270, etc.)
+        test_context: Context string for error messages (e.g., "App", "Unit")
+    """
+    for i, tr_geom in enumerate(tr_geometries):
+        original_geom = or_geometries[i]
+        expected_geom = __get_expected_geometry_result(original_geom, operation)
+
+        # Compare the actual transformation result with expected
+        np.testing.assert_allclose(
+            tr_geom.coords,
+            expected_geom.coords,
+            rtol=1e-10,
+            err_msg=f"{test_context} geometry result {i} "
+            f"({tr_geom.title}) coordinates do not match expected for {operation}. "
+            f"Got: {tr_geom.coords}, Expected: {expected_geom.coords}",
+        )
+
+        # Verify other properties are preserved
+        assert tr_geom.title == expected_geom.title, (
+            f"Title should be preserved for geometry {i} in {operation}"
+        )
+        assert tr_geom.kind == expected_geom.kind, (
+            f"Kind should be preserved for geometry {i} in {operation}"
+        )
+        np.testing.assert_array_equal(
+            tr_geom.roi_indices,
+            expected_geom.roi_indices,
+            err_msg=f"ROI indices should be preserved for geometry {i} in {operation}",
+        )
+
+
+def __validate_basic_transformation(tr_obj: sio.ImageObj, or_obj: sio.ImageObj) -> None:
+    """Validate basic transformation requirements.
+
+    Args:
+        tr_obj: The transformed image object
+        or_obj: The original image object
+    """
+    assert tr_obj is not or_obj, "Transformation should create a new object"
+    assert len(tr_obj.metadata) == len(or_obj.metadata), (
+        "Number of geometry results should be preserved"
+    )
+
+
+def __validate_roi_transformation(
+    tr_obj: sio.ImageObj,
+    or_obj: sio.ImageObj,
+    operation: str,
+) -> None:
+    """Validate that ROI is properly transformed.
+
+    Args:
+        tr_obj: The transformed image object
+        or_obj: Original image object
+        operation: Operation name for expected transformation
+    """
+    tr_roi = tr_obj.roi
+    assert tr_roi is not None, "ROI should not be removed after transformation"
+    assert len(tr_roi.single_rois) == len(or_obj.roi.single_rois), (
+        "Number of ROI objects should be preserved"
+    )
+    # Validate that the ROI coordinates were properly transformed
+    for i, roi in enumerate(tr_roi.single_rois):
+        # Temporary transform the ROI into a geometry result:
+        or_roi = or_obj.roi.get_single_roi(i)
+        temp_geom = sio.GeometryResult(
+            "temp_geom",
+            sio.KindShape.RECTANGLE,
+            coords=np.asarray([or_roi.get_physical_coords(or_obj)]),
+        )
+        expected_geom = __get_expected_geometry_result(temp_geom, operation)
+        exp_coords = expected_geom.coords[0]
+        np.testing.assert_allclose(
+            roi.get_physical_coords(tr_obj),
+            exp_coords,
+            rtol=1e-10,
+            atol=1e-10,
+            err_msg=f"ROI {i} coordinates do not match expected for {operation}.",
+        )
+
+
+def __validate_image_data_transformation(
+    tr_obj: sio.ImageObj, or_obj: sio.ImageObj, operation: str
+) -> None:
+    """Validate that image data was properly transformed.
+
+    Args:
+        tr_obj: The transformed image object
+        or_obj: Original image object
+        operation: Operation name for expected transformation
+    """
+    if operation == "rotate90":
+        expected_data = np.rot90(or_obj.data)
+    elif operation == "rotate270":
+        expected_data = np.rot90(or_obj.data, k=-1)
+    elif operation == "fliph":
+        expected_data = np.fliplr(or_obj.data)
+    elif operation == "flipv":
+        expected_data = np.flipud(or_obj.data)
+    elif operation == "transpose":
+        expected_data = np.transpose(or_obj.data)
+    elif operation in ("resize", "binning"):
+        # These operations are more complex and use Sigima's functions
+        # We'll just verify the operation was applied (shape may change)
+        return
+    else:
+        raise ValueError(f"Unknown operation for data validation: {operation}")
+
+    np.testing.assert_array_equal(
+        tr_obj.data,
+        expected_data,
+        err_msg=f"Image data not properly transformed for {operation}",
+    )
+
+
+# =============================================================================
+# Unit Tests
+# =============================================================================
+
+
+def __create_unit_test(
+    operation: str,
+    param_creator: Callable[
+        [], sip.BinningParam | sip.ResizeParam | sip.RotateParam
+    ] = None,
+) -> Callable[[], None]:
+    """Create a unit test function for a geometry transformation operation.
+
+    Args:
+        operation: Operation name (e.g., "rotate90", "fliph")
+        param_creator: Function to create parameter object, if needed
+
+    Returns:
+        Test function
+    """
+
+    def test_func() -> None:
+        """Test geometry transformation at unit level."""
+        obj = __create_test_image()
+        or_geometries = __get_geometries(obj)  # Store original data for comparison
+
+        # Apply transformation (same as DataLab processor does)
+        param = param_creator() if param_creator else None
+        compfunc = getattr(sipi, operation, None)
+        if compfunc is None:
+            raise ValueError(f"Unknown operation: {operation}")
+        if param is None:
+            tr_obj = compfunc(obj)
+        else:
+            tr_obj = compfunc(obj, param)
+
+        # Apply the geometry transformation to the result
+        # (skip geometry transformation for resize and binning as they preserve
+        # physical coordinates)
+        if operation not in ["resize", "binning"]:
+            apply_geometry_transform(tr_obj, operation)
+
+        # Validate basic transformation requirements
+        __validate_basic_transformation(tr_obj, obj)
+
+        # Validate geometry transformation
+        tr_geometries = __get_geometries(tr_obj)
+        __validate_geometry_transformation(
+            tr_geometries, or_geometries, operation, "Unit"
+        )
+
+        # Validate ROI transformation (only for simple operations)
+        simple_ops = ["fliph", "flipv", "transpose"]
+        if operation in simple_ops:
+            __validate_roi_transformation(tr_obj, obj, operation)
+
+    # Set proper function name and docstring
+    test_func.__name__ = f"test_geometry_transform_{operation}_unit"
+    test_func.__doc__ = (
+        f"Test geometry transformation for {operation} at unit level.\n\n"
+        f"This test verifies that the DataLab geometry transformation properly "
+        f"applies Sigima's {operation} function to geometry results."
+    )
+
+    return test_func
+
+
+def __create_app_test(
+    operation: str,
+    param_creator: Callable[
+        [], sip.BinningParam | sip.ResizeParam | sip.RotateParam
+    ] = None,
+) -> Callable[[], None]:
+    """Create an app test function for a geometry transformation operation.
+
+    Args:
+        operation: Operation name (e.g., "rotate90", "fliph")
+        param_creator: Function to create parameter object, if needed
+
+    Returns:
+        Test function
+    """
+
+    def test_func() -> None:
+        """Test operation at application level through direct processing."""
+        with datalab_test_app_context() as win:
+            panel = win.imagepanel
+            proc = panel.processor
+
+            obj = __create_test_image()
+            panel.add_object(obj)
+            panel.objview.select_objects((1,))
+
+            # Apply operation using app workflow
+            param = param_creator() if param_creator else None
+            if param is None:
+                proc.run_feature(operation)
+            else:
+                proc.run_feature(operation, param=param)
+            tr_obj = panel[len(panel)]
+
+            # # Validate basic transformation requirements
+            # __validate_basic_transformation(tr_obj, obj)
+
+            # # Validate geometry transformation
+            # tr_geometries = __get_geometries(tr_obj)
+            # __validate_geometry_transformation(
+            #     tr_geometries, or_geometries, operation, "App", param
+            # )
+
+        # Verify that image data is properly transformed
+        __validate_image_data_transformation(tr_obj, obj, operation)
+
+        # For simple transformations, validate ROI transformation
+        # Skip ROI validation for rotation operations due to inconsistency in Sigima
+        # library between image data rotation (around image center) and ROI coordinate
+        # rotation (around ROI center)
+        simple_ops = ["fliph", "flipv", "transpose"]
+        if operation in simple_ops:
+            __validate_roi_transformation(tr_obj, obj, operation)
+
+    # Set proper function name and docstring
+    test_func.__name__ = f"test_geometry_transform_{operation}_app"
+    test_func.__doc__ = (
+        f"Test {operation} operation at application level.\n\n"
+        f"This test verifies the complete transformation workflow including "
+        f"image processing and geometry transformation pipeline."
+    )
+
+    return test_func
+
+
+# =============================================================================
+# Parameter Creators
+# =============================================================================
+
+
+def __resize_param() -> sip.ResizeParam:
+    """Create resize parameter."""
+    return sip.ResizeParam.create(zoom=1.5)
+
+
+def __binning_param() -> sip.BinningParam:
+    """Create binning parameter."""
+    return sip.BinningParam.create(sx=2, sy=3)
+
+
+# =============================================================================
+# Generate Test Functions
+# =============================================================================
+
+# Simple transformations (no parameters)
+test_geometry_transform_rotate90_unit = __create_unit_test("rotate90")
+test_geometry_transform_rotate90_app = __create_app_test("rotate90")
+
+test_geometry_transform_rotate270_unit = __create_unit_test("rotate270")
+test_geometry_transform_rotate270_app = __create_app_test("rotate270")
+
+test_geometry_transform_fliph_unit = __create_unit_test("fliph")
+test_geometry_transform_fliph_app = __create_app_test("fliph")
+
+test_geometry_transform_flipv_unit = __create_unit_test("flipv")
+test_geometry_transform_flipv_app = __create_app_test("flipv")
+
+test_geometry_transform_transpose_unit = __create_unit_test("transpose")
+test_geometry_transform_transpose_app = __create_app_test("transpose")
+
+# Parametric transformations
+test_geometry_transform_resize_unit = __create_unit_test("resize", __resize_param)
+test_geometry_transform_resize_app = __create_app_test("resize", __resize_param)
+
+test_geometry_transform_binning_unit = __create_unit_test("binning", __binning_param)
+test_geometry_transform_binning_app = __create_app_test("binning", __binning_param)
+
+
+if __name__ == "__main__":
+    # test_geometry_transform_rotate90_unit()
+    test_geometry_transform_rotate90_app()
+    test_geometry_transform_rotate270_unit()
+    test_geometry_transform_rotate270_app()
+    test_geometry_transform_fliph_unit()
+    test_geometry_transform_fliph_app()
+    test_geometry_transform_flipv_unit()
+    test_geometry_transform_flipv_app()
+    test_geometry_transform_transpose_unit()
+    test_geometry_transform_transpose_app()
+    test_geometry_transform_resize_unit()
+    test_geometry_transform_resize_app()
+    test_geometry_transform_binning_unit()
+    test_geometry_transform_binning_app()
+    print("✅ All geometry transformation tests passed!")

datalab/tests/features/image/imagetools_app_test.py

@@ -0,0 +1,51 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Image tools application test:
+
+  - Testing `ZAxisLogTool`
+  - Testing `profile_to_signal` function (image cross section -> curve)
+"""
+
+# pylint: disable=invalid-name  # Allows short reference names like x, y, ...
+# guitest: show
+
+import os.path as osp
+
+from plotpy.coords import axes_to_canvas
+from plotpy.tools import CrossSectionTool
+from qtpy import QtCore as QC
+from sigima.objects import NewImageParam
+from sigima.tests.data import create_multigaussian_image
+
+from datalab.gui.docks import profile_to_signal
+from datalab.tests import datalab_test_app_context
+
+
+def test_image_tools_app():
+    """Run image tools test scenario"""
+    with datalab_test_app_context() as win:
+        panel = win.imagepanel
+        newparam = NewImageParam.create(height=200, width=200)
+        ima = create_multigaussian_image(newparam)
+        panel.add_object(ima)
+        panel.set_current_object_title(f"Test image for {osp.basename(__file__)}")
+        plotwidget = panel.plothandler.plotwidget
+        mgr = plotwidget.get_manager()
+        plot = plotwidget.get_plot()
+
+        # === Testing "profile_to_signal" ----------------------------------------------
+        cstool: CrossSectionTool = mgr.get_tool(CrossSectionTool)
+        xcs_panel, ycs_panel = mgr.get_xcs_panel(), mgr.get_ycs_panel()
+        xcs_panel.setVisible(True)
+        ycs_panel.setVisible(True)
+        x, y = newparam.width // 2, newparam.height // 2
+        active_item = plot.get_active_item()
+        pos = QC.QPointF(*axes_to_canvas(active_item, x, y))
+        cstool.add_shape_to_plot(plot, pos, pos)
+        for panel in (xcs_panel, ycs_panel):
+            profile_to_signal(plot, panel)
+
+
+if __name__ == "__main__":
+    test_image_tools_app()

datalab/tests/features/image/imagetools_unit_test.py

@@ -0,0 +1,27 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Image tools test
+
+Simple image dialog for testing all image tools available in DataLab
+"""
+
+# pylint: disable=invalid-name  # Allows short reference names like x, y, ...
+# guitest: show
+
+from guidata.qthelpers import qt_app_context
+from plotpy.builder import make
+from sigima.tests.data import create_noisy_gaussian_image
+from sigima.tests.vistools import view_image_items
+
+
+def test_image_tools_unit():
+    """Image tools test"""
+    with qt_app_context():
+        data = create_noisy_gaussian_image().data
+        items = [make.image(data, interpolation="nearest", eliminate_outliers=2.0)]
+        view_image_items(items)
+
+
+if __name__ == "__main__":
+    test_image_tools_unit()

datalab/tests/features/image/load_app_test.py

@@ -0,0 +1,73 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Load application test: high number of images
+"""
+
+# pylint: disable=invalid-name  # Allows short reference names like x, y, ...
+# guitest: show
+
+from __future__ import annotations
+
+import numpy as np
+import pytest
+import sigima.objects
+import sigima.params
+
+from datalab.env import execenv
+from datalab.tests import datalab_test_app_context
+
+
+def create_random_test_data(
+    size: tuple[int, int] | None = None,
+) -> sigima.objects.ImageObj:
+    """Create a test image, based on a fast algorithm, to be able to generate
+    a high number of images.
+
+    Args:
+        size: Size of the image.
+    """
+    if size is None:
+        size = (2048, 2048)
+    # Create a base image with low frequency shapes:
+    x = np.linspace(-1, 1, size[0])
+    y = np.linspace(-1, 1, size[1])
+    xx, yy = np.meshgrid(x, y)
+    a1, a2, f1, f2 = np.random.rand(4)
+    data = a1 * np.sin(2 * np.pi * xx * (1 + f1 * 0.2)) + a2 * np.cos(
+        2 * np.pi * yy * (1 + f2 * 0.2)
+    )
+    # Add some random noise:
+    data += 0.1 * np.random.randn(*data.shape)
+    image = sigima.objects.create_image("Random test image", data)
+    return image
+
+
+@pytest.mark.skip("This a load test, not a functional test")
+def test_high_number_of_images() -> None:
+    """Run a test with a high number of images."""
+    nb = 30
+    execenv.print("Creating images", end="")
+    images = []
+    for idx in range(nb):
+        execenv.print(".", end="")
+        ima = create_random_test_data()
+        ima.title += f" {idx}"
+        images.append(ima)
+    execenv.print(" done")
+    with datalab_test_app_context() as win:
+        panel = win.imagepanel
+        for ima in images:
+            panel.add_object(ima)
+        panel.objview.select_groups()
+
+        # Comment the two following lines to check if DataLab only shows the last image
+        # when they are all superposed
+        param = sigima.params.GridParam.create(cols=10)
+        panel.processor.distribute_on_grid(param)
+
+        panel.duplicate_object()
+
+
+if __name__ == "__main__":
+    test_high_number_of_images()

datalab/tests/features/image/morph_app_test.py

@@ -0,0 +1,32 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Morphology 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_morphology():
+    """Run morphology 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
+        param = sigima.params.MorphologyParam.create(radius=10)
+        proc.compute_all_morphology(param)
+        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_morphology()

datalab/tests/features/image/offsetcorrection_app_test.py

@@ -0,0 +1,30 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Image offset correction application test
+
+An application test for the image offset correction feature is necessary to ensure
+that the feature works correctly with the GUI and the image processing pipeline, as
+it involves user interaction and a specific dialog for selecting the offset region.
+Experience has shown that this feature can be prone to issues, especially with
+dialog interactions, so a dedicated test is essential to catch any regressions or
+unexpected behavior in the future.
+"""
+
+# 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_offset_correction():
+    """Run offset correction application test scenario"""
+    with datalab_test_app_context() as win:
+        win.imagepanel.add_object(get_test_image("flower.npy"))
+        win.imagepanel.processor.compute_offset_correction()
+
+
+if __name__ == "__main__":
+    test_offset_correction()

datalab/tests/features/image/peak2d_app_test.py

@@ -0,0 +1,53 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+2D peak detection test
+
+Testing the following:
+  - Create a test image with multiple peaks
+  - Compute 2D peak detection and show points on image
+"""
+
+# guitest: show
+
+import sigima.params
+from sigima.tests.data import create_peak_image
+
+from datalab.tests import datalab_test_app_context, take_plotwidget_screenshot
+
+
+def test_peak2d(screenshot: bool = False) -> None:
+    """Run 2D peak detection scenario"""
+    with datalab_test_app_context() as win:
+        panel = win.imagepanel
+        ima = create_peak_image()
+        panel.add_object(ima)
+
+        # Test with ROI creation enabled (default)
+        param = sigima.params.Peak2DDetectionParam.create(create_rois=True)
+        results = panel.processor.compute_peak_detection(param)
+        assert results is not None, "Peak detection should return results"
+
+        # Get the processed image object
+        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(), "ROI should not be empty"
+
+        # Test with ROI creation disabled
+        ima2 = create_peak_image()
+        panel.add_object(ima2)
+        param2 = sigima.params.Peak2DDetectionParam.create(create_rois=False)
+        panel.processor.compute_peak_detection(param2)
+
+        obj2 = panel.objview.get_current_object()
+        assert obj2.roi is None or obj2.roi.is_empty(), (
+            "ROI should not be created when create_rois=False"
+        )
+
+        win.toggle_show_titles(False)
+        if screenshot:
+            take_plotwidget_screenshot(panel, "peak2d_test")
+
+
+if __name__ == "__main__":
+    test_peak2d()