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

datalab/tests/features/common/operation_modes_app_test.py

@@ -0,0 +1,392 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Operation modes test
+--------------------
+
+DataLab has two operation modes:
+
+- **Single operand mode**: the operation is applied to the selected objects (this
+  is the default mode)
+
+- **Pairwise mode**: the operation is applied to the selected pairs of objects
+
+This test scenario covers the pairwise mode and the operations that can be
+performed in this mode: sum, difference, product, division, ...
+"""
+
+# guitest: show
+
+from __future__ import annotations
+
+from datalab import app
+from datalab.config import Conf
+from datalab.env import execenv
+from datalab.gui.processor.base import is_pairwise_mode
+from datalab.objectmodel import get_short_id
+from datalab.tests import helpers
+from datalab.utils.qthelpers import datalab_app_context
+
+
+def get_h5fname() -> str:
+    """Get the HDF5 test filename"""
+    fnames = helpers.get_test_fnames("reorder*")
+    return fnames[0]
+
+
+def check_titles(title: str, titles: list[tuple[str, str]]) -> None:
+    """Check that the title is one of the expected titles"""
+    execenv.print(f"{title}:")
+    for actual_title, expected_title in titles:
+        execenv.print(f"  {actual_title} == {expected_title}", end=" ")
+        assert actual_title == expected_title
+        if actual_title == expected_title:
+            execenv.print("✓")
+        else:
+            execenv.print("✗")
+
+
+def test_single_operand_mode_compute_n_to_1() -> None:
+    """Run single operand mode test scenario
+    with `compute_n_to_1` operation (e.g. sum)"""
+    h5fname = get_h5fname()
+    original_mode = Conf.proc.operation_mode.get()
+    Conf.proc.operation_mode.set("single")
+
+    with datalab_app_context(exec_loop=True):
+        win = app.create(h5files=[h5fname], console=False)
+        panel = win.signalpanel
+        view, model = panel.objview, panel.objmodel
+
+        # Checking the operation mode:
+        assert not is_pairwise_mode()
+
+        # Store the number of groups before the operations
+        n_groups = len(model.get_groups())
+
+        # Select the two first groups
+        groups = [model.get_group_from_number(idx) for idx in (1, 2)]
+        view.select_groups(groups)
+
+        # Perform a sum operation
+        panel.processor.run_feature("addition")
+
+        # Default operation mode is single operand mode, so the sum operation
+        # is applied to the selected groups, and we should have a new group
+        # with two signals being the sum of signals from each group:
+        # - signal 1: group 1 signal 1 + group 1 signal 2
+        # - signal 2: group 2 signal 1 + group 2 signal 2
+        assert len(model.get_groups()) == n_groups + 1
+        new_group = model.get_group_from_number(n_groups + 1)
+        assert len(new_group) == 2
+        titles = []
+        for idx, obj in enumerate(new_group):
+            pfx_orig = ", ".join(get_short_id(obj) for obj in groups[idx].get_objects())
+            titles.append((obj.title, f"Σ({pfx_orig})"))
+        check_titles(f"Single operand mode Σ[{new_group.title}]", titles)
+
+        # Remove new group
+        view.select_groups([new_group])
+        panel.remove_object(force=True)
+
+        # Store the number of groups before the operations
+        n_groups = len(model.get_groups())
+
+        # Select the two first signals of the first two groups
+        groups = [model.get_group_from_number(idx) for idx in (1, 2)]
+        objs = groups[0][:2] + groups[1][:2]
+        view.select_objects(objs)
+
+        # Perform a sum operation
+        panel.processor.run_feature("addition")
+
+        # Default operation mode is single operand mode, so the sum operation
+        # is applied to the selected signals, and we should have a new resulting
+        # signal being the sum of the selected signals added in each group:
+        # - signal added to group 1: group 1 signal 1 + group 2 signal 1
+        # - signal added to group 2: group 1 signal 2 + group 2 signal 2
+        assert len(model.get_groups()) == n_groups  # no new group
+        titles = []
+        for idx in range(1):
+            pfx_orig = ", ".join(get_short_id(obj) for obj in groups[idx][:2])
+            titles.append((groups[idx][-1].title, f"Σ({pfx_orig})"))
+        check_titles(f"Single operand mode Σ[{groups[1].title}]", titles)
+
+    Conf.proc.operation_mode.set(original_mode)
+
+
+def test_pairwise_operations_mode_compute_n_to_1() -> None:
+    """Run pairwise operations mode test scenario
+    with `compute_n_to_1` operation (e.g. sum)"""
+    h5fname = get_h5fname()
+    original_mode = Conf.proc.operation_mode.get()
+    Conf.proc.operation_mode.set("pairwise")
+
+    with datalab_app_context(exec_loop=True):
+        win = app.create(h5files=[h5fname], console=False)
+        panel = win.signalpanel
+        view, model = panel.objview, panel.objmodel
+
+        # Checking the operation mode:
+        assert is_pairwise_mode()
+
+        # Store the number of groups before the operations
+        n_groups = len(model.get_groups())
+
+        # Select the two first groups
+        groups = [model.get_group_from_number(idx) for idx in (1, 2)]
+        view.select_groups(groups)
+
+        # Checking that each group contains the same number of signals (this is
+        # required for pairwise operations - this part of the test is checking
+        # if the data file is the one we expect)
+        n_objects = len(groups[0])
+        assert all(len(group) == n_objects for group in groups)
+
+        # Perform a sum operation
+        panel.processor.run_feature("addition")
+
+        # Operation mode is now pairwise, so the sum operation is applied to the
+        # selected groups, and we should have a new group with as many signals as
+        # the original groups, each signal being the sum of the corresponding signals:
+        # - signal 1: group 1 signal 1 + group 2 signal 1
+        # - signal 2: group 1 signal 1 + group 2 signal 2
+        # ...
+        assert len(model.get_groups()) == n_groups + 1
+        new_group = model.get_group_from_number(n_groups + 1)
+        assert len(new_group.get_objects()) == n_objects
+        titles = []
+        for idx in range(len(groups[0])):
+            obj = new_group[idx]
+            pfx_orig = ", ".join(
+                get_short_id(obj) for obj in (grp[idx] for grp in groups)
+            )
+            titles.append((obj.title, f"Σ({pfx_orig})"))
+        check_titles(f"Pairwise operations mode Σ[{new_group.title}]", titles)
+
+        # Remove new group
+        view.select_groups([new_group])
+        panel.remove_object(force=True)
+
+        # Store the number of groups before the operations
+        n_groups = len(model.get_groups())
+
+        # Select two signals of the first two groups
+        groups = [model.get_group_from_number(idx) for idx in (1, 2)]
+        objs = [groups[0][0]] + [groups[0][-1]] + groups[1][-2:]
+        view.select_objects(objs)
+
+        # Perform a sum operation
+        panel.processor.run_feature("addition")
+
+        # Operation mode is now pairwise, so the sum operation is applied to the
+        # selected signals, and we should have a new group with as many signals as
+        # the selected signals, each signal being the sum of the corresponding signals:
+        # - signal 1: group 1 signal 1 + group 2 signal 1
+        # - signal 2: group 1 signal 1 + group 2 signal 2
+        # ...
+        assert len(model.get_groups()) == n_groups + 1
+        new_group = model.get_group_from_number(n_groups + 1)
+        assert len(new_group) == 2  # 2 signals were selected
+        titles = []
+        for idx, obj in enumerate(new_group):
+            pfx_orig = ", ".join(get_short_id(obj) for obj in objs[idx::2])
+            titles.append((obj.title, f"Σ({pfx_orig})"))
+        check_titles(f"Pairwise operations mode Σ[{new_group.title}]", titles)
+
+    Conf.proc.operation_mode.set(original_mode)
+
+
+def test_single_operand_mode_compute_2_to_1() -> None:
+    """Run single operand mode test scenario
+    with `compute_2_to_1` operation (e.g. difference)"""
+    h5fname = get_h5fname()
+    original_mode = Conf.proc.operation_mode.get()
+    Conf.proc.operation_mode.set("single")
+
+    with datalab_app_context(exec_loop=True):
+        win = app.create(h5files=[h5fname], console=False)
+        panel = win.signalpanel
+        view, model = panel.objview, panel.objmodel
+
+        # Checking the operation mode:
+        assert not is_pairwise_mode()
+
+        # Store the number of groups before the operations
+        n_groups = len(model.get_groups())
+
+        # Select the two first groups
+        groups = [model.get_group_from_number(idx) for idx in (1, 2)]
+        view.select_groups(groups)
+        n_objects = [len(grp) for grp in groups]
+
+        # Perform a difference operation with the first signal of the third group
+        group3 = model.get_group_from_number(3)
+        panel.processor.run_feature("difference", group3[0])
+
+        # Default operation mode is single operand mode, so we should have new signals
+        # in each selected group being the difference between the original signals and
+        # the selected signal:
+        # - in group 1:
+        #   - signal 1: group 1 signal 1 - group 3 signal 1
+        #   - signal 2: group 1 signal 2 - group 3 signal 1
+        # - in group 2:
+        #   - signal 1: group 2 signal 1 - group 3 signal 1
+        #   - signal 2: group 2 signal 2 - group 3 signal 1
+        assert len(model.get_groups()) == n_groups
+        new_objs = []
+        for i_group, group in enumerate(groups):
+            titles = []
+            for i_obj in range(n_objects[i_group]):
+                obj = group[i_obj + n_objects[i_group]]
+                titles.append(
+                    (
+                        obj.title,
+                        f"{get_short_id(group[i_obj])}-{get_short_id(group3[0])}",
+                    )
+                )
+                new_objs.append(obj)
+            check_titles(f"Single operand mode Δ[{group.title}]", titles)
+
+        # Remove new signals
+        view.select_objects(new_objs)
+        panel.remove_object(force=True)
+
+        # Store the number of groups before the operations
+        n_groups = len(model.get_groups())
+
+        # Select the two first signals of the first two groups
+        groups = [model.get_group_from_number(idx) for idx in (1, 2)]
+        objs = groups[0][:2] + groups[1][:2]
+        view.select_objects(objs)
+        n_objects = [2, 2]
+
+        # Perform a difference operation with the first signal of the third group
+        panel.processor.run_feature("difference", group3[0])
+
+        # Default operation mode is single operand mode, so we should have new signals
+        # being the difference between the original signals and the selected signal:
+        # - in group 1:
+        #   - signal 1: group 1 signal 1 - group 3 signal 1
+        #   - signal 2: group 1 signal 2 - group 3 signal 1
+        # - in group 2:
+        #   - signal 1: group 2 signal 1 - group 3 signal 1
+        #   - signal 2: group 2 signal 2 - group 3 signal 1
+        assert len(model.get_groups()) == n_groups  # no new group
+        for i_group, group in enumerate(groups):
+            titles = []
+            for i_obj in range(n_objects[i_group]):
+                obj = group[len(group) - n_objects[i_group] + i_obj]
+                titles.append(
+                    (
+                        obj.title,
+                        f"{get_short_id(group[i_obj])}-{get_short_id(group3[0])}",
+                    )
+                )
+            check_titles(f"Single operand mode Δ[{group.title}]", titles)
+
+    Conf.proc.operation_mode.set(original_mode)
+
+
+def test_pairwise_operations_mode_compute_2_to_1() -> None:
+    """Run pairwise operations mode test scenario
+    with `compute_2_to_1` operation (e.g. difference)"""
+    h5fname = get_h5fname()
+    original_mode = Conf.proc.operation_mode.get()
+    Conf.proc.operation_mode.set("pairwise")
+
+    with datalab_app_context(exec_loop=True):
+        win = app.create(h5files=[h5fname], console=False)
+        panel = win.signalpanel
+        view, model = panel.objview, panel.objmodel
+
+        # Checking the operation mode:
+        assert is_pairwise_mode()
+
+        # Store the number of groups before the operations
+        n_groups = len(model.get_groups())
+
+        # Select the two first groups
+        groups = [model.get_group_from_number(idx) for idx in (1, 2)]
+        view.select_groups(groups)
+
+        # Checking that each group contains the same number of signals (this is
+        # required for pairwise operations - this part of the test is checking
+        # if the data file is the one we expect)
+        n_objects = len(groups[0])
+        assert all(len(group) == n_objects for group in groups)
+
+        # Perform a difference operation with the third group
+        group3 = model.get_group_from_number(3)
+        assert len(group3) == n_objects
+        panel.processor.run_feature("difference", group3.get_objects())
+
+        # Operation mode is now pairwise, so the difference operation is applied to the
+        # selected groups, and we should have a new group with as many signals as the
+        # original groups, each signal being the difference of the corresponding
+        # signals:
+        # - signal 1: group 1 signal 1 - group 2 signal 1
+        # - signal 2: group 1 signal 1 - group 2 signal 2
+        # ...
+        assert len(model.get_groups()) == n_groups + 2
+        new_groups = [
+            model.get_group_from_number(idx) for idx in (n_groups + 1, n_groups + 2)
+        ]
+        execenv.print("Δ|pairwise")
+        for i_new_grp, new_grp in enumerate(new_groups):
+            assert len(new_grp.get_objects()) == n_objects
+            titles = []
+            for idx in range(n_objects):
+                obj = new_grp[idx]
+                obj1, obj2 = groups[i_new_grp][idx], group3[idx]
+                titles.append((obj.title, f"{get_short_id(obj1)}-{get_short_id(obj2)}"))
+            check_titles(f"Pairwise operations mode Δ[{new_grp.title}]", titles)
+
+        # Remove new groups
+        view.select_groups(new_groups)
+        panel.remove_object(force=True)
+
+        # Store the number of groups before the operations
+        n_groups = len(model.get_groups())
+
+        # Select two signals of the first two groups
+        groups = [model.get_group_from_number(idx) for idx in (1, 2)]
+        objs = [groups[0][0]] + [groups[0][-1]] + groups[1][-2:]
+        view.select_objects(objs)
+        n_objects = 2
+
+        # Perform a difference operation with two signals from the third group
+        objs2 = group3[:2]
+        panel.processor.run_feature("difference", objs2)
+
+        # Operation mode is now pairwise, so the difference operation is applied to the
+        # selected signals, and we should have a new group with as many signals as the
+        # selected signals, each signal being the difference of the corresponding
+        # signals:
+        # - signal 1: group 1 signal 1 - group 3 signal 1
+        # - signal 2: group 1 signal 1 - group 3 signal 2
+        # ...
+        assert len(model.get_groups()) == n_groups + 2
+        new_groups = [
+            model.get_group_from_number(idx) for idx in (n_groups + 1, n_groups + 2)
+        ]
+        i_obj1 = 0
+        execenv.print("Δ|pairwise")
+        for i_new_grp, new_grp in enumerate(new_groups):
+            assert len(new_grp.get_objects()) == n_objects
+            titles = []
+            for idx in range(n_objects):
+                obj = new_grp[idx]
+                obj1, obj2 = objs[i_obj1], objs2[idx]
+                i_obj1 += 1
+                titles.append((obj.title, f"{get_short_id(obj1)}-{get_short_id(obj2)}"))
+            check_titles(f"Pairwise operations mode Δ[{new_grp.title}]", titles)
+
+    Conf.proc.operation_mode.set(original_mode)
+
+
+if __name__ == "__main__":
+    test_single_operand_mode_compute_n_to_1()
+    test_pairwise_operations_mode_compute_n_to_1()
+    test_single_operand_mode_compute_2_to_1()
+    test_pairwise_operations_mode_compute_2_to_1()

datalab/tests/features/common/plot_results_app_test.py

@@ -0,0 +1,278 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Plot results application test:
+
+Testing the "Plot results" feature with different options:
+  - Different plot kinds (one curve per object vs. one curve per title)
+  - Different X/Y axis selections
+  - Results with and without ROIs
+  - Both signal and image panels
+  - Multiple result types (scalar and geometry results)
+  - Group selection creates a new result group
+"""
+
+# guitest: show
+
+from __future__ import annotations
+
+from typing import Generator
+
+import sigima.objects
+import sigima.params
+from sigima.tests import data as test_data
+
+from datalab.config import _
+from datalab.env import execenv
+from datalab.objectmodel import get_uuid
+from datalab.tests import datalab_test_app_context
+
+
+def iterate_noisy_signals(
+    count: int,
+    a: float,
+    sigma: float,
+) -> Generator[tuple[sigima.objects.SignalObj, float], None, None]:
+    """Generate noisy signals for testing."""
+    noiseparam = sigima.objects.NormalDistribution1DParam.create(sigma=sigma, mu=0.0)
+    param = sigima.objects.GaussParam.create(a=a)
+    for i in range(count):
+        param.sigma = 1.0 + (i * 0.1) ** 2
+        theoretical_fwhm = param.get_expected_features().fwhm
+        sig = test_data.create_noisy_signal(
+            noiseparam, param, f"Signal|fwhm_th={theoretical_fwhm:.2f}"
+        )
+        yield sig, theoretical_fwhm
+
+
+def test_plot_results_signals_one_curve_per_title():
+    """Test plot results feature with signals, one curve per title.
+
+    Create signals with single-value results (e.g., FWHM) and plot them.
+    Verify that results are created in the "Results" group.
+    """
+    with datalab_test_app_context() as win:
+        panel = win.signalpanel
+
+        with execenv.context(unattended=True):
+            x_th = []
+            y_th = []
+            for i, (sig, theoretical_fwhm) in enumerate(
+                iterate_noisy_signals(5, a=10.0, sigma=0.01)
+            ):
+                x_th.append(i)
+                y_th.append(theoretical_fwhm)
+                panel.add_object(sig)
+                # Compute FWHM using the default method (zero-crossing) which introduces
+                # a systematic ~2% error compared to the theoretical value
+                # (trade-off for noise robustness)
+                panel.processor.run_feature("fwhm", sigima.params.FWHMParam())
+
+            # Get number of groups before plotting
+            groups_before = len(panel.objmodel.get_groups())
+
+            panel.objview.selectAll()
+            panel.show_results()
+            panel.plot_results(kind="one_curve_per_title", xaxis="indices", yaxis="Δx")
+
+            # Verify a Results group was created
+            groups_after = panel.objmodel.get_groups()
+            assert len(groups_after) == groups_before + 1, (
+                f"Expected {groups_before + 1} groups, got {len(groups_after)}"
+            )
+
+            # Verify the new group is named "Results"
+            expected_title = _("Results")
+            result_group = groups_after[-1]
+            assert result_group.title == expected_title, (
+                f"Expected last group to be '{expected_title}', "
+                f"got '{result_group.title}'"
+            )
+
+            # Verify the Results group contains the result signal
+            assert len(result_group) > 0, (
+                "Results group should contain at least one result signal"
+            )
+
+            fwhm_var_th = sigima.objects.create_signal("FWHM_Theoretical", x_th, y_th)
+            panel.add_object(fwhm_var_th)
+            panel.objview.select_objects((6, 7))
+            # The observed offset should be around ~2% of the theoretical value
+
+
+def test_plot_results_images_one_curve_per_object():
+    """Test plot results feature with images, one curve per object.
+
+    Create images with multi-value results (e.g., peak detection) and plot them.
+    """
+    with datalab_test_app_context() as win:
+        panel = win.imagepanel
+
+        with execenv.context(unattended=True):
+            for i in range(3):
+                img = test_data.create_peak_image()
+                img.title = f"Peaks_{i + 1}"
+                panel.add_object(img)
+                param = sigima.params.Peak2DDetectionParam.create(create_rois=False)
+                panel.processor.run_feature("peak_detection", param)
+
+            panel.objview.selectAll()
+            panel.show_results()
+            # Use programmatic parameters: plot y vs x for each peak
+            panel.plot_results(kind="one_curve_per_object", xaxis="x", yaxis="y")
+
+
+def test_plot_results_images_with_rois():
+    """Test plot results feature with images containing ROIs.
+
+    Create images with ROIs and single-value results (e.g., centroid) and plot them.
+    """
+    with datalab_test_app_context() as win:
+        panel = win.imagepanel
+
+        with execenv.context(unattended=True):
+            size = 512
+            peak_param = test_data.PeakDataParam.create(size=size)
+            for i in range(3):
+                data, peak_coords = test_data.get_peak2d_data(peak_param)
+                img = sigima.objects.create_image(f"Image_ROI_{i + 1}", data)
+                # Add rectangular ROI to image
+                roi_coords = []
+                for xpeak, ypeak in peak_coords:
+                    roi_coords.append([xpeak, ypeak, 20])
+                img.roi = sigima.objects.create_image_roi("circle", roi_coords)
+                panel.add_object(img)
+                panel.processor.run_feature("centroid")
+
+            panel.objview.selectAll()
+            panel.show_results()
+            # Plot centroid x vs indices with ROIs
+            panel.plot_results(kind="one_curve_per_title", xaxis="indices", yaxis="x")
+
+
+def test_plot_results_with_group_selection():
+    """Test plot results with Results group.
+
+    All plot results operations should create result signals in a reusable
+    "Results" group for better organization.
+    """
+    with datalab_test_app_context() as win:
+        panel = win.signalpanel
+
+        with execenv.context(unattended=True):
+            # Create a group with signals
+            panel.add_group("Test Group")
+
+            # Add signals and compute FWHM
+            for i, (sig, _fwhm) in enumerate(
+                iterate_noisy_signals(3, a=10.0, sigma=0.01)
+            ):
+                sig.title = f"Signal_{i + 1}"
+                panel.add_object(sig)
+                panel.processor.run_feature("fwhm", sigima.params.FWHMParam())
+
+            # Get the number of groups before plotting results
+            groups_before = len(panel.objmodel.get_groups())
+
+            # Select the group (not individual objects)
+            panel.objview.select_groups([1])
+
+            # Verify the group is selected
+            sel_groups = panel.objview.get_sel_groups()
+            assert len(sel_groups) == 1, (
+                f"Expected 1 selected group, got {len(sel_groups)}"
+            )
+
+            # Plot results - this should create or reuse a "Results" group
+            panel.plot_results(kind="one_curve_per_title", xaxis="indices", yaxis="Δx")
+
+            # Verify a new group was created
+            groups_after = panel.objmodel.get_groups()
+            assert len(groups_after) == groups_before + 1, (
+                f"Expected {groups_before + 1} groups, got {len(groups_after)}"
+            )
+
+            # Check that the new group is named "Results" (or its translation)
+            expected_title = _("Results")
+            result_group = groups_after[-1]  # Last group should be Results
+            assert result_group.title == expected_title, (
+                f"Expected last group to be '{expected_title}', "
+                f"got '{result_group.title}'"
+            )
+
+            # Check that the Results group contains at least one result signal
+            assert len(result_group) > 0, (
+                "Results group should contain at least one result signal"
+            )
+
+            # Verify that the result signal title includes source object short IDs
+            result_signal = list(result_group)[0]
+            # Should contain all three source signal IDs: s001, s002, s003
+            # (s000 is the default group, so signals start at s001)
+            assert "(s001, s002, s003)" in result_signal.title, (
+                f"Result signal title should include source IDs (s001, s002, s003), "
+                f"got '{result_signal.title}'"
+            )
+
+            # Test that the group is reused: create another group and plot results
+            test_group_2 = panel.add_group("Test Group 2")
+            test_group_2_id = get_uuid(test_group_2)
+            for i, (sig, _fwhm) in enumerate(
+                iterate_noisy_signals(2, a=10.0, sigma=0.01)
+            ):
+                sig.title = f"Signal2_{i + 1}"
+                panel.add_object(sig, group_id=test_group_2_id)
+                panel.processor.run_feature("fwhm", sigima.params.FWHMParam())
+
+            # Select the second group and plot results again
+            panel.objview.select_groups([3])
+
+            # Plot results again
+            num_results_before = len(result_group)
+            panel.plot_results(kind="one_curve_per_title", xaxis="indices", yaxis="Δx")
+
+            # Verify no new group was created (reused existing Results group)
+            groups_final = panel.objmodel.get_groups()
+            assert len(groups_final) == len(groups_after), (
+                "Results group should be reused, no new group created"
+            )
+
+            # Verify more results were added to the existing Results group
+            assert len(result_group) > num_results_before, (
+                "More results should be added to the existing Results group"
+            )
+
+            # Test with many objects (more than 3) to verify "..." is used
+            test_group_3 = panel.add_group("Test Group 3")
+            test_group_3_id = get_uuid(test_group_3)
+            for i, (sig, _fwhm) in enumerate(
+                iterate_noisy_signals(5, a=10.0, sigma=0.01)
+            ):
+                sig.title = f"Signal3_{i + 1}"
+                panel.add_object(sig, group_id=test_group_3_id)
+                panel.processor.run_feature("fwhm", sigima.params.FWHMParam())
+
+            # Select the third group
+            panel.objview.select_groups([4])
+
+            # Plot results
+            num_results_before = len(result_group)
+            panel.plot_results(kind="one_curve_per_title", xaxis="indices", yaxis="Δx")
+
+            # Verify the result signal title uses "..." for many objects
+            new_results = list(result_group)[num_results_before:]
+            assert len(new_results) > 0, "Should have new results"
+            result_signal_many = new_results[0]
+            # With 5 source signals, should show first 2 IDs, "...", then last ID
+            # Format: "fwhm (s..., s..., ..., s...): ..."
+            assert ", ..., " in result_signal_many.title, (
+                f"Result signal title should use '...' before last ID, "
+                f"got '{result_signal_many.title}'"
+            )
+
+
+if __name__ == "__main__":
+    test_plot_results_signals_one_curve_per_title()
+    test_plot_results_images_one_curve_per_object()
+    test_plot_results_images_with_rois()
+    test_plot_results_with_group_selection()