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

datalab/tests/features/image/profile_app_test.py

@@ -0,0 +1,73 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Profile extraction test
+=======================
+
+Testing the profile extraction features of the image panel:
+
+- Compute a profile along a horizontal line
+- Compute a profile along a vertical line
+- Compute an average profile between two points along a horizontal line
+- Compute an average profile between two points along a vertical line
+- Compute a radial profile
+"""
+
+# pylint: disable=invalid-name  # Allows short reference names like x, y, ...
+# guitest: show
+
+import sigima.params
+from sigima.tests.data import create_noisy_gaussian_image, get_test_image
+
+from datalab.tests import datalab_test_app_context
+
+
+def test_profile():
+    """Run profile extraction test scenario"""
+    with datalab_test_app_context() as win:
+        panel = win.imagepanel
+        panel.add_object(get_test_image("flower.npy"))
+        proc = panel.processor
+        for direction, row, col in (
+            ("horizontal", 102, 131),
+            ("vertical", 102, 131),
+        ):
+            profparam = sigima.params.LineProfileParam.create(
+                direction=direction, row=row, col=col
+            )
+            proc.compute_line_profile(profparam)
+        for direction, row1, col1, row2, col2 in (
+            ("horizontal", 10, 10, 102, 131),
+            ("vertical", 10, 10, 102, 131),
+        ):
+            avgprofparam = sigima.params.AverageProfileParam.create(
+                direction=direction,
+                row1=row1,
+                col1=col1,
+                row2=row2,
+                col2=col2,
+            )
+            proc.compute_average_profile(avgprofparam)
+        segprofparam = sigima.params.SegmentProfileParam.create(
+            row1=10, col1=10, row2=102, col2=131
+        )
+        proc.compute_segment_profile(segprofparam)
+        image2 = create_noisy_gaussian_image(center=(0.0, 0.0), add_annotations=False)
+        panel.add_object(image2)
+        for center, x0, y0 in (
+            (None, 0.0, 0.0),
+            ("centroid", 0.0, 0.0),
+            ("center", 0.0, 0.0),
+            ("user", 800.0, 900.0),
+        ):
+            if center is None:
+                proc.compute_radial_profile()
+            else:
+                param = sigima.params.RadialProfileParam.create(
+                    center=center, x0=x0, y0=y0
+                )
+                proc.compute_radial_profile(param)
+
+
+if __name__ == "__main__":
+    test_profile()

datalab/tests/features/image/profile_dialog_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
+
+import sigima.params
+from guidata.qthelpers import exec_dialog, qt_app_context
+from sigima.tests.data import create_noisy_gaussian_image
+
+from datalab.env import execenv
+from datalab.gui.profiledialog import ProfileExtractionDialog
+
+
+def test_profile_unit():
+    """Run profile extraction test"""
+    with qt_app_context():
+        obj = create_noisy_gaussian_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.params.LineProfileParam.create(row=100, col=200)
+                    elif mode == "segment":
+                        param = sigima.params.SegmentProfileParam.create(
+                            row1=10, col1=20, row2=200, col2=300
+                        )
+                    else:
+                        param = sigima.params.AverageProfileParam.create(
+                            row1=10, col1=20, row2=200, col2=300
+                        )
+                else:
+                    if mode == "line":
+                        param = sigima.params.LineProfileParam()
+                    elif mode == "segment":
+                        param = sigima.params.SegmentProfileParam()
+                    else:
+                        param = sigima.params.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()

datalab/tests/features/image/roi_app_test.py

@@ -0,0 +1,98 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""Image ROI application test"""
+
+# pylint: disable=invalid-name  # Allows short reference names like x, y, ...
+# guitest: show
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import pytest
+import sigima.params as sigima_param
+from sigima.objects import ImageObj, ImageROI, NewImageParam, create_image_roi
+from sigima.tests.data import create_multigaussian_image
+
+from datalab.config import Conf
+from datalab.env import execenv
+from datalab.tests import datalab_test_app_context, helpers
+
+if TYPE_CHECKING:
+    from datalab.gui.panel.image import ImagePanel
+
+SIZE = 200
+
+# Image ROIs:
+IROI1 = [100, 100, 75, 100]  # Rectangle
+IROI2 = [66, 100, 50]  # Circle
+# Polygon (triangle, that is intentionally inside the rectangle, so that this ROI
+# has no impact on the mask calculations in the tests)
+IROI3 = [100, 100, 100, 150, 150, 133]
+
+
+def __run_image_computations(panel: ImagePanel):
+    """Test all image features related to ROI"""
+    panel.processor.run_feature("centroid")
+    panel.processor.run_feature("histogram", sigima_param.HistogramParam())
+    panel.processor.run_feature(
+        "peak_detection", sigima_param.Peak2DDetectionParam.create(create_rois=False)
+    )
+    roi = ImageROI()
+    panel.processor.compute_roi_extraction(roi)
+
+
+def create_test_image_with_roi(newimageparam: NewImageParam) -> ImageObj:
+    """Create test image with ROIs
+
+    Args:
+        newimageparam (sigima.NewImageParam): Image parameters
+
+    Returns:
+        sigima.ImageObj: Image object with ROIs
+    """
+    ima = create_multigaussian_image(newimageparam)
+    ima.data += 1  # Ensure that the image has non-zero values (for ROI check tests)
+    roi = create_image_roi("rectangle", IROI1)
+    roi.add_roi(create_image_roi("circle", IROI2))
+    roi.add_roi(create_image_roi("polygon", IROI3))
+    ima.roi = roi
+    return ima
+
+
+def test_image_roi_app(screenshots: bool = False):
+    """Run Image ROI application test scenario"""
+    with datalab_test_app_context(console=False) as win:
+        execenv.print("Image ROI application test:")
+        panel = win.imagepanel
+        param = NewImageParam.create(height=SIZE, width=SIZE)
+        ima1 = create_multigaussian_image(param)
+        panel.add_object(ima1)
+        __run_image_computations(panel)
+        ima2 = create_test_image_with_roi(param)
+        for singleobj in (False, True):
+            with Conf.proc.extract_roi_singleobj.temp(singleobj):
+                ima2_i = ima2.copy()
+                panel.add_object(ima2_i)
+                helpers.print_obj_data_dimensions(ima2_i)
+                panel.processor.edit_roi_graphically()
+                if screenshots:
+                    win.statusBar().hide()
+                    win.take_screenshot("i_roi_image")
+                __run_image_computations(panel)
+
+
+@pytest.mark.skip(reason="This test is only for manual testing")
+def test_image_roi_basic_app():
+    """Run Image ROI basic application test scenario"""
+    with datalab_test_app_context(console=False) as win:
+        panel = win.imagepanel
+        param = NewImageParam.create(height=SIZE, width=SIZE)
+        ima1 = create_multigaussian_image(param)
+        panel.add_object(ima1)
+        panel.processor.edit_roi_graphically()
+
+
+if __name__ == "__main__":
+    test_image_roi_app(screenshots=True)
+    test_image_roi_basic_app()

