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

datalab/tests/features/macro/macro_app_test.py

@@ -0,0 +1,28 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Macro Panel application test
+(essentially for the screenshot...)
+"""
+
+# guitest: show
+
+from datalab import config
+from datalab.gui.main import DLMainWindow
+from datalab.utils import qthelpers as qth
+
+
+def test_macro(screenshots: bool = False) -> None:
+    """Run image tools test scenario"""
+    config.reset()  # Reset configuration (remove configuration file and initialize it)
+    with qth.datalab_app_context(exec_loop=True):
+        win = DLMainWindow()
+        win.show()
+        win.set_current_panel("macro")
+        win.macropanel.add_macro()
+        if screenshots:
+            qth.grab_save_window(win.macropanel, "macro_panel")
+
+
+if __name__ == "__main__":
+    test_macro()

datalab/tests/features/macro/macroeditor_unit_test.py

@@ -0,0 +1,102 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Macro Panel unit tests
+----------------------
+
+The objective of this test is to check all the functionalities of the Macro Panel
+widget, by calling all its methods and checking the results.
+
+Some methods are not tested here, as they are tested in remote control tests
+(see datalab/tests/features/control/remoteclient_app.py):
+- `run_macro`
+- `stop_macro`
+
+All other methods should be tested here.
+"""
+
+# guitest: show
+
+import os.path as osp
+
+from guidata.qthelpers import qt_app_context
+
+from datalab.env import execenv
+from datalab.gui.macroeditor import Macro
+from datalab.gui.panel import macro
+from datalab.tests import helpers
+
+
+def get_macro_example_path() -> str:
+    """Return macro example path"""
+    path = helpers.get_temporary_directory()
+    contents = """
+# Simple DataLab macro example
+
+import numpy as np
+
+from datalab.control.proxy import RemoteProxy
+
+proxy = RemoteProxy()
+
+z = np.random.rand(20, 20)
+proxy.add_image("toto", z)
+proxy.calc("fft")
+
+print("All done! :)")
+"""
+    filename = osp.join(path, "macro_example.py")
+    with open(filename, "w", encoding="utf-8") as f:
+        f.write(contents)
+    return filename
+
+
+def test_macro_editor():
+    """Test dep viewer window"""
+    with qt_app_context(exec_loop=True):
+        widget = macro.MacroPanel(None)
+        widget.resize(800, 600)
+        widget.show()
+
+        # Create a new macro
+        new_macro = widget.add_macro()
+        assert new_macro is widget.get_macro()
+
+        # Check out the macro title, serializable name, number, ...
+        execenv.print("Macro title:", new_macro.title)
+        execenv.print("Serializable name:", widget.get_serializable_name(new_macro))
+        nb1 = widget.get_number_from_macro(new_macro)
+        nb2 = widget.get_number_from_title(new_macro.title)
+        assert nb1 == nb2 and nb1 == 1
+        execenv.print("Macro number:", nb1)
+        titles = widget.get_macro_titles()
+        assert titles[0] == new_macro.title and len(titles) == 1
+        new_title = "New title"
+        widget.rename_macro(1, new_title)
+        assert widget.get_macro_titles()[0] == new_title
+
+        with helpers.WorkdirRestoringTempDir() as tmpdir:
+            fname = osp.join(tmpdir, "macro.py")
+            widget.export_macro_to_file(1, fname)
+            widget.import_macro_from_file(fname)
+            imported_macro: Macro = widget.get_macro(2)
+            assert imported_macro.title == new_macro.title
+            assert imported_macro.get_code() == new_macro.get_code()
+            widget.rename_macro(1, "Other title")
+            widget.remove_macro(1)
+            assert len(widget.get_macro_titles()) == 1
+            assert widget.get_macro_titles()[0] == imported_macro.title
+
+        # Remove all macros
+        widget.remove_all_objects()
+        assert len(widget.get_macro_titles()) == 0
+
+        # Load a macro from file
+        macro_path = get_macro_example_path()
+        widget.import_macro_from_file(macro_path)
+        assert len(widget.get_macro_titles()) == 1
+        assert widget.get_macro_titles()[0] == osp.basename(macro_path)
+
+
+if __name__ == "__main__":
+    test_macro_editor()

datalab/tests/features/signal/__init__.py

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

