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

datalab/tests/features/common/auto_analysis_recompute_unit_test.py

@@ -0,0 +1,240 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Unit test for automatic recomputation of 1-to-0 analysis operations.
+
+This test verifies that analysis results (like centroid) are automatically updated
+when data changes through various methods:
+- ROI modifications (adding, deleting ROIs)
+- Data transformations via recompute_1_to_1 (modifying processing parameters)
+
+The tests create a Gaussian image, compute its centroid, then verify that:
+1. The centroid changes when a ROI is added to restrict the calculation region
+2. Two centroid rows are generated when two ROIs are added
+3. One centroid row remains after deleting the first ROI
+4. The centroid returns to the original value when all ROIs are deleted
+5. The centroid is recomputed when processing parameters are modified
+"""
+
+# guitest: show
+
+from __future__ import annotations
+
+import numpy as np
+from sigima.objects import Gauss2DParam, create_image_from_param, create_image_roi
+from sigima.params import RotateParam
+
+from datalab.adapters_metadata import GeometryAdapter
+from datalab.config import Conf
+from datalab.tests import datalab_test_app_context
+
+
+def get_centroid_coords(obj) -> tuple[float, float] | None:
+    """Extract centroid coordinates from object metadata.
+
+    Args:
+        obj: Image object with centroid results
+
+    Returns:
+        Tuple (x, y) of centroid coordinates, or None if no centroid found
+    """
+    adapter = GeometryAdapter.from_obj(obj, "centroid")
+    if adapter is not None:
+        print("adapter.result.coords:", adapter.result.coords)
+        return tuple(adapter.result.coords[0])
+    return None
+
+
+def test_analysis_recompute_after_roi_change():
+    """Test automatic recomputation of analysis results when ROI changes."""
+    with datalab_test_app_context(console=False) as win:
+        panel = win.imagepanel
+
+        # Create a 2D Gaussian image in a 200x200 image
+        size = 200
+        param = Gauss2DParam.create(height=size, width=size, sigma=20)
+        img = create_image_from_param(param)
+        panel.add_object(img)
+
+        # Compute centroid on the full image
+        with Conf.proc.show_result_dialog.temp(False):
+            panel.processor.run_feature("centroid")
+        centroid = get_centroid_coords(img)
+        assert centroid is not None, "Centroid should be computed"
+        x0, y0 = centroid
+        print(f"\nInitial centroid (full image): ({x0:.1f}, {y0:.1f})")
+
+        # Step 1: Add ROI (simulating edit_roi_graphically)
+        # Add a rectangular ROI in the upper-left quadrant
+        roi = create_image_roi("rectangle", [25, 25, 50, 50])  # x0, y0, width, height
+        img.roi = roi
+        panel.refresh_plot("selected", update_items=True)
+        # Trigger auto-recompute by simulating ROI modification
+        panel.processor.auto_recompute_analysis(img)
+
+        # Verify centroid was updated
+        centroid = get_centroid_coords(img)
+        assert centroid is not None, "Centroid should still exist after ROI change"
+        x1, y1 = centroid
+        print(f"Centroid after adding ROI (upper-left): ({x1:.1f}, {y1:.1f})")
+        # Centroid should have moved (different from initial)
+        centroid_changed = not (
+            np.isclose(x1, x0, atol=0.1) and np.isclose(y1, y0, atol=0.1)
+        )
+        assert centroid_changed, (
+            f"Centroid should have changed from ({x0:.1f}, {y0:.1f}) "
+            f"to ({x1:.1f}, {y1:.1f})"
+        )
+
+        # Step 2: Add two ROIs at once
+        # Create a multi-ROI object with two rectangular regions
+        roi1 = create_image_roi("rectangle", [25, 25, 50, 50])  # Upper-left
+        roi2 = create_image_roi("rectangle", [150, 150, 40, 40])  # Lower-right
+        roi1.add_roi(roi2)  # Combine both ROIs
+        img.roi = roi1
+        panel.refresh_plot("selected", update_items=True)
+        panel.processor.auto_recompute_analysis(img)
+
+        # Verify centroid now has TWO rows (one for each ROI)
+        adapter = GeometryAdapter.from_obj(img, "centroid")
+        assert adapter is not None, "Centroid adapter should exist"
+        coords = adapter.result.coords
+        print(f"Centroid coords after adding two ROIs:\n{coords}")
+        assert len(coords) == 2, f"Should have 2 centroid rows, got {len(coords)}"
+        x2_roi0, y2_roi0 = coords[0]
+        x2_roi1, y2_roi1 = coords[1]
+        print(
+            f"Centroid ROI 0 (upper-left): ({x2_roi0:.1f}, {y2_roi0:.1f}), "
+            f"ROI 1 (lower-right): ({x2_roi1:.1f}, {y2_roi1:.1f})"
+        )
+
+        # Step 3: Delete the first ROI using delete_single_roi
+        panel.processor.delete_single_roi(roi_index=0)
+
+        # Verify centroid now has ONE row (for the remaining ROI)
+        adapter = GeometryAdapter.from_obj(img, "centroid")
+        assert adapter is not None, "Centroid adapter should exist after ROI deletion"
+        coords = adapter.result.coords
+        print(f"Centroid coords after deleting first ROI:\n{coords}")
+        assert len(coords) == 1, f"Should have 1 centroid row, got {len(coords)}"
+        x3, y3 = coords[0]
+        print(f"Centroid after deleting first ROI: ({x3:.1f}, {y3:.1f})")
+        # The remaining ROI should be the second one (lower-right), so centroid should
+        # be close to what was previously in ROI 1
+        assert np.isclose(x3, x2_roi1, atol=1.0), (
+            f"X centroid should be close to {x2_roi1:.1f}, got {x3:.1f}"
+        )
+        assert np.isclose(y3, y2_roi1, atol=1.0), (
+            f"Y centroid should be close to {y2_roi1:.1f}, got {y3:.1f}"
+        )
+
+        # Step 4: Delete all remaining ROIs using delete_regions_of_interest
+        panel.processor.delete_regions_of_interest()
+
+        # Verify centroid was updated back to original
+        centroid = get_centroid_coords(img)
+        assert centroid is not None, "Centroid should exist after deleting all ROIs"
+        x4, y4 = centroid
+        print(f"Centroid after delete_regions_of_interest: ({x4:.1f}, {y4:.1f})")
+        # Should return to original centroid of full image
+        assert np.isclose(x4, x0, atol=1.0), (
+            f"X centroid should return to {x0:.1f}, got {x4:.1f}"
+        )
+        assert np.isclose(y4, y0, atol=1.0), (
+            f"Y centroid should return to {y0:.1f}, got {y4:.1f}"
+        )
+
+        print("\n✓ All ROI auto-recompute tests passed!")
+
+
+def test_analysis_recompute_after_recompute_1_to_1():
+    """Test automatic recomputation of analysis after processing parameter changes."""
+    with datalab_test_app_context(console=False) as win:
+        panel = win.imagepanel
+
+        # Create a Gaussian image offset from center
+        size = 200
+        # In Gauss2DParam, x0 and y0 are the center coordinates with Xmin=-10.0,
+        # Ymin=-10.0, Xmax=10.0, Ymax=10.0 by default.
+        # The centroid position should be at (49.75, 99.5).
+        # After a 45° rotation, it should move closer to (64.32, 134.68).
+        # Or after a 90° rotation, it should move to (99.5, 149.2).
+        param = Gauss2DParam.create(height=size, width=size, x0=-5.0)
+        img = create_image_from_param(param)
+        panel.add_object(img)
+
+        # Apply a rotation transformation with 45° angle
+        rot_param = RotateParam.create(angle=45.0)
+        with Conf.proc.show_result_dialog.temp(False):
+            panel.processor.run_feature("rotate", rot_param)
+
+        # Get the rotated image
+        img_rotated = panel.objview.get_sel_objects()[0]
+        print(f"\nRotated image title: {img_rotated.title}")
+
+        # Compute centroid on the rotated image
+        with Conf.proc.show_result_dialog.temp(False):
+            panel.processor.run_feature("centroid")
+
+        # Get initial centroid (after 45° rotation)
+        centroid = get_centroid_coords(img_rotated)
+        assert centroid is not None, "Centroid should be computed"
+        x0, y0 = centroid
+        print(f"Initial centroid (45° rotation): ({x0:.1f}, {y0:.1f})")
+        expected_x0 = 64.32
+        expected_y0 = 134.68
+        assert np.isclose(x0, expected_x0, atol=0.2), (
+            f"X centroid should be near {expected_x0:.1f}, got {x0:.1f}"
+        )
+        assert np.isclose(y0, expected_y0, atol=0.2), (
+            f"Y centroid should be near {expected_y0:.1f}, got {y0:.1f}"
+        )
+
+        # Now modify the rotation angle to 90° via the Processing tab
+        # The rotated object is already selected, just ensure we're accessing it
+        panel.objview.select_objects([img_rotated])
+
+        # Get the processing parameter editor and change the angle
+        assert panel.objprop.processing_param_editor is not None
+        editor = panel.objprop.processing_param_editor
+        editor.dataset.angle = 90.0  # Change from 45° to 90°
+
+        # Apply the modified parameters (this triggers recompute_1_to_1)
+        report = panel.objprop.apply_processing_parameters(interactive=False)
+
+        assert report.success, f"Recompute failed: {report.message}"
+        print("Processing parameters recomputed with new angle (90°)")
+
+        # Verify centroid was automatically recomputed
+        centroid = get_centroid_coords(img_rotated)
+        assert centroid is not None, "Centroid should still exist after recompute"
+        x1, y1 = centroid
+        print(f"Centroid after recompute (90° rotation): ({x1:.1f}, {y1:.1f})")
+
+        # After 90° rotation: the Gaussian blob that was at upper-right (after 45°)
+        # moves toward the center-right area
+        # Empirical measurements show approximately (99.5, 149.2)
+        expected_x1 = 99.5
+        expected_y1 = 149.2
+        assert np.isclose(x1, expected_x1, atol=0.2), (
+            f"X centroid should be near {expected_x1:.1f}, got {x1:.1f}"
+        )
+        assert np.isclose(y1, expected_y1, atol=0.2), (
+            f"Y centroid should be near {expected_y1:.1f}, got {y1:.1f}"
+        )
+
+        # Most importantly, verify the centroid changed from 90° rotation
+        centroid_changed = not (
+            np.isclose(x1, x0, atol=5.0) and np.isclose(y1, y0, atol=5.0)
+        )
+        assert centroid_changed, (
+            f"Centroid should have changed from ({x0:.1f}, {y0:.1f}) "
+            f"to ({x1:.1f}, {y1:.1f}) after changing rotation angle"
+        )
+
+        print("\n✓ Recompute_1_to_1 auto-analysis test passed!")
+
+
+if __name__ == "__main__":
+    test_analysis_recompute_after_roi_change()
+    test_analysis_recompute_after_recompute_1_to_1()

datalab/tests/features/common/createobject_unit_test.py

@@ -0,0 +1,50 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+New signal/image test
+
+Testing GUI functions related to signal/image creation.
+"""
+
+# pylint: disable=invalid-name  # Allows short reference names like x, y, ...
+# pylint: disable=duplicate-code
+# guitest: show
+
+from __future__ import annotations
+
+import sigima.objects
+from guidata.qthelpers import qt_app_context
+from sigima.tests.vistools import view_curves, view_images
+
+from datalab.env import execenv
+from datalab.gui.newobject import create_image_gui, create_signal_gui
+
+
+def test_new_signal() -> None:
+    """Test new signal feature"""
+    edit = not execenv.unattended
+    with qt_app_context():
+        signal = create_signal_gui(None, edit=edit)
+        if signal is not None:
+            data = (signal.x, signal.y)
+            view_curves([data], name=test_new_signal.__name__, title=signal.title)
+
+
+def test_new_image() -> None:
+    """Test new image feature"""
+    # Test with no input parameter
+    edit = not execenv.unattended
+    with qt_app_context():
+        image = create_image_gui(None, edit=edit)
+        if image is not None:
+            view_images(image.data, name=test_new_image.__name__, title=image.title)
+        # Test with parametered 2D-Gaussian
+        param = sigima.objects.Gauss2DParam.create(x0=3, y0=3, sigma=5)
+        image = create_image_gui(param, edit=edit)
+        if image is not None:
+            view_images(image.data, name=test_new_image.__name__, title=image.title)
+
+
+if __name__ == "__main__":
+    test_new_signal()
+    test_new_image()