datalab/tests/features/image/roi_circ_app_test.py

@@ -0,0 +1,62 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Circular ROI test
+"""
+
+# pylint: disable=invalid-name  # Allows short reference names like x, y, ...
+# guitest: show
+
+from __future__ import annotations
+
+from typing import Literal
+
+import numpy as np
+import sigima.objects
+from skimage import draw
+
+from datalab.env import execenv
+from datalab.tests import datalab_test_app_context, helpers
+
+
+def create_test_image_with_roi(
+    geometry: Literal["rectangle", "circle", "polygon"],
+) -> sigima.objects.ImageObj:
+    """Create test image with ROIs"""
+    data = np.zeros((500, 750), dtype=np.uint16)
+    xc, yc, r = 500, 200, 100
+    rr, cc = draw.disk((yc, xc), r)
+    data[rr, cc] = 10000
+    data[yc + r - 20 : yc + r, xc + r - 30 : xc + r - 10] = 50000
+    if geometry == "rectangle":
+        coords = [xc - r, yc - r, 2 * r, 2 * r]
+    elif geometry == "circle":
+        coords = [xc, yc, r]
+    else:
+        raise NotImplementedError(f"Geometry {geometry} not implemented")
+    ima = sigima.objects.create_image(f"Test image with ROI/{geometry}", data)
+    ima.roi = sigima.objects.create_image_roi(geometry, coords, indices=True)
+    return ima
+
+
+def test_roi_circ() -> None:
+    """Run circular ROI application test scenario"""
+    with datalab_test_app_context() as win:
+        execenv.print("Circular ROI test:")
+        panel = win.imagepanel
+        for geometry in ("rectangle", "circle"):  # model.ROI2DParam.geometries:
+            ima = create_test_image_with_roi(geometry)
+            panel.add_object(ima)
+            helpers.print_obj_data_dimensions(ima)
+            panel.processor.run_feature("stats")
+            panel.processor.run_feature("centroid")
+        # Extracting ROIs:
+        for obj_nb in (1, 2):
+            obj = panel[obj_nb]
+            panel.objview.set_current_object(obj)
+            params = obj.roi.to_params(obj)
+            panel.processor.run_feature("extract_roi", params=params)
+
+
+if __name__ == "__main__":
+    test_roi_circ()

datalab/tests/features/image/roi_manipulation_app_test.py

@@ -0,0 +1,268 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""Image ROI manipulation application test (copy/paste, import/export)"""
+
+# pylint: disable=invalid-name  # Allows short reference names like x, y, ...
+# guitest: show
+
+from __future__ import annotations
+
+import os
+import tempfile
+from typing import TYPE_CHECKING
+
+from sigima.io import read_roi
+from sigima.objects import NewImageParam, create_image_roi
+from sigima.tests.data import create_multigaussian_image
+
+from datalab.env import execenv
+from datalab.objectmodel import get_uuid
+from datalab.tests import datalab_test_app_context
+
+if TYPE_CHECKING:
+    from datalab.gui.panel.image import ImagePanel
+
+SIZE = 200
+
+# Image ROIs:
+IROI1 = [100, 100, 75, 100]  # Rectangle
+IROI2 = [66, 100, 50]  # Circle
+IROI3 = [100, 100, 100, 150, 150, 133]  # Polygon
+
+
+def test_image_roi_copy_paste():
+    """Test image ROI copy and paste functionality"""
+    with datalab_test_app_context(console=False) as win:
+        execenv.print("Image ROI Copy/Paste test:")
+        panel: ImagePanel = win.imagepanel
+        param = NewImageParam.create(height=SIZE, width=SIZE)
+
+        # Create first image with ROI
+        ima1 = create_multigaussian_image(param)
+        ima1.title = "Image with ROI"
+        roi1 = create_image_roi("rectangle", IROI1)
+        roi1.add_roi(create_image_roi("circle", IROI2))
+        ima1.roi = roi1
+        panel.add_object(ima1)
+
+        # Create second image without ROI
+        ima2 = create_multigaussian_image(param)
+        ima2.title = "Image without ROI"
+        panel.add_object(ima2)
+
+        # Create third image without ROI
+        ima3 = create_multigaussian_image(param)
+        ima3.title = "Image without ROI 2"
+        panel.add_object(ima3)
+
+        execenv.print("  Initial state:")
+        execenv.print(f"    Image 1 ROI: {ima1.roi is not None}")
+        execenv.print(f"    Image 2 ROI: {ima2.roi is not None}")
+        execenv.print(f"    Image 3 ROI: {ima3.roi is not None}")
+
+        # Select first image and copy its ROI
+        panel.objview.set_current_item_id(get_uuid(ima1))
+        panel.copy_roi()
+        execenv.print("  Copied ROI from Image 1")
+
+        # Select second image and paste ROI
+        panel.objview.set_current_item_id(get_uuid(ima2))
+        panel.paste_roi()
+        execenv.print("  Pasted ROI to Image 2")
+
+        # Verify that ima2 now has the same ROI as ima1
+        assert ima2.roi is not None, "Image 2 should have ROI after paste"
+        assert len(ima2.roi) == len(ima1.roi), "ROI should have same number of regions"
+        execenv.print(f"    Image 2 now has {len(ima2.roi)} ROI regions")
+
+        # Select third image and paste ROI (should create new ROI)
+        panel.objview.set_current_item_id(get_uuid(ima3))
+        panel.paste_roi()
+        execenv.print("  Pasted ROI to Image 3")
+
+        assert ima3.roi is not None, "Image 3 should have ROI after paste"
+        assert len(ima3.roi) == len(ima1.roi), "ROI should have same number of regions"
+        execenv.print(f"    Image 3 now has {len(ima3.roi)} ROI regions")
+
+        # Test pasting to image that already has ROI (should combine)
+        panel.objview.set_current_item_id(get_uuid(ima2))
+        panel.copy_roi()
+        execenv.print("  Copied ROI from Image 2")
+
+        # Add a different ROI to ima1
+        roi_new = create_image_roi("polygon", IROI3)
+        ima1.roi.add_roi(roi_new)
+        original_roi_count = len(ima1.roi)
+        execenv.print(f"    Image 1 now has {original_roi_count} ROI regions")
+
+        # Paste the ROI from ima2 into ima1 (should combine)
+        panel.objview.set_current_item_id(get_uuid(ima1))
+        panel.paste_roi()
+        execenv.print("  Pasted ROI to Image 1 (should combine)")
+
+        # Get fresh reference to ima1 from panel
+        ima1_updated = panel.objmodel[get_uuid(ima1)]
+        assert ima1_updated.roi is not None, "Image 1 should still have ROI"
+        # After combining, ima1 should have more regions than before
+        assert len(ima1_updated.roi) >= original_roi_count, (
+            f"Expected at least {original_roi_count} ROI regions, "
+            f"got {len(ima1_updated.roi)}"
+        )
+        execenv.print(
+            f"    Image 1 now has {len(ima1_updated.roi)} ROI regions (combined)"
+        )
+
+        execenv.print("  ✓ Image ROI copy/paste test passed")
+
+
+def test_image_roi_copy_paste_multiple_selection():
+    """Test image ROI paste to multiple selected images"""
+    with datalab_test_app_context(console=False) as win:
+        execenv.print("Image ROI Copy/Paste with multiple selection test:")
+        panel: ImagePanel = win.imagepanel
+        param = NewImageParam.create(height=SIZE, width=SIZE)
+
+        # Create source image with ROI
+        ima_src = create_multigaussian_image(param)
+        ima_src.title = "Source with ROI"
+        roi = create_image_roi("rectangle", IROI1)
+        roi.add_roi(create_image_roi("circle", IROI2))
+        ima_src.roi = roi
+        panel.add_object(ima_src)
+
+        # Create multiple target images without ROI
+        target_images = []
+        for i in range(3):
+            ima = create_multigaussian_image(param)
+            ima.title = f"Target image {i + 1}"
+            panel.add_object(ima)
+            target_images.append(ima)
+
+        execenv.print(f"  Created {len(target_images)} target images")
+
+        # Copy ROI from source
+        panel.objview.set_current_item_id(get_uuid(ima_src))
+        panel.copy_roi()
+        execenv.print("  Copied ROI from source image")
+
+        # Select all target images
+        target_uuids = [get_uuid(img) for img in target_images]
+        panel.objview.set_current_item_id(target_uuids[0])
+        for uuid in target_uuids[1:]:
+            panel.objview.set_current_item_id(uuid, extend=True)
+
+        execenv.print(f"  Selected {len(target_uuids)} target images")
+
+        # Paste ROI to all selected images
+        panel.paste_roi()
+        execenv.print("  Pasted ROI to all selected images")
+
+        # Verify all target images have ROI
+        for i, img in enumerate(target_images):
+            assert img.roi is not None, f"Target image {i + 1} should have ROI"
+            assert len(img.roi) == len(ima_src.roi), (
+                f"Target image {i + 1} should have {len(ima_src.roi)} ROI regions"
+            )
+            execenv.print(f"    Target image {i + 1}: {len(img.roi)} ROI regions ✓")
+
+        execenv.print("  ✓ Multiple selection paste test passed")
+
+
+def test_image_roi_import_export():
+    """Test image ROI import and export to/from file functionality"""
+    with datalab_test_app_context(console=False) as win:
+        execenv.print("Image ROI Import/Export test:")
+        panel: ImagePanel = win.imagepanel
+        param = NewImageParam.create(height=SIZE, width=SIZE)
+
+        # Create first image with ROI
+        ima1 = create_multigaussian_image(param)
+        ima1.title = "Image with ROI"
+        roi1 = create_image_roi("rectangle", IROI1)
+        roi1.add_roi(create_image_roi("circle", IROI2))
+        roi1.add_roi(create_image_roi("polygon", IROI3))
+        ima1.roi = roi1
+        panel.add_object(ima1)
+
+        original_roi_count = len(ima1.roi)
+        execenv.print(f"  Image 1 has {original_roi_count} ROI regions")
+
+        # Export ROI to file
+        roi_file = tempfile.mktemp(suffix=".dlabroi")
+        try:
+            execenv.print("  Exporting ROI to temporary file")
+
+            # Select first image and export its ROI
+            panel.objview.set_current_item_id(get_uuid(ima1))
+            panel.export_roi_to_file(roi_file)
+            execenv.print("  ✓ ROI exported")
+
+            # Verify file was created
+            assert os.path.exists(roi_file), "ROI file should have been created"
+
+            # Read the exported ROI directly to verify content
+            exported_roi = read_roi(roi_file)
+            assert len(exported_roi) == original_roi_count, (
+                f"Exported ROI should have {original_roi_count} regions"
+            )
+            execenv.print(f"  ✓ Exported ROI has {len(exported_roi)} regions")
+
+            # Create second image without ROI
+            ima2 = create_multigaussian_image(param)
+            ima2.title = "Image without ROI"
+            panel.add_object(ima2)
+            assert ima2.roi is None, "Image 2 should not have ROI initially"
+
+            # Import ROI from file to second image
+            panel.objview.set_current_item_id(get_uuid(ima2))
+            panel.import_roi_from_file(roi_file)
+            execenv.print("  Imported ROI to Image 2")
+
+            # Get fresh reference to ima2 from panel
+            ima2_updated = panel.objmodel[get_uuid(ima2)]
+            assert ima2_updated.roi is not None, "Image 2 should have ROI after import"
+            assert len(ima2_updated.roi) == original_roi_count, (
+                f"Imported ROI should have {original_roi_count} regions"
+            )
+            execenv.print(f"  ✓ Image 2 now has {len(ima2_updated.roi)} ROI regions")
+
+            # Test importing ROI to image that already has ROI (should combine)
+            ima3 = create_multigaussian_image(param)
+            ima3.title = "Image with existing ROI"
+            roi3 = create_image_roi("circle", [150, 150, 40])
+            ima3.roi = roi3
+            panel.add_object(ima3)
+            initial_roi_count = len(ima3.roi)
+            execenv.print(f"  Image 3 has {initial_roi_count} ROI region initially")
+
+            # Import ROI (should combine with existing)
+            panel.objview.set_current_item_id(get_uuid(ima3))
+            panel.import_roi_from_file(roi_file)
+            execenv.print("  Imported ROI to Image 3 (should combine)")
+
+            # Get fresh reference to ima3 from panel
+            ima3_updated = panel.objmodel[get_uuid(ima3)]
+            assert ima3_updated.roi is not None, "Image 3 should still have ROI"
+            # After combining, should have more regions
+            assert len(ima3_updated.roi) >= initial_roi_count, (
+                f"Expected at least {initial_roi_count} ROI regions, "
+                f"got {len(ima3_updated.roi)}"
+            )
+            execenv.print(
+                f"  ✓ Image 3 now has {len(ima3_updated.roi)} ROI regions (combined)"
+            )
+        finally:
+            # Clean up temporary file
+            if os.path.exists(roi_file):
+                try:
+                    os.unlink(roi_file)
+                except (PermissionError, OSError):
+                    pass  # Ignore cleanup errors on Windows
+
+        execenv.print("  ✓ Image ROI import/export test passed")
+
+
+if __name__ == "__main__":
+    test_image_roi_copy_paste()
+    test_image_roi_copy_paste_multiple_selection()
+    test_image_roi_import_export()

