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

datalab/tests/features/common/reorder_app_test.py

@@ -0,0 +1,75 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Groups/signals/images reorder test:
+
+    - Testing groups/signals reorder (images are not tested but the code is the same)
+    - When executed in unattended mode, the test only covers the "move up" and
+      "move down" actions
+    - When executed in interactive mode, the user has to test the "drag and
+      drop" actions manually
+    - In unattended mode only, we take the opportunity to test other methods of
+      the `ObjectModel` class (e.g. `get_group`, `remove_group`, ...) for maximizing
+      the code coverage
+"""
+
+# guitest: show
+
+from datalab import app
+from datalab.env import execenv
+from datalab.objectmodel import get_uuid
+from datalab.tests import helpers
+from datalab.utils.qthelpers import datalab_app_context
+
+
+def test_reorder():
+    """Run signals/images reorder test scenario"""
+    with datalab_app_context(exec_loop=True):
+        win = app.create(h5files=[helpers.get_test_fnames("reorder*")[0]])
+        panel = win.signalpanel
+        view, model = panel.objview, panel.objmodel
+
+        # Select multiple signals
+        objs = [model.get_object_from_number(idx) for idx in (2, 4, 5, 9)]
+        view.select_objects(objs)
+        # Move up
+        view.move_up()
+        # Check that the order is correct (note: objects 4 and 5 are not affected
+        # by the move up action because they are moved up from the top of their group
+        # to the bottom of the previous group)
+        assert [model.get_number(obj) for obj in objs] == [1, 4, 5, 8]
+        # Move down
+        view.move_down()
+        # Check that the order is correct (note: objects 4 and 5 are not affected
+        # by the move down action because they are moved down from the bottom of their
+        # group to the top of the next group)
+        assert [model.get_number(obj) for obj in objs] == [2, 4, 5, 9]
+
+        # Select multiple groups
+        groups = [model.get_group_from_number(idx) for idx in (2, 3)]
+        view.select_groups(groups)
+        # Move up
+        view.move_up()
+        assert [model.get_number(group) for group in groups] == [1, 2]
+        # Move down
+        view.move_down()
+        assert [model.get_number(group) for group in groups] == [2, 3]
+
+        # Testing other methods of the `ObjectModel` class in unattended mode only
+        if execenv.unattended:
+            # Get group
+            group = model.get_group_from_number(2)
+            assert model.get_number(group) == 2
+            # Get the same group from its uuid
+            group = model.get_group(get_uuid(group))
+            assert model.get_number(group) == 2
+            group = model.get_object_or_group(get_uuid(group))
+            assert model.get_number(group) == 2
+            # Remove group
+            n_groups = len(model.get_groups())
+            model.remove_group(group)
+            assert len(model.get_groups()) == n_groups - 1
+
+
+if __name__ == "__main__":
+    test_reorder()

datalab/tests/features/common/result_deletion_unit_test.py

@@ -0,0 +1,96 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Result deletion unit test
+--------------------------
+
+Test the deletion of analysis results from objects.
+"""
+
+# pylint: disable=invalid-name  # Allows short reference names like x, y, ...
+# guitest: show
+
+from __future__ import annotations
+
+from sigima.objects import Gauss2DParam, create_image_from_param
+from sigima.tests.data import create_paracetamol_signal
+
+from datalab.adapters_metadata import GeometryAdapter, TableAdapter
+from datalab.config import Conf
+from datalab.env import execenv
+from datalab.objectmodel import get_uuid
+from datalab.tests import datalab_test_app_context
+
+
+def test_delete_results_image():
+    """Test deletion of analysis results from images"""
+    with datalab_test_app_context(console=False) as win:
+        execenv.print("Image result deletion test:")
+        panel = win.imagepanel
+
+        # Create a test image
+        param = Gauss2DParam.create(height=200, width=200, sigma=20)
+        img = create_image_from_param(param)
+        panel.add_object(img)
+
+        # Run centroid analysis to create results
+        execenv.print("  Running centroid analysis...")
+        with Conf.proc.show_result_dialog.temp(False):
+            panel.processor.run_feature("centroid")
+
+        # Verify that results exist
+        img_refreshed = panel.objmodel[get_uuid(img)]
+        adapter_before = GeometryAdapter.from_obj(img_refreshed, "centroid")
+        assert adapter_before is not None, (
+            "Centroid result should exist before deletion"
+        )
+        execenv.print("  ✓ Centroid result created")
+
+        # Delete all results
+        execenv.print("  Deleting all results...")
+        panel.objview.select_objects([get_uuid(img)])
+        panel.delete_results()
+
+        # Verify that results were deleted
+        img_after = panel.objmodel[get_uuid(img)]
+        adapter_after = GeometryAdapter.from_obj(img_after, "centroid")
+        assert adapter_after is None, "Centroid result should be deleted"
+        execenv.print("  ✓ Centroid result deleted")
+
+
+def test_delete_results_signal():
+    """Test deletion of analysis results from signals"""
+    with datalab_test_app_context(console=False) as win:
+        execenv.print("Signal result deletion test:")
+        panel = win.signalpanel
+
+        # Create a test signal
+        sig = create_paracetamol_signal()
+        panel.add_object(sig)
+
+        # Run stats analysis to create table results
+        execenv.print("  Running stats analysis...")
+        with Conf.proc.show_result_dialog.temp(False):
+            panel.processor.run_feature("stats")
+
+        # Verify that results exist
+        sig_refreshed = panel.objmodel[get_uuid(sig)]
+        tables_before = list(TableAdapter.iterate_from_obj(sig_refreshed))
+        assert len(tables_before) > 0, "Stats result should exist before deletion"
+        execenv.print("  ✓ Stats result created")
+
+        # Delete all results
+        execenv.print("  Deleting all results...")
+        panel.objview.select_objects([get_uuid(sig)])
+        panel.delete_results()
+
+        # Verify that results were deleted
+        sig_after = panel.objmodel[get_uuid(sig)]
+        tables_after = list(TableAdapter.iterate_from_obj(sig_after))
+        assert len(tables_after) == 0, "Stats result should be deleted"
+        execenv.print("  ✓ Stats result deleted")
+
+
+if __name__ == "__main__":
+    test_delete_results_image()
+    test_delete_results_signal()

