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

datalab/tests/features/signal/pulse_features_app_test.py

@@ -0,0 +1,118 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Pulse features application test.
+"""
+
+# pylint: disable=invalid-name  # Allows short reference names like x, y, ...
+# guitest: show
+
+from sigima.objects import (
+    SignalObj,
+    TableKind,
+    TableResult,
+    create_signal_from_param,
+    create_signal_roi,
+)
+from sigima.params import PulseFeaturesParam
+from sigima.tests.helpers import check_scalar_result
+from sigima.tests.signal.pulse.pulse_unit_test import (
+    create_test_square_params,
+    create_test_step_params,
+)
+
+from datalab.adapters_metadata import TableAdapter
+from datalab.gui.panel.signal import SignalPanel
+from datalab.tests import datalab_test_app_context
+from datalab.utils import qthelpers as qth
+
+
+def __check_table(obj: SignalObj) -> TableResult:
+    """Check that the object has a pulse features table."""
+    tables = list(TableAdapter.iterate_from_obj(obj))
+    assert len(tables) == 1
+    table = tables[0].result
+    assert table.kind == TableKind.PULSE_FEATURES
+    return table
+
+
+def __add_signal_and_check_pulse_features(
+    panel: SignalPanel, obj: SignalObj, assertions: dict[str, float]
+) -> None:
+    """Add signal to the application and check that pulse features are extracted."""
+    panel.add_object(obj)
+    param = PulseFeaturesParam()
+    param.update_from_obj(obj)
+    panel.processor.run_feature("extract_pulse_features", param)
+    table = __check_table(obj)
+    for name, expected_value in assertions.items():
+        if isinstance(expected_value, str):
+            assert table[name][0] == expected_value
+        else:
+            check_scalar_result(name, table[name][0], expected_value, rtol=1e-2)
+
+
+def test_pulse_features_app():
+    """Pulse features application test."""
+    with datalab_test_app_context(console=False) as win:
+        panel = win.signalpanel
+
+        # Add first signal and extract features
+        s1 = create_signal_from_param(create_test_step_params())
+        __add_signal_and_check_pulse_features(
+            panel,
+            s1,
+            {
+                "signal_shape": "step",
+                "polarity": 1.0,
+                "amplitude": 4.9,
+                "rise_time": 1.5,
+            },
+        )
+
+        # Add second signal and extract features
+        s2 = create_signal_from_param(create_test_square_params())
+        __add_signal_and_check_pulse_features(
+            panel,
+            s2,
+            {
+                "signal_shape": "square",
+                "polarity": 1.0,
+                "amplitude": 4.94,
+                "rise_time": 1.60,
+                "fall_time": 3.95,
+                "fwhm": 5.49,
+            },
+        )
+
+        # Select the two signals and show the results table
+        panel.objview.select_objects([s1, s2])
+        panel.show_results()
+
+        # Define a ROI, just to test that it works (⚠️ it makes no sense here):
+        # it tests that the "comparison rows" features work correctly with ROIs.
+        # TODO: Maybe we should test this part in a more appropriate place, like in
+        # a test for the "statistics" feature.
+        roi = create_signal_roi([[0.650227, 5.8], [1.1596, 9.09509]])
+        s1.roi = roi
+        s2.roi = roi.copy()
+        panel.processor.run_feature("stats")
+
+        panel.show_results()
+
+
+def pulse_features_screenshot():
+    """Generate pulse features screenshot."""
+    with datalab_test_app_context(size=(1400, 600), console=False) as win:
+        panel = win.signalpanel
+        s1 = create_signal_from_param(create_test_step_params())
+        panel.add_object(s1)
+        param = PulseFeaturesParam()
+        param.update_from_obj(s1)
+        panel.processor.run_feature("extract_pulse_features", param)
+        qth.grab_save_window(win.signalview, "s_pulse_features")
+
+
+if __name__ == "__main__":
+    # test_pulse_features_app()
+    pulse_features_screenshot()

datalab/tests/features/signal/pulse_features_roi_app_test.py

@@ -0,0 +1,55 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Pulse features with ROIs application test.
+"""
+
+# pylint: disable=invalid-name  # Allows short reference names like x, y, ...
+# guitest: show
+
+from __future__ import annotations
+
+from sigima.objects import SignalObj, TableResult
+from sigima.params import PulseFeaturesParam
+from sigima.tests.signal.pulse.pulse_features_roi_unit_test import (
+    check_results_equal,
+    generate_source_signal,
+)
+
+from datalab.gui.panel.signal import SignalPanel
+from datalab.tests import datalab_test_app_context
+
+
+def __extract_pulse_features(panel: SignalPanel, obj: SignalObj) -> TableResult:
+    """Extract pulse features."""
+    panel.objview.select_objects([obj])
+    param = PulseFeaturesParam()
+    param.update_from_obj(obj)
+    rdata = panel.processor.run_feature("extract_pulse_features", param)
+    assert len(rdata.results) == 1
+    return rdata.results[0]
+
+
+def test_pulse_features_roi_app():
+    """Pulse features with ROIs application test."""
+    with datalab_test_app_context(console=False) as win:
+        panel = win.signalpanel
+
+        # Test signal with multiple ROIs defined around peaks of the spectrum
+        sig = generate_source_signal()
+        panel.add_object(sig)
+        pf_sig = __extract_pulse_features(panel, sig)
+
+        # Extract ROIs in separate signals and test each one
+        panel.processor.run_feature("extract_roi", params=sig.roi.to_params(sig))
+        pf_extracted_sigs = []
+        for nb_sig in (2, 3, 4):
+            extracted_sig = panel.objmodel.get_object_from_number(nb_sig)
+            pf_extracted_sig = __extract_pulse_features(panel, extracted_sig)
+            pf_extracted_sigs.append(pf_extracted_sig)
+
+        check_results_equal(pf_sig, pf_extracted_sigs)
+
+
+if __name__ == "__main__":
+    test_pulse_features_roi_app()