datalab/tests/features/signal/baseline_dialog_test.py

@@ -0,0 +1,53 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Baseline dialog test
+"""
+
+# pylint: disable=invalid-name  # Allows short reference names like x, y, ...
+# pylint: disable=duplicate-code
+# guitest: show
+
+from __future__ import annotations
+
+import numpy as np
+import sigima.objects
+import sigima.proc.signal as sips
+from guidata.qthelpers import exec_dialog, qt_app_context
+from sigima.tests.data import create_paracetamol_signal
+from sigima.tests.vistools import view_curves
+
+from datalab.env import execenv
+from datalab.widgets.signalbaseline import SignalBaselineDialog
+
+
+def test_signal_baseline_selection():
+    """Signal baseline selection dialog test"""
+    sig = create_paracetamol_signal()
+    with qt_app_context():
+        dlg = SignalBaselineDialog(sig)
+        dlg.resize(640, 480)
+        dlg.setObjectName(dlg.objectName() + "_00")  # to avoid timestamp suffix
+        exec_dialog(dlg)
+    execenv.print(f"baseline: {dlg.get_baseline()}")
+    execenv.print(f"X range: {dlg.get_x_range()}")
+    # Check baseline value:
+    i0, i1 = np.searchsorted(sig.x, dlg.get_x_range())
+    assert dlg.get_baseline() == sig.data[i0:i1].mean()
+
+
+def test_signal_baseline_dialog() -> None:
+    """Test the signal baseline dialog for offset correction."""
+    with qt_app_context():
+        s1 = create_paracetamol_signal()
+        dlg = SignalBaselineDialog(s1)
+        if exec_dialog(dlg):
+            param = sigima.objects.ROI1DParam()
+            param.xmin, param.xmax = dlg.get_x_range()
+            s2 = sips.offset_correction(s1, param)
+            view_curves([s1, s2], title="Signal offset correction")
+
+
+if __name__ == "__main__":
+    test_signal_baseline_selection()
+    test_signal_baseline_dialog()

datalab/tests/features/signal/deltax_dialog_unit_test.py

@@ -0,0 +1,34 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Signal delta x dialog unit test.
+"""
+
+# pylint: disable=invalid-name  # Allows short reference names like x, y, ...
+# guitest: show
+
+from guidata.qthelpers import exec_dialog, qt_app_context
+from sigima.tests.data import create_paracetamol_signal
+from sigima.tools.signal.pulse import full_width_at_y
+
+from datalab.widgets.signaldeltax import SignalDeltaXDialog
+
+
+def test_signal_delta_x_dialog():
+    """Test the SignalDeltaXDialog widget."""
+    sig = create_paracetamol_signal()
+    with qt_app_context():
+        dlg = SignalDeltaXDialog(signal=sig)
+        dlg.resize(640, 480)
+        dlg.setObjectName(dlg.objectName() + "_00")  # to avoid timestamp suffix
+        exec_dialog(dlg)
+    y = dlg.get_y_value()
+    x0, y0, x1, y1 = dlg.get_coords()
+    exp_x0, exp_y0, exp_x1, exp_y1 = full_width_at_y(sig.x, sig.y, y)
+    assert (x0, y0, x1, y1) == (exp_x0, exp_y0, exp_x1, exp_y1), (
+        f"Expected: {(exp_x0, exp_y0, exp_x1, exp_y1)} but got: {(x0, y0, x1, y1)}"
+    )
+
+
+if __name__ == "__main__":
+    test_signal_delta_x_dialog()

datalab/tests/features/signal/fft1d_app_test.py