datalab/tests/features/common/result_merged_label_unit_test.py

@@ -0,0 +1,154 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Merged result label test:
+
+Test that multiple results are merged into a single label that displays all results.
+
+This test verifies that:
+1. Computing FWHM adds a result to the merged label
+2. Computing FW1e2 adds another result to the same merged label
+3. The merged label contains both results
+4. The merged label is read-only (cannot be deleted to remove individual results)
+5. De-selecting and re-selecting the signal maintains the merged label
+"""
+
+# pylint: disable=invalid-name  # Allows short reference names like x, y, ...
+# guitest: show
+
+import sigima.params
+import sigima.proc.signal as sips
+from sigima.tests.data import create_paracetamol_signal
+
+from datalab.adapters_metadata.geometry_adapter import GeometryAdapter
+from datalab.env import execenv
+from datalab.tests import datalab_test_app_context
+
+
+def test_merged_result_label() -> None:
+    """Test that multiple results are merged into a single label"""
+    with datalab_test_app_context() as win:
+        panel = win.signalpanel
+
+        # Create a Gaussian curve
+        execenv.print("Creating paracetamol signal...")
+        sig = create_paracetamol_signal()
+        panel.add_object(sig)
+        execenv.print(f"  Added signal: {sig.title}")
+
+        # Compute the FWHM (this adds a result to metadata)
+        execenv.print("Computing FWHM...")
+        panel.processor.run_feature(sips.fwhm, sigima.params.FWHMParam())
+
+        # Force refresh to ensure shapes are added
+        panel.plothandler.refresh_plot("selected", force=True)
+
+        # Check that the result metadata exists
+        sig = panel.objview.get_sel_objects()[0]
+        geometry_results_1 = list(GeometryAdapter.iterate_from_obj(sig))
+        execenv.print(f"  Geometry results after FWHM: {len(geometry_results_1)}")
+        assert len(geometry_results_1) == 1, "Should have one geometry result"
+
+        # Get the plot and find the merged result label item
+        plot = panel.plothandler.plot
+        label_items = [item for item in plot.items if hasattr(item, "labelparam")]
+
+        # Find the merged result label - it should be on the plot
+        merged_label = None
+        for item in label_items:
+            if hasattr(item, "is_readonly") and item.is_readonly():
+                merged_label = item
+                break
+
+        assert merged_label is not None, "Should find the merged result label"
+        execenv.print(f"  Found merged result label: {merged_label.title()}")
+
+        # Check that the label is read-only
+        assert merged_label.is_readonly(), "Merged label should be read-only"
+        execenv.print("  ✓ Merged label is read-only")
+
+        # Get the label text to verify it contains FWHM result
+        label_text_1 = merged_label.text_string
+        assert "fwhm" in label_text_1.lower(), "Label should contain FWHM result"
+        execenv.print("  ✓ Label contains FWHM result")
+
+        # Compute FW1e2 (this adds another result to metadata)
+        execenv.print("Computing FW1e2...")
+        panel.processor.run_feature(sips.fw1e2)
+
+        # Check that we now have two results
+        sig = panel.objview.get_sel_objects()[0]
+        geometry_results_2 = list(GeometryAdapter.iterate_from_obj(sig))
+        execenv.print(f"  Geometry results after FW1e2: {len(geometry_results_2)}")
+        assert len(geometry_results_2) == 2, "Should have two geometry results"
+
+        # Verify the merged label now contains both results
+        merged_labels = [
+            item
+            for item in plot.items
+            if hasattr(item, "labelparam")
+            and hasattr(item, "is_readonly")
+            and item.is_readonly()
+        ]
+
+        execenv.print(f"  Merged result labels on plot: {len(merged_labels)}")
+        assert len(merged_labels) == 1, "Should have exactly one merged result label"
+
+        merged_label_2 = merged_labels[0]
+        label_text_2 = merged_label_2.text_string
+        assert "fwhm" in label_text_2.lower(), "Label should contain FWHM result"
+        assert "fw1e2" in label_text_2.lower(), "Label should contain FW1e2 result"
+        assert "<hr>" in label_text_2, "Should contain separator between results"
+        execenv.print("  ✓ Merged label contains both FWHM and FW1e2 results")
+
+        # Create another signal and select it (to deselect the first one)
+        execenv.print("Creating second signal to deselect first...")
+        sig2 = create_paracetamol_signal()
+        sig2.title = "Paracetamol 2"
+        panel.add_object(sig2)
+
+        # Re-select the first signal
+        execenv.print("Re-selecting first signal...")
+        panel.objview.select_objects([1])
+
+        # Check that the merged label still exists and contains both results
+        sig = panel.objview.get_sel_objects()[0]
+        geometry_results_after = list(GeometryAdapter.iterate_from_obj(sig))
+        execenv.print(
+            f"  Geometry results after reselect: {len(geometry_results_after)}"
+        )
+        assert len(geometry_results_after) == 2, (
+            "Should still have two geometry results after re-selection"
+        )
+
+        # Check that the merged label is still present
+        merged_labels_after = [
+            item
+            for item in plot.items
+            if hasattr(item, "labelparam")
+            and hasattr(item, "is_readonly")
+            and item.is_readonly()
+        ]
+
+        execenv.print(
+            f"  Merged result labels on plot after reselect: {len(merged_labels_after)}"
+        )
+        assert len(merged_labels_after) == 1, (
+            "Should still have one merged result label after re-selection"
+        )
+
+        merged_label_final = merged_labels_after[0]
+        label_text_final = merged_label_final.text_string
+        assert "fwhm" in label_text_final.lower(), (
+            "Label should still contain FWHM result"
+        )
+        assert "fw1e2" in label_text_final.lower(), (
+            "Label should still contain FW1e2 result"
+        )
+        execenv.print("  ✓ Merged label persists after re-selection")
+
+        execenv.print("✓ Test passed: Merged result label works correctly")
+
+
+if __name__ == "__main__":
+    test_merged_result_label()

datalab/tests/features/common/result_shape_settings_unit_test.py

@@ -0,0 +1,223 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Unit test for visualization settings for annotated shapes and markers.
+
+This test verifies that visualization settings (configured in Settings dialog)
+are properly applied when creating geometry results:
+1. Centroid produces a marker (MARKER kind from sigima)
+2. Contour detection produces annotated shapes (CIRCLE, ELLIPSE, or POLYGON kind)
+
+The test uses the Conf.view.def*.temp() context manager to temporarily modify
+settings and verify they're applied to new results.
+"""
+
+from __future__ import annotations
+
+from plotpy.items import AnnotatedCircle, Marker
+from plotpy.styles import MarkerParam, ShapeParam
+from sigima.objects import Gauss2DParam, create_image_from_param
+
+from datalab.adapters_metadata import GeometryAdapter
+from datalab.adapters_plotpy import GeometryPlotPyAdapter
+from datalab.config import Conf
+from datalab.env import execenv
+from datalab.tests import datalab_test_app_context
+
+
+def test_ima_shape_param():
+    """Test that annotated shape settings are applied to
+    enclosing_circle results on images."""
+    with datalab_test_app_context(console=False) as win:
+        panel = win.imagepanel
+
+        # Create a Gaussian image for testing (simple peak for enclosing circle)
+        size = 200
+        param = Gauss2DParam.create(height=size, width=size, sigma=20)
+        img = create_image_from_param(param)
+        img.title = "Test Gaussian"
+        panel.add_object(img)
+
+        # Test: Verify annotated shape settings for enclosing circle
+        # ----------------------------------------------------------
+        execenv.print("\n=== Test: Enclosing Circle (Annotated Shapes) ===")
+
+        # Create custom annotated shape settings
+        def_param = ShapeParam()
+        def_param.line.width = 3
+        def_param.line.color = "#852727"
+
+        # Temporarily set the annotated shape settings
+        # Note: enclosing_circle is an image feature, so we use ima_shape_param
+        with Conf.view.ima_shape_param.temp(def_param):
+            # Compute enclosing circle with the custom settings
+            with Conf.proc.show_result_dialog.temp(False):
+                panel.processor.run_feature("enclosing_circle")
+
+            # Get the geometry adapter and create plot items
+            adapter = GeometryAdapter.from_obj(img, "enclosing_circle")
+            assert adapter is not None, "Enclosing circle should be computed"
+
+            # Create a plotpy adapter to get the shape items
+            plotpy_adapter = GeometryPlotPyAdapter(adapter)
+            items = list(plotpy_adapter.iterate_shape_items("%.1f", True, "i"))
+
+            # Verify we got annotated shapes
+            assert len(items) > 0, "Should have at least one shape"
+
+            shape_item = items[0]
+            assert isinstance(shape_item, AnnotatedCircle), (
+                f"Expected AnnotatedCircle, got {type(shape_item)}"
+            )
+
+            # Verify the annotation settings were applied
+            param: ShapeParam = shape_item.shape.shapeparam
+            execenv.print(f"Line width: {param.line.width}")
+            execenv.print(f"Line color: {param.line.color}")
+            assert param.line.width == def_param.line.width, (
+                f"Expected line.width={def_param.line.width}, got {param.line.width}"
+            )
+            assert param.line.color == def_param.line.color, (
+                f"Expected line.color={def_param.line.color}, got {param.line.color}"
+            )
+            execenv.print(
+                "✓ Enclosing circle annotated shape settings correctly applied"
+            )
+
+        execenv.print("\n=== Test passed ===")
+
+
+def test_ima_marker_param():
+    """Test that shape settings are applied to geometry results."""
+    with datalab_test_app_context(console=False) as win:
+        panel = win.imagepanel
+
+        # Create a 2D Gaussian image for testing
+        size = 200
+        param = Gauss2DParam.create(height=size, width=size, sigma=20)
+        img = create_image_from_param(param)
+        img.title = "Test Gaussian"
+        panel.add_object(img)
+
+        # Test: Verify marker settings for centroid
+        # ------------------------------------------
+        execenv.print("\n=== Test: Centroid (Marker) ===")
+
+        # Create custom marker settings
+        def_param = MarkerParam()
+        def_symbol = def_param.symbol
+        def_symbol.marker = "XCross"
+        def_symbol.size = 15
+        def_symbol.edgecolor = "#316331"
+        def_symbol.facecolor = "#291b6b"
+        def_symbol.alpha = 0.87
+
+        # Temporarily set the marker settings
+        with Conf.view.ima_marker_param.temp(def_param):
+            # Compute centroid with the custom settings
+            with Conf.proc.show_result_dialog.temp(False):
+                panel.processor.run_feature("centroid")
+
+            # Get the geometry adapter and create plot items
+            adapter = GeometryAdapter.from_obj(img, "centroid")
+            assert adapter is not None, "Centroid should be computed"
+
+            # Create a plotpy adapter to get the marker item
+            plotpy_adapter = GeometryPlotPyAdapter(adapter)
+            items = list(plotpy_adapter.iterate_shape_items("%.1f", True, "i"))
+
+            # Verify we got a marker
+            assert len(items) > 0, "Should have at least one marker"
+
+            marker = items[0]
+            assert isinstance(marker, Marker), f"Expected Marker, got {type(marker)}"
+
+            # Verify the marker settings were applied
+            symbol = marker.markerparam.symbol
+            execenv.print(f"Marker symbol: {symbol.marker}")
+            execenv.print(f"Marker size: {symbol.size}")
+            execenv.print(f"Marker edge color: {symbol.edgecolor}")
+            assert symbol.marker == def_symbol.marker, (
+                f"Expected marker='XCross', got '{symbol.marker}'"
+            )
+            assert symbol.size == def_symbol.size, (
+                f"Expected size={def_symbol.size}, got {symbol.size}"
+            )
+            assert symbol.edgecolor == def_symbol.edgecolor, (
+                f"Expected edgecolor={def_symbol.edgecolor}, got {symbol.edgecolor}"
+            )
+            assert symbol.facecolor == def_symbol.facecolor, (
+                f"Expected facecolor={def_symbol.facecolor}, got {symbol.facecolor}"
+            )
+            execenv.print("✓ Centroid marker settings correctly applied")
+
+        execenv.print("\n=== Test passed ===")
+
+
+def test_refresh_shape_items_after_settings_change():
+    """Test that shape items are refreshed when settings change.
+
+    This test verifies the fix for the issue where result shapes were not
+    updated when refreshing the Image View after changing shape
+    parameters in the Settings dialog.
+    """
+    with datalab_test_app_context(console=False) as win:
+        panel = win.imagepanel
+
+        # Create a Gaussian image with a result
+        size = 200
+        param = Gauss2DParam.create(height=size, width=size, sigma=20)
+        img = create_image_from_param(param)
+        img.title = "Test Gaussian"
+        panel.add_object(img)
+
+        # Compute enclosing circle with initial settings
+        with Conf.proc.show_result_dialog.temp(False):
+            panel.processor.run_feature("enclosing_circle")
+
+        # Get initial shape item styling
+        plot = panel.plothandler.plot
+        shape_items = [item for item in plot.items if isinstance(item, AnnotatedCircle)]
+        assert len(shape_items) > 0, "Should have at least one shape item"
+
+        initial_width = shape_items[0].shape.shapeparam.line.width
+        initial_color = shape_items[0].shape.shapeparam.line.color
+
+        execenv.print(f"Initial shape: width={initial_width}, color={initial_color}")
+
+        # Change temporarily the shape parameters
+        new_param = ShapeParam()
+        new_param.line.width = 5
+        new_param.line.color = "#00ff00"
+        with Conf.view.ima_shape_param.temp(new_param):
+            # Call refresh_all_shape_items() to apply new settings
+            panel.plothandler.refresh_all_shape_items()
+
+            # Get updated shape items
+            shape_items_after = [
+                item for item in plot.items if isinstance(item, AnnotatedCircle)
+            ]
+            assert len(shape_items_after) > 0, (
+                "Should still have shape items after refresh"
+            )
+
+            updated_width = shape_items_after[0].shape.shapeparam.line.width
+            updated_color = shape_items_after[0].shape.shapeparam.line.color
+
+            execenv.print(
+                f"Updated shape: width={updated_width}, color={updated_color}"
+            )
+
+            # Verify the shape was updated with new settings
+            assert updated_width == 5, f"Expected width 5, got {updated_width}"
+            assert updated_color == "#00ff00", (
+                f"Expected color #00ff00, got {updated_color}"
+            )
+
+            execenv.print("✓ Shape items correctly refreshed after settings change\n")
+
+
+if __name__ == "__main__":
+    test_ima_shape_param()
+    test_ima_marker_param()
+    test_refresh_shape_items_after_settings_change()