datalab/tests/features/image/roigrid_unit_test.py

@@ -0,0 +1,60 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""ROI grid unit test."""
+
+# pylint: disable=invalid-name  # Allows short reference names like x, y, ...
+# guitest: show
+
+from __future__ import annotations
+
+from guidata.qthelpers import exec_dialog, qt_app_context
+from sigima.proc.image import Direction, ROIGridParam
+from sigima.tests.data import create_grid_of_gaussian_images
+
+from datalab.gui.roigrideditor import ImageGridROIEditor
+from datalab.utils import qthelpers as qth
+
+
+def test_roi_grid(screenshots: bool = False) -> None:
+    """ROI grid test."""
+    with qt_app_context():
+        roi_editor = ImageGridROIEditor(
+            parent=None, obj=create_grid_of_gaussian_images()
+        )
+        if screenshots:
+            roi_editor.show()
+            qth.grab_save_window(roi_editor)
+        exec_dialog(roi_editor)
+
+
+def test_roi_grid_geometry_headless() -> None:
+    """Test ROI grid geometry in headless mode."""
+    img = create_grid_of_gaussian_images()
+
+    # Create grid parameters
+    gp = ROIGridParam()
+    gp.nx, gp.ny = 2, 2
+    gp.xsize = gp.ysize = 50
+    gp.xtranslation = gp.ytranslation = 50
+    gp.xdirection = gp.ydirection = Direction.INCREASING
+
+    with qt_app_context():
+        dlg = ImageGridROIEditor(parent=None, obj=img, gridparam=gp)
+        # Set a small grid and sizes
+        dlg.update_obj(update_item=False)
+        roi = dlg.get_roi()
+        assert roi is not None
+        # 4 ROIs, centered in each cell
+        assert len(list(roi)) == 4
+        titles = [r.title for r in roi]
+        assert "ROI(1,1)" in titles and "ROI(2,2)" in titles
+        # Check one ROI position approximately
+        r00 = next(r for r in roi if r.title == "ROI(1,1)")
+        _x0, _y0, dx, dy = r00.get_physical_coords(img)
+        assert dx == img.width / 2 * 0.5
+        assert dy == img.height / 2 * 0.5
+
+
+if __name__ == "__main__":
+    test_roi_grid_geometry_headless()
+    test_roi_grid(screenshots=True)

datalab/tests/features/image/side_by_side_app_test.py

@@ -0,0 +1,52 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+View images side-by-side test
+"""
+
+# 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 datalab.tests import datalab_test_app_context
+
+
+def test_view_images_side_by_side() -> None:
+    """Test viewing multiple images side-by-side."""
+    with datalab_test_app_context() as win:
+        panel = win.imagepanel
+
+        # Create several test images with different content
+        for i in range(5):
+            x = np.linspace(-5, 5, 100)
+            y = np.linspace(-5, 5, 100)
+            xx, yy = np.meshgrid(x, y)
+
+            # Different patterns for each image
+            if i == 0:
+                data = np.exp(-(xx**2 + yy**2) / (2 * (i + 1)))
+            elif i == 1:
+                data = np.sin(xx) * np.cos(yy)
+            elif i == 2:
+                data = np.abs(xx) + np.abs(yy)
+            elif i == 3:
+                data = xx**2 - yy**2
+            else:
+                data = np.random.randn(100, 100)
+
+            image = sigima.objects.create_image(f"Test Image {i + 1}", data)
+            panel.add_object(image)
+
+        # Select all images (1 to 5)
+        panel.objview.select_objects(list(range(1, 6)))
+
+        # Open side-by-side view
+        panel.view_images_side_by_side()
+
+
+if __name__ == "__main__":
+    test_view_images_side_by_side()

datalab/tests/features/macro/__init__.py

@@ -0,0 +1 @@
+#