datalab/tests/features/signal/roi_app_test.py

@@ -0,0 +1,78 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""Signal 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 SignalROI, create_signal_roi
+from sigima.tests.data import create_paracetamol_signal
+
+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.signal import SignalPanel
+
+SIZE = 200
+
+# Signal ROIs:
+SROI1 = [26, 41]
+SROI2 = [125, 146]
+
+
+def __run_signal_computations(panel: SignalPanel):
+    """Test all signal features related to ROI"""
+    panel.processor.run_feature("fwhm", sigima_param.FWHMParam())
+    panel.processor.run_feature("fw1e2")
+    panel.processor.run_feature("histogram", sigima_param.HistogramParam())
+    roi = SignalROI()
+    panel.processor.compute_roi_extraction(roi)
+
+
+def test_signal_roi_app(screenshots: bool = False) -> None:
+    """Run Signal ROI application test scenario
+
+    Args:
+        screenshots: If True, take screenshots during the test.
+    """
+    with datalab_test_app_context(console=False) as win:
+        execenv.print("Signal ROI application test:")
+        panel = win.signalpanel
+        sig1 = create_paracetamol_signal(SIZE)
+        panel.add_object(sig1)
+        __run_signal_computations(panel)
+        sig2 = create_paracetamol_signal(SIZE)
+        sig2.roi = create_signal_roi([SROI1, SROI2], indices=True)
+        for singleobj in (False, True):
+            with Conf.proc.extract_roi_singleobj.temp(singleobj):
+                sig2_i = sig2.copy()
+                panel.add_object(sig2_i)
+                helpers.print_obj_data_dimensions(sig2_i, indent=1)
+                panel.processor.edit_roi_graphically()
+                if screenshots:
+                    win.statusBar().hide()
+                    win.take_screenshot("s_roi_signal")
+                __run_signal_computations(panel)
+
+
+@pytest.mark.skip(reason="This test is only for manual testing")
+def test_signal_roi_basic_app():
+    """Run Signal ROI basic application test scenario"""
+    with datalab_test_app_context(console=False) as win:
+        panel = win.signalpanel
+        sig1 = create_paracetamol_signal(SIZE)
+        panel.add_object(sig1)
+        panel.processor.edit_roi_graphically()
+
+
+if __name__ == "__main__":
+    test_signal_roi_basic_app()
+    test_signal_roi_app(screenshots=False)