@@ -0,0 +1,26 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Signal FFT application test.
+"""
+
+# pylint: disable=invalid-name  # Allows short reference names like x, y, ...
+# guitest: show
+
+from sigima.objects import CosineParam, create_signal_from_param
+
+from datalab.tests import datalab_test_app_context
+
+
+def test_fft1d_app():
+    """FFT application test."""
+    with datalab_test_app_context() as win:
+        panel = win.signalpanel
+        s1 = create_signal_from_param(CosineParam.create(size=10000))
+        panel.add_object(s1)
+        panel.processor.run_feature("fft")
+        panel.processor.run_feature("ifft")
+
+
+if __name__ == "__main__":
+    test_fft1d_app()

datalab/tests/features/signal/filter_app_test.py

@@ -0,0 +1,44 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Frequential filtering application test.
+"""
+
+# pylint: disable=invalid-name  # Allows short reference names like x, y, ...
+# guitest: show
+
+import sigima.params
+from sigima.objects import create_signal_from_param
+from sigima.tests.helpers import check_array_result
+from sigima.tests.signal.pulse.pulse_unit_test import create_test_square_params
+
+from datalab.tests import datalab_test_app_context
+
+
+def test_signal_freq_filter_app():
+    """Signal frequency filtering application test."""
+    with datalab_test_app_context(console=False) as win:
+        panel = win.signalpanel
+        s1 = create_signal_from_param(create_test_square_params())
+        panel.add_object(s1)
+        for feature, paramclass in (
+            ("lowpass", sigima.params.LowPassFilterParam),
+            ("highpass", sigima.params.HighPassFilterParam),
+            ("bandstop", sigima.params.BandStopFilterParam),
+        ):
+            for zero_padding in (True, False):
+                panel.objview.select_objects([1])  # Select the first signal
+                param = paramclass.create(method="brickwall", zero_padding=zero_padding)
+                param.update_from_obj(s1)
+                panel.processor.run_feature(feature, param)
+
+                s2 = panel.objview.get_sel_objects()[0]
+                check_array_result(
+                    f"{feature} filter output X data (zero_padding={zero_padding})",
+                    s2.x,
+                    s1.x,
+                )
+
+
+if __name__ == "__main__":
+    test_signal_freq_filter_app()

datalab/tests/features/signal/fitdialog_unit_test.py