datalab/tests/features/common/roi_plotitem_unit_test.py

@@ -0,0 +1,64 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+ROI to plot item conversion unit tests
+"""
+
+# pylint: disable=invalid-name  # Allows short reference names like x, y, ...
+# guitest: show
+
+from __future__ import annotations
+
+import numpy as np
+import sigima.objects
+from guidata.qthelpers import qt_app_context
+from sigima.tests.data import (
+    create_multigaussian_image,
+    create_paracetamol_signal,
+    create_test_image_rois,
+    create_test_signal_rois,
+)
+
+from datalab.adapters_plotpy import create_adapter_from_object, plotitem_to_singleroi
+from datalab.env import execenv
+
+
+def __conversion_methods(
+    roi: sigima.objects.SignalROI | sigima.objects.ImageROI,
+    obj: sigima.objects.SignalObj | sigima.objects.ImageObj,
+) -> None:
+    """Test conversion methods for single ROI objects"""
+    execenv.print("    test `to_plot_item` and `from_plot_item` methods: ", end="")
+    single_roi = roi.get_single_roi(0)
+    with qt_app_context(exec_loop=False):
+        plot_item = create_adapter_from_object(single_roi).to_plot_item(obj)
+        sroi_new = plotitem_to_singleroi(plot_item)
+        orig_coords = [float(val) for val in single_roi.get_physical_coords(obj)]
+        new_coords = [float(val) for val in sroi_new.get_physical_coords(obj)]
+        execenv.print(f"{orig_coords} --> {new_coords}")
+        assert np.array_equal(orig_coords, new_coords)
+
+
+def test_signal_roi_plotitem_conversion() -> None:
+    """Test signal ROIs conversion to/from plot items"""
+    execenv.print("==============================================")
+    execenv.print("Test signal ROIs conversion to/from plot items")
+    execenv.print("==============================================")
+    obj = create_paracetamol_signal()
+    for roi in create_test_signal_rois(obj):
+        __conversion_methods(roi, obj)
+
+
+def test_image_roi_plotitem_conversion() -> None:
+    """Test image ROIs conversion to/from plot items"""
+    execenv.print("==============================================")
+    execenv.print("Test image ROIs conversion to/from plot items")
+    execenv.print("==============================================")
+    obj = create_multigaussian_image()
+    for roi in create_test_image_rois(obj):
+        __conversion_methods(roi, obj)
+
+
+if __name__ == "__main__":
+    test_signal_roi_plotitem_conversion()
+    test_image_roi_plotitem_conversion()