datalab/tests/features/signal/roi_manipulation_app_test.py

@@ -0,0 +1,261 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""Signal 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 create_signal_roi
+from sigima.tests.data import create_paracetamol_signal
+
+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.signal import SignalPanel
+
+SIZE = 200
+
+# Signal ROIs:
+SROI1 = [26, 41]
+SROI2 = [125, 146]
+SROI3 = [60, 80]
+
+
+def test_signal_roi_copy_paste():
+    """Test signal ROI copy and paste functionality"""
+    with datalab_test_app_context(console=False) as win:
+        execenv.print("Signal ROI Copy/Paste test:")
+        panel: SignalPanel = win.signalpanel
+
+        # Create first signal with ROI
+        sig1 = create_paracetamol_signal(SIZE)
+        sig1.title = "Signal with ROI"
+        roi1 = create_signal_roi([SROI1, SROI2], indices=True)
+        sig1.roi = roi1
+        panel.add_object(sig1)
+
+        # Create second signal without ROI
+        sig2 = create_paracetamol_signal(SIZE)
+        sig2.title = "Signal without ROI"
+        panel.add_object(sig2)
+
+        # Create third signal without ROI
+        sig3 = create_paracetamol_signal(SIZE)
+        sig3.title = "Signal without ROI 2"
+        panel.add_object(sig3)
+
+        execenv.print("  Initial state:")
+        execenv.print(f"    Signal 1 ROI: {sig1.roi is not None}")
+        execenv.print(f"    Signal 2 ROI: {sig2.roi is not None}")
+        execenv.print(f"    Signal 3 ROI: {sig3.roi is not None}")
+
+        # Select first signal and copy its ROI
+        panel.objview.set_current_item_id(get_uuid(sig1))
+        panel.copy_roi()
+        execenv.print("  Copied ROI from Signal 1")
+
+        # Select second signal and paste ROI
+        panel.objview.set_current_item_id(get_uuid(sig2))
+        panel.paste_roi()
+        execenv.print("  Pasted ROI to Signal 2")
+
+        # Verify that sig2 now has the same ROI as sig1
+        assert sig2.roi is not None, "Signal 2 should have ROI after paste"
+        assert len(sig2.roi) == len(sig1.roi), "ROI should have same number of regions"
+        execenv.print(f"    Signal 2 now has {len(sig2.roi)} ROI regions")
+
+        # Select third signal and paste ROI (should create new ROI)
+        panel.objview.set_current_item_id(get_uuid(sig3))
+        panel.paste_roi()
+        execenv.print("  Pasted ROI to Signal 3")
+
+        assert sig3.roi is not None, "Signal 3 should have ROI after paste"
+        assert len(sig3.roi) == len(sig1.roi), "ROI should have same number of regions"
+        execenv.print(f"    Signal 3 now has {len(sig3.roi)} ROI regions")
+
+        # Test pasting to signal that already has ROI (should combine)
+        panel.objview.set_current_item_id(get_uuid(sig2))
+        panel.copy_roi()
+        execenv.print("  Copied ROI from Signal 2")
+
+        # Add a different ROI to sig1
+        roi_new = create_signal_roi([SROI3], indices=True)
+        sig1.roi = sig1.roi.combine_with(roi_new)
+        original_roi_count = len(sig1.roi)
+        execenv.print(f"    Signal 1 now has {original_roi_count} ROI regions")
+
+        # Paste the ROI from sig2 into sig1 (should combine)
+        panel.objview.set_current_item_id(get_uuid(sig1))
+        panel.paste_roi()
+        execenv.print("  Pasted ROI to Signal 1 (should combine)")
+
+        # Get fresh reference to sig1 from panel
+        sig1_updated = panel.objmodel[get_uuid(sig1)]
+        assert sig1_updated.roi is not None, "Signal 1 should still have ROI"
+        # After combining, sig1 should have more regions than before
+        assert len(sig1_updated.roi) >= original_roi_count, (
+            f"Expected at least {original_roi_count} ROI regions, "
+            f"got {len(sig1_updated.roi)}"
+        )
+        execenv.print(
+            f"    Signal 1 now has {len(sig1_updated.roi)} ROI regions (combined)"
+        )
+
+        execenv.print("  ✓ Signal ROI copy/paste test passed")
+
+
+def test_signal_roi_copy_paste_multiple_selection():
+    """Test signal ROI paste to multiple selected signals"""
+    with datalab_test_app_context(console=False) as win:
+        execenv.print("Signal ROI Copy/Paste with multiple selection test:")
+        panel: SignalPanel = win.signalpanel
+
+        # Create source signal with ROI
+        sig_src = create_paracetamol_signal(SIZE)
+        sig_src.title = "Source with ROI"
+        roi = create_signal_roi([SROI1, SROI2], indices=True)
+        sig_src.roi = roi
+        panel.add_object(sig_src)
+
+        # Create multiple target signals without ROI
+        target_signals = []
+        for i in range(3):
+            sig = create_paracetamol_signal(SIZE)
+            sig.title = f"Target signal {i + 1}"
+            panel.add_object(sig)
+            target_signals.append(sig)
+
+        execenv.print(f"  Created {len(target_signals)} target signals")
+
+        # Copy ROI from source
+        panel.objview.set_current_item_id(get_uuid(sig_src))
+        panel.copy_roi()
+        execenv.print("  Copied ROI from source signal")
+
+        # Select all target signals
+        target_uuids = [get_uuid(sig) for sig in target_signals]
+        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 signals")
+
+        # Paste ROI to all selected signals
+        panel.paste_roi()
+        execenv.print("  Pasted ROI to all selected signals")
+
+        # Verify all target signals have ROI
+        for i, sig in enumerate(target_signals):
+            assert sig.roi is not None, f"Target signal {i + 1} should have ROI"
+            assert len(sig.roi) == len(sig_src.roi), (
+                f"Target signal {i + 1} should have {len(sig_src.roi)} ROI regions"
+            )
+            execenv.print(f"    Target signal {i + 1}: {len(sig.roi)} ROI regions ✓")
+
+        execenv.print("  ✓ Multiple selection paste test passed")
+
+
+def test_signal_roi_import_export():
+    """Test signal ROI import and export to/from file functionality"""
+    with datalab_test_app_context(console=False) as win:
+        execenv.print("Signal ROI Import/Export test:")
+        panel: SignalPanel = win.signalpanel
+
+        # Create first signal with ROI
+        sig1 = create_paracetamol_signal(SIZE)
+        sig1.title = "Signal with ROI"
+        roi1 = create_signal_roi([SROI1, SROI2, SROI3], indices=True)
+        sig1.roi = roi1
+        panel.add_object(sig1)
+
+        original_roi_count = len(sig1.roi)
+        execenv.print(f"  Signal 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 signal and export its ROI
+            panel.objview.set_current_item_id(get_uuid(sig1))
+            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 signal without ROI
+            sig2 = create_paracetamol_signal(SIZE)
+            sig2.title = "Signal without ROI"
+            panel.add_object(sig2)
+            assert sig2.roi is None, "Signal 2 should not have ROI initially"
+
+            # Import ROI from file to second signal
+            panel.objview.set_current_item_id(get_uuid(sig2))
+            panel.import_roi_from_file(roi_file)
+            execenv.print("  Imported ROI to Signal 2")
+
+            # Get fresh reference to sig2 from panel
+            sig2_updated = panel.objmodel[get_uuid(sig2)]
+            assert sig2_updated.roi is not None, "Signal 2 should have ROI after import"
+            assert len(sig2_updated.roi) == original_roi_count, (
+                f"Imported ROI should have {original_roi_count} regions"
+            )
+            execenv.print(f"  ✓ Signal 2 now has {len(sig2_updated.roi)} ROI regions")
+
+            # Test importing ROI to signal that already has ROI (should combine)
+            sig3 = create_paracetamol_signal(SIZE)
+            sig3.title = "Signal with existing ROI"
+            roi3 = create_signal_roi([[90, 110]], indices=True)
+            sig3.roi = roi3
+            panel.add_object(sig3)
+            initial_roi_count = len(sig3.roi)
+            execenv.print(f"  Signal 3 has {initial_roi_count} ROI region initially")
+
+            # Import ROI (should combine with existing)
+            panel.objview.set_current_item_id(get_uuid(sig3))
+            panel.import_roi_from_file(roi_file)
+            execenv.print("  Imported ROI to Signal 3 (should combine)")
+
+            # Get fresh reference to sig3 from panel
+            sig3_updated = panel.objmodel[get_uuid(sig3)]
+            assert sig3_updated.roi is not None, "Signal 3 should still have ROI"
+            # After combining, should have more regions
+            assert len(sig3_updated.roi) >= initial_roi_count, (
+                f"Expected at least {initial_roi_count} ROI regions, "
+                f"got {len(sig3_updated.roi)}"
+            )
+            execenv.print(
+                f"  ✓ Signal 3 now has {len(sig3_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("  ✓ Signal ROI import/export test passed")
+
+
+if __name__ == "__main__":
+    test_signal_roi_copy_paste()
+    test_signal_roi_copy_paste_multiple_selection()
+    test_signal_roi_import_export()

datalab/tests/features/signal/select_xy_cursor_unit_test.py

@@ -0,0 +1,46 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Signal horizontal or vertical cursor selection unit test.
+"""
+
+# pylint: disable=invalid-name  # Allows short reference names like x, y, ...
+# guitest: show
+
+from typing import Literal
+
+import numpy as np
+import pytest
+from guidata.qthelpers import exec_dialog, qt_app_context
+from sigima.tests.data import create_paracetamol_signal
+from sigima.tools.signal.features import find_x_values_at_y
+
+from datalab.env import execenv
+from datalab.widgets.signalcursor import SignalCursorDialog
+
+
+@pytest.mark.parametrize("cursor_orientation", ["horizontal", "vertical"])
+def test_signal_cursor_selection(
+    cursor_orientation: Literal["horizontal", "vertical"],
+) -> None:
+    """Parametrized signal cursor selection unit test."""
+    sig = create_paracetamol_signal()
+    with qt_app_context():
+        dlg = SignalCursorDialog(signal=sig, cursor_orientation=cursor_orientation)
+        dlg.resize(640, 480)
+        dlg.setObjectName(dlg.objectName() + "_00")  # to avoid timestamp suffix
+        exec_dialog(dlg)
+    x, y = dlg.get_cursor_position()
+    if cursor_orientation == "horizontal":
+        execenv.print(f"X value: {x}")
+        x_sig = find_x_values_at_y(sig.x, sig.y, y)[0]
+        assert x == x_sig, f"Expected {x_sig}, got {x}"
+    else:
+        execenv.print(f"Y value: {y}")
+        y_sig = sig.y[np.searchsorted(sig.x, x)]
+        assert y == y_sig, f"Expected {y_sig}, got {y}"
+
+
+if __name__ == "__main__":
+    test_signal_cursor_selection(cursor_orientation="horizontal")
+    test_signal_cursor_selection(cursor_orientation="vertical")

datalab/tests/features/signal/signalpeakdetection_dialog_test.py

@@ -0,0 +1,33 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Signal peak detection dialog 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 get_test_signal
+
+from datalab.env import execenv
+from datalab.widgets.signalpeak import SignalPeakDetectionDialog
+
+
+def test_peak1d_dialog():
+    """Signal peak dialog test"""
+    with qt_app_context():
+        s = get_test_signal("paracetamol.txt")
+        dlg = SignalPeakDetectionDialog(s)
+        dlg.resize(640, 300)
+        plot = dlg.get_plot()
+        plot.set_axis_limits(plot.xBottom, 16, 30)
+        dlg.setObjectName(dlg.objectName() + "_00")  # to avoid timestamp suffix
+        exec_dialog(dlg)
+    execenv.print("peaks:")
+    execenv.pprint(dlg.get_peaks())
+    execenv.pprint(dlg.get_min_dist())
+
+
+if __name__ == "__main__":
+    test_peak1d_dialog()

datalab/tests/features/signal/signals_to_image_app_test.py

@@ -0,0 +1,98 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""Signals to image conversion application test"""
+
+# pylint: disable=invalid-name  # Allows short reference names like x, y, ...
+# guitest: show
+
+from __future__ import annotations
+
+import sigima.params
+from sigima.enums import NormalizationMethod, SignalsToImageOrientation
+from sigima.objects import SignalTypes
+from sigima.tests.data import create_periodic_signal
+
+from datalab.env import execenv
+from datalab.tests import datalab_test_app_context
+
+SIZE = 100
+N_SIGNALS = 10
+
+
+def test_signals_to_image_app(screenshots: bool = False) -> None:
+    """Run signals to image conversion application test scenario
+
+    Args:
+        screenshots: If True, take screenshots during the test.
+    """
+    with datalab_test_app_context(console=False) as win:
+        execenv.print("Signals to image conversion application test:")
+
+        # Create multiple test signals
+        for i in range(N_SIGNALS):
+            sig = create_periodic_signal(
+                SignalTypes.SINE, freq=50.0 + i * 10.0, size=SIZE, a=(i + 1) * 0.1
+            )
+            sig.title = f"Signal {i + 1}"
+            win.signalpanel.add_object(sig)
+
+        # Select all signals
+        win.signalpanel.objview.select_objects(list(range(1, N_SIGNALS + 1)))
+
+        # Test without normalization, as rows
+        p = sigima.params.SignalsToImageParam()
+        p.orientation = SignalsToImageOrientation.ROWS
+        p.normalize = False
+        win.signalpanel.processor.run_feature("signals_to_image", p)
+
+        if screenshots:
+            win.statusBar().hide()
+            win.take_screenshot("s_signals_to_image_rows")
+
+        # Select all signals again
+        win.set_current_panel("signal")
+        win.signalpanel.objview.select_objects(list(range(1, N_SIGNALS + 1)))
+
+        # Test without normalization, as columns
+        p.orientation = SignalsToImageOrientation.COLUMNS
+        win.signalpanel.processor.run_feature("signals_to_image", p)
+
+        if screenshots:
+            win.take_screenshot("s_signals_to_image_columns")
+
+        # Select all signals again
+        win.set_current_panel("signal")
+        win.signalpanel.objview.select_objects(list(range(1, N_SIGNALS + 1)))
+
+        # Test with normalization, as rows
+        p.orientation = SignalsToImageOrientation.ROWS
+        p.normalize = True
+        p.normalize_method = NormalizationMethod.MAXIMUM
+        win.signalpanel.processor.run_feature("signals_to_image", p)
+
+        if screenshots:
+            win.take_screenshot("s_signals_to_image_normalized")
+
+        # Verify that images were created
+        assert len(win.imagepanel) == 3, f"Expected 3 images, got {len(win.imagepanel)}"
+
+        # Switch to image panel to verify dimensions
+        win.set_current_panel("image")
+
+        # Verify image dimensions - get objects directly from object model
+        images = win.imagepanel.objmodel.get_all_objects()
+        assert len(images) == 3, f"Expected 3 images in object model, got {len(images)}"
+        assert images[0].data.shape == (
+            N_SIGNALS,
+            SIZE,
+        ), f"Expected shape ({N_SIGNALS}, {SIZE}), got {images[0].data.shape}"
+        assert images[1].data.shape == (
+            SIZE,
+            N_SIGNALS,
+        ), f"Expected shape ({SIZE}, {N_SIGNALS}), got {images[1].data.shape}"
+
+        execenv.print("  ✓ Signals to image conversion test passed")
+
+
+if __name__ == "__main__":
+    test_signals_to_image_app(screenshots=False)