@@ -0,0 +1,50 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""Curve fitting dialog test
+
+Testing fit dialogs: Gaussian, Lorentzian, Voigt, etc.
+"""
+
+# pylint: disable=invalid-name  # Allows short reference names like x, y, ...
+# guitest: show
+
+from guidata.qthelpers import qt_app_context
+from sigima.objects import NormalDistribution1DParam
+from sigima.tests.data import create_noisy_signal, get_test_signal
+from sigima.tools.signal.peakdetection import peak_indices
+
+from datalab.env import execenv
+from datalab.tests import helpers
+from datalab.widgets import fitdialog as fdlg
+
+
+def test_fit_dialog():
+    """Test function"""
+    with qt_app_context():
+        # Multi-gaussian curve fitting test
+        s1 = get_test_signal("paracetamol.txt")
+        peakidx = peak_indices(s1.y)
+        s2 = create_noisy_signal(NormalDistribution1DParam.create(sigma=5.0))
+        s3 = get_test_signal("gaussian_fit.txt")
+        s4 = get_test_signal("piecewiseexponential_fit.txt")
+
+        ep = execenv.print
+        tn = helpers.get_default_test_name
+
+        ep(fdlg.polynomial_fit(s2.x, s2.y, 4, name=tn("00")))
+        ep(fdlg.linear_fit(s2.x, s2.y, name=tn("01")))
+        ep(fdlg.gaussian_fit(s3.x, s3.y, name=tn("02")))
+        ep(fdlg.lorentzian_fit(s3.x, s3.y, name=tn("03")))
+        ep(fdlg.multigaussian_fit(s1.x, s1.y, peakidx, name=tn("04")))
+        ep(fdlg.multilorentzian_fit(s1.x, s1.y, peakidx, name=tn("05")))
+        ep(fdlg.voigt_fit(s3.x, s3.y, name=tn("06")))
+        ep(fdlg.exponential_fit(s2.x, s2.y, name=tn("07")))
+        ep(fdlg.sinusoidal_fit(s2.x, s2.y, name=tn("08")))
+        ep(fdlg.cdf_fit(s2.x, s2.y, name=tn("09")))
+        ep(fdlg.planckian_fit(s3.x, s3.y, name=tn("10")))
+        ep(fdlg.twohalfgaussian_fit(s3.x, s3.y, name=tn("11")))
+        ep(fdlg.piecewiseexponential_fit(s4.x, s4.y, name=tn("12")))
+
+
+if __name__ == "__main__":
+    test_fit_dialog()

datalab/tests/features/signal/interpolation_app_test.py

@@ -0,0 +1,110 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Interpolation application test and X-array compatibility behavior.
+"""
+
+# pylint: disable=invalid-name  # Allows short reference names like x, y, ...
+# guitest: show
+
+import numpy as np
+import sigima.params
+from sigima.objects import SignalObj, create_signal
+
+from datalab.tests import datalab_test_app_context
+
+
+def test_interpolation_app():
+    """Test interpolation feature in DataLab application.
+
+    This test ensures that interpolation works correctly when signals have
+    different X arrays (which is the whole point of interpolation).
+    """
+    with datalab_test_app_context() as win:
+        panel = win.signalpanel
+
+        # Create interpolation parameters
+        param = sigima.params.InterpolationParam.create(method="linear")
+
+        # Create X arrays
+        x_dense = np.linspace(0, 10, 100)
+        x_sparse = np.linspace(1, 9, 20)
+
+        for x1, x2 in [(x_dense, x_sparse), (x_sparse, x_dense)]:
+            context = f"Source X {'dense' if len(x1) > len(x2) else 'sparse'} → "
+            context += f"Target X {'sparse' if len(x1) > len(x2) else 'dense'}"
+
+            # Create source signal with dense sampling
+            y1 = np.sin(x1)
+            sig1 = create_signal("Source signal", x1, y1)
+            panel.add_object(sig1)
+
+            # Create target signal with sparse sampling and different range
+            y2 = np.zeros_like(x2)  # Y values don't matter for interpolation target
+            sig2 = create_signal("Target X values", x2, y2)
+            panel.add_object(sig2)
+
+            # This is the key test - interpolation should work even when X arrays differ
+            # The X-array compatibility check should NOT interfere
+            panel.objview.select_objects([sig1])
+            panel.processor.run_feature("interpolate", sig2, param)
+
+            # Verify the result
+            result_objects = panel.objview.get_sel_objects()
+            assert len(result_objects) == 1, (
+                f"[{context}] Should have one interpolated result"
+            )
+            result = result_objects[0]
+            assert isinstance(result, SignalObj), (
+                f"[{context}] Result should be a SignalObj"
+            )
+            assert result.x.shape == sig2.x.shape, (
+                f"[{context}] Result X should match target X shape"
+            )
+            assert np.allclose(result.x, sig2.x), (
+                f"[{context}] Result X should match target X"
+            )
+            expected_y = np.interp(x2, x1, y1)
+            assert np.allclose(result.y, expected_y, atol=1e-10), (
+                f"[{context}] Result Y should be properly interpolated"
+            )
+
+
+def test_xarray_compatibility_still_works_for_other_operations():
+    """Test that X-array compatibility still works for operations that need it.
+
+    This test ensures that the fix for interpolation doesn't break X-array
+    compatibility for other operations like addition.
+    """
+    with datalab_test_app_context() as win:
+        panel = win.signalpanel
+
+        # Create signals with different X arrays (should trigger compatibility check)
+        x1 = np.linspace(0, 10, 100)
+        y1 = np.ones_like(x1)
+        sig1 = create_signal("Signal 1", x1, y1)
+        panel.add_object(sig1)
+
+        x2 = np.linspace(0, 10, 50)  # Different sampling
+        y2 = np.ones_like(x2)
+        sig2 = create_signal("Signal 2", x2, y2)
+        panel.add_object(sig2)
+
+        # Test addition (should still use X-array compatibility)
+        panel.objview.select_objects([sig1, sig2])
+        panel.processor.run_feature("addition")
+
+        # Get the result
+        result_objects = panel.objview.get_sel_objects()
+        assert len(result_objects) == 1, "Should have one addition result"
+        result = result_objects[0]
+
+        # For addition, the X-array compatibility should have handled the different
+        # arrays. The result should have consistent X values and proper Y values (2.0)
+        assert np.allclose(result.y, 2.0, atol=1e-10), (
+            "Addition result should be 2.0 (1.0 + 1.0)"
+        )
+
+
+if __name__ == "__main__":
+    test_interpolation_app()

datalab/tests/features/signal/loadbigsignal_app_test.py