datalab/tests/features/common/geometry_results_app_test.py

@@ -0,0 +1,135 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Result shapes application test:
+
+  - Create an image with metadata shapes and ROI
+  - Further tests to be done manually: check if copy/paste metadata works
+"""
+
+# guitest: show
+
+from __future__ import annotations
+
+import pandas as pd
+import sigima.objects
+import sigima.params
+from sigima.tests import data as test_data
+
+from datalab.adapters_metadata import GeometryAdapter
+from datalab.config import Conf
+from datalab.tests import datalab_test_app_context
+
+
+def __create_image_with_geometry_results() -> sigima.objects.ImageObj:
+    """Create test image with geometry results"""
+    param = sigima.objects.Gauss2DParam.create(
+        height=600,
+        width=600,
+        title="Test image (with geometry results)",
+        dtype=sigima.objects.ImageDatatypes.UINT16,
+        x0=2,
+        y0=3,
+    )
+    image = sigima.objects.create_image_from_param(param)
+    for geometry in test_data.generate_geometry_results():
+        GeometryAdapter(geometry).add_to(image)
+    return image
+
+
+def __check_geometry_results_merge(
+    obj1: sigima.objects.SignalObj | sigima.objects.ImageObj,
+    obj2: sigima.objects.SignalObj | sigima.objects.ImageObj,
+) -> None:
+    """Check if geometry results merge properly: the scenario is to duplicate an object,
+    then compute average. We thus have to check if the second object (average) has the
+    expected geometry results (i.e. twice the number of geometry results of the original
+    object for each geometry result type).
+
+    Args:
+        obj1: Original object
+        obj2: Merged object
+    """
+    rsl1, rsl2 = (
+        list(GeometryAdapter.iterate_from_obj(obj1)),
+        list(GeometryAdapter.iterate_from_obj(obj2)),
+    )
+    assert len(rsl2) == len(rsl1), (
+        f"Result shapes length mismatch: {len(rsl1)} != {len(rsl2)}"
+    )
+    for rs1, rs2 in zip(rsl1, rsl2):
+        df1 = rs1.to_dataframe()
+        df2 = rs2.to_dataframe()
+        assert len(df1) * 2 == len(df2), (
+            f"Result shape dataframe length mismatch: {len(df1)} * 2 != {len(df2)}"
+        )
+        # Check that the second dataframe contains double the data
+        # (original geometry result concatenated with itself)
+        coord_cols = [col for col in df1.columns if col != "roi_index"]
+        df1_doubled = pd.concat([df1, df1], ignore_index=True)
+        pd.testing.assert_frame_equal(
+            df2[coord_cols].sort_values(coord_cols[0]).reset_index(drop=True),
+            df1_doubled[coord_cols].sort_values(coord_cols[0]).reset_index(drop=True),
+        )
+
+
+def __check_roi_merge(
+    obj1: sigima.objects.SignalObj | sigima.objects.ImageObj,
+    obj2: sigima.objects.SignalObj | sigima.objects.ImageObj,
+) -> None:
+    """Check if ROI merge properly: the scenario is to duplicate an object,
+    then compute average. We thus have to check if the second object (average) has the
+    expected ROI (i.e. the union of the original object's ROI).
+
+    Args:
+        obj1: Original object
+        obj2: Merged object
+    """
+    roi1 = obj1.roi
+    roi2 = obj2.roi
+    for single_roi2 in roi2:
+        assert roi1.get_single_roi(0) == single_roi2
+
+
+def test_geometry_results() -> None:
+    """Geometry results test"""
+    with datalab_test_app_context() as win:
+        obj1 = test_data.create_sincos_image()
+        obj2 = __create_image_with_geometry_results()
+        obj2.roi = sigima.objects.create_image_roi("rectangle", [10, 10, 50, 400])
+        panel = win.signalpanel
+        for noised in (False, True):
+            sig = test_data.create_noisy_signal(noised=noised)
+            panel.add_object(sig)
+            panel.processor.run_feature("fwhm", sigima.params.FWHMParam())
+            panel.processor.run_feature("fw1e2")
+        panel.objview.select_objects((1, 2))
+        panel.show_results()
+        panel.plot_results()
+        win.set_current_panel("image")
+        panel = win.imagepanel
+        for obj in (obj1, obj2):
+            panel.add_object(obj)
+        panel.show_results()
+        panel.plot_results()
+        for keep_results in (False, True):
+            with Conf.proc.keep_results.temp(keep_results):
+                # Test merging result shapes (duplicate obj, then compute average):
+                for panel in (win.signalpanel, win.imagepanel):
+                    panel.objview.select_objects((2,))
+                    panel.duplicate_object()
+                    panel.objview.select_objects((2, len(panel)))
+                    panel.processor.run_feature("average")
+                    last_obj = panel[len(panel)]
+                    if keep_results:
+                        __check_geometry_results_merge(panel[2], last_obj)
+                        if panel is win.imagepanel:
+                            __check_roi_merge(panel[2], last_obj)
+                    else:
+                        assert (
+                            len(list(GeometryAdapter.iterate_from_obj(last_obj))) == 0
+                        )
+
+
+if __name__ == "__main__":
+    test_geometry_results()