@@ -0,0 +1,80 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Load big signal application test:
+
+- Generate a big signal (open an existing CSV file and create a dummy CSV file by
+  duplicating the data several times)
+
+- Load the big signal in the signal panel
+"""
+
+# guitest: show
+
+import os.path as osp
+
+import numpy as np
+import pandas as pd
+import pytest
+
+from datalab.env import execenv
+from datalab.tests import datalab_test_app_context, helpers
+
+
+def create_large_random_dataframe(nrows: int, ncols: int) -> pd.DataFrame:
+    """Create a large DataFrame with random data.
+
+    Args:
+        nrows: The number of rows to generate.
+        ncols: The number of columns to generate.
+    """
+    # The number of initial random rows to generate
+    initial_rows = min(nrows, 1000)
+
+    # Generate the initial "SignalXX" data with random values
+    initial_signal_data = np.random.rand(initial_rows, ncols)
+
+    # Duplicate the "SignalXX" data to fill the desired number of rows
+    full_signal_data = np.tile(
+        initial_signal_data,
+        (nrows // initial_rows + (1 if nrows % initial_rows > 0 else 0), 1),
+    )
+
+    # If nrows is not an exact multiple of initial_rows, trim the excess rows
+    full_signal_data = full_signal_data[:nrows, :]
+
+    # Generate the "Time" column as a sequential array from 0 to nrows-1
+    time_data = np.arange(nrows).reshape(-1, 1)
+
+    # Combine the "Time" column with the "SignalXX" data
+    full_data = np.hstack((time_data, full_signal_data))
+
+    # Prepare the column names
+    column_names = ["Time"] + [f"Signal{str(i).zfill(2)}" for i in range(1, ncols + 1)]
+
+    # Create and return the DataFrame
+    df = pd.DataFrame(full_data, columns=column_names)
+    return df
+
+
+@pytest.mark.parametrize("nrows, ncols", [(10000, 16)])
+def test_loadbigsignal_app(nrows: int, ncols: int) -> None:
+    """Load big signal application test"""
+    with helpers.WorkdirRestoringTempDir() as tmpdir:
+        with datalab_test_app_context() as win:
+            execenv.print("Loading big signal application test:")
+            execenv.print("  - Working in temporary directory:", tmpdir)
+            execenv.print(f"  - Creating a big dataset ({nrows} rows, {ncols} columns)")
+            df = create_large_random_dataframe(nrows, ncols)
+            big_csv = osp.join(tmpdir, "big.csv")
+            df.to_csv(big_csv, index=False)
+            execenv.print("  - Loading the big signal in the signal panel")
+            panel = win.signalpanel
+            panel.load_from_files([big_csv])
+            execenv.print("  - Saving the big signal")
+            panel.save_to_files([big_csv.replace(".csv", "_copy.csv")])
+            execenv.print("OK")
+
+
+if __name__ == "__main__":
+    test_loadbigsignal_app(1000000, 16)

datalab/tests/features/signal/multiple_rois_unit_test.py

@@ -0,0 +1,132 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Test for multiple geometry results with multiple ROIs
+======================================================
+
+This test verifies that multiple geometry results (e.g., FWHM and FW1e2) can coexist
+when computed on signals with multiple ROIs (e.g., multiple pulse peaks).
+"""
+
+from __future__ import annotations
+
+import numpy as np
+import sigima.objects as sio
+import sigima.params
+import sigima.proc.signal as sig_proc
+
+from datalab.adapters_metadata import GeometryAdapter
+
+
+def test_multiple_results_with_multiple_rois():
+    """Test that FWHM and FW1e2 work correctly with multiple ROIs."""
+    # Create a signal with three Gaussian pulses
+    x = np.linspace(0, 30, 3000)
+
+    # Three pulses at different positions
+    pulse1 = 1.0 * np.exp(-((x - 5) ** 2) / 2)  # Peak at x=5, sigma=1
+    pulse2 = 0.8 * np.exp(-((x - 15) ** 2) / 4)  # Peak at x=15, sigma=2
+    pulse3 = 1.2 * np.exp(-((x - 25) ** 2) / 1)  # Peak at x=25, sigma=0.707
+
+    y = pulse1 + pulse2 + pulse3
+    signal = sio.create_signal("Triple Pulse Signal", x, y)
+
+    # Create three ROIs around each pulse (pass all coordinates at once)
+    signal.roi = sio.create_signal_roi(
+        [[0.0, 10.0], [10.0, 20.0], [20.0, 30.0]]  # Three ROI ranges
+    )
+
+    roi_count = len(list(signal.iterate_roi_indices()))
+    print(f"Signal has {roi_count} ROIs")
+    fwhm_param = sigima.params.FWHMParam()
+    fwhm_param.method = "zero-crossing"
+    fwhm_result = sig_proc.fwhm(signal, fwhm_param)
+
+    assert fwhm_result is not None, "FWHM computation failed"
+    print(f"FWHM result has {len(fwhm_result.coords)} rows")
+    assert len(fwhm_result.coords) == 3, "Expected 3 FWHM measurements (one per ROI)"
+
+    GeometryAdapter(fwhm_result).add_to(signal)
+
+    # Compute FW1e2 (should also get one result per ROI)
+    fw1e2_result = sig_proc.fw1e2(signal)
+
+    assert fw1e2_result is not None, "FW1e2 computation failed"
+    print(f"FW1e² result has {len(fw1e2_result.coords)} rows")
+    assert len(fw1e2_result.coords) == 3, "Expected 3 FW1e2 measurements (one per ROI)"
+
+    GeometryAdapter(fw1e2_result).add_to(signal)
+
+    # Verify both results are stored separately
+    results = list(GeometryAdapter.iterate_from_obj(signal))
+    assert len(results) == 2, f"Expected 2 distinct results, got {len(results)}"
+
+    # Verify the titles
+    titles = {adapter.title for adapter in results}
+    assert "fwhm" in titles, "FWHM result not found"
+    assert "fw1e2" in titles, "FW1e2 result not found"
+
+    # Verify each result has measurements for all 3 ROIs
+    for adapter in results:
+        assert len(adapter.result.coords) == 3, (
+            f"{adapter.title} should have 3 measurements"
+        )
+
+        # Verify ROI indices are correct
+        roi_indices = adapter.result.roi_indices
+        assert roi_indices is not None, f"{adapter.title} should have ROI indices"
+        assert len(roi_indices) == 3, f"{adapter.title} should have 3 ROI indices"
+        assert set(roi_indices) == {0, 1, 2}, (
+            f"{adapter.title} ROI indices should be [0, 1, 2]"
+        )
+
+        print(f"\n{adapter.title.upper()} measurements:")
+        for coords, roi_idx in zip(adapter.result.coords, roi_indices):
+            width = abs(coords[2] - coords[0])
+            print(f"  ROI {roi_idx}: width = {width:.4f}")
+
+    print("\n✓ Multiple results with multiple ROIs work correctly")
+
+
+def test_roi_filtering():
+    """Test that we can filter results by ROI index."""
+    # Create a signal with two pulses
+    x = np.linspace(0, 20, 2000)
+    pulse1 = np.exp(-((x - 5) ** 2) / 2)
+    pulse2 = np.exp(-((x - 15) ** 2) / 2)
+    y = pulse1 + pulse2
+    signal = sio.create_signal("Dual Pulse Signal", x, y)
+
+    # Create two ROIs (pass all coordinates at once)
+    signal.roi = sio.create_signal_roi([[0.0, 10.0], [10.0, 20.0]])
+
+    # Compute FWHM
+    fwhm_param = sigima.params.FWHMParam()
+    fwhm_param.method = "zero-crossing"
+    fwhm_result = sig_proc.fwhm(signal, fwhm_param)
+
+    assert fwhm_result is not None
+    assert len(fwhm_result.coords) == 2
+
+    GeometryAdapter(fwhm_result).add_to(signal)
+
+    # Retrieve and filter by ROI
+    adapters = list(GeometryAdapter.iterate_from_obj(signal))
+    assert len(adapters) == 1
+
+    adapter = adapters[0]
+
+    # Get data for specific ROI
+    roi0_df = adapter.get_roi_data(0)
+    roi1_df = adapter.get_roi_data(1)
+
+    assert len(roi0_df) == 1, "ROI 0 should have 1 measurement"
+    assert len(roi1_df) == 1, "ROI 1 should have 1 measurement"
+
+    print("\n✓ ROI filtering works correctly")
+
+
+if __name__ == "__main__":
+    test_multiple_results_with_multiple_rois()
+    test_roi_filtering()
+    print("\n✅ All multi-ROI tests passed!")