sigima 0.0.1.dev0__py3-none-any.whl → 1.0.0__py3-none-any.whl

sigima/tests/io/imageio_formats_test.py

@@ -0,0 +1,41 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Testing image format handling based on the `imageio_formats` option.
+"""
+
+# Note about the modules imported outside top-level:
+#
+# We want to keep the import order under control, so we import the modules only when
+# they are needed, especially for the dynamically defined image formats in the `formats`
+# module. This way, we can ensure that the formats are defined just before we use them
+# in the tests. This is particularly useful for testing the `imageio_formats` option
+# that allows users to set custom image I/O formats.
+
+
+def get_image_formats():
+    """Get image formats"""
+    # pylint: disable=import-outside-toplevel
+    from sigima.io.image import formats
+
+    return [clname for clname in dir(formats) if clname.endswith("ImageFormat")]
+
+
+def test_imageio_formats_option():
+    """Set other image I/O formats"""
+    # pylint: disable=import-outside-toplevel
+    from sigima.config import options
+    from sigima.io.image import formats
+
+    # Set custom image I/O formats
+    options.imageio_formats.set((("*.rec", "PCO Camera REC"),))
+    # Check if the formats are set correctly
+    assert hasattr(formats, "RECImageFormat"), "RECImageFormat not found in formats"
+
+
+if __name__ == "__main__":
+    from pprint import pprint
+
+    pprint(get_image_formats())
+    test_imageio_formats_option()
+    pprint(get_image_formats())

sigima/tests/io/ioregistry_unit_test.py

@@ -0,0 +1,69 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+I/O registry unit test
+"""
+
+from __future__ import annotations
+
+from sigima.io import ImageIORegistry, SignalIORegistry
+from sigima.io.base import IOAction, get_file_extensions
+from sigima.tests.env import execenv
+
+
+def test_get_file_extensions() -> None:
+    """Test function `get_file_extensions` for I/O registries"""
+    extensions = "*.bmp *.jpg *.jpeg *.png *.tif *.tiff *.jp2"
+    assert get_file_extensions(extensions) == [
+        "bmp",
+        "jp2",
+        "jpeg",
+        "jpg",
+        "png",
+        "tif",
+        "tiff",
+    ], "get_file_extensions did not return expected list of extensions"
+
+
+def __test_io_registry(registry: SignalIORegistry | ImageIORegistry) -> None:
+    """Test I/O registry functionality
+
+    Args:
+        registry: I/O registry to test
+    """
+    execenv.print("*" * 80)
+    execenv.print(f"Testing I/O registry: {registry.__name__}")
+    execenv.print("*" * 80)
+    formats = registry.get_formats()
+    execenv.print(f"Supported formats: {len(formats)}")
+    execenv.print(registry.get_format_info(mode="text"))
+    load_filters = registry.get_filters(IOAction.LOAD)
+    assert (
+        len(load_filters.splitlines())
+        == len([fmt for fmt in formats if fmt.info.readable]) + 1
+    ), "Number of load filters does not match number of formats"
+    save_filters = registry.get_filters(IOAction.SAVE)
+    assert (
+        len(save_filters.splitlines())
+        == len([fmt for fmt in formats if fmt.info.writeable]) + 1
+    ), "Number of save filters does not match number of formats"
+    execenv.print(f"Readable formats: {load_filters}")
+    assert load_filters == registry.get_read_filters()
+    execenv.print(f"Writable formats: {save_filters}")
+    assert save_filters == registry.get_write_filters()
+
+
+def test_signal_io_registry() -> None:
+    """Test Signal I/O registry functionality"""
+    __test_io_registry(SignalIORegistry)
+
+
+def test_image_io_registry() -> None:
+    """Test Image I/O registry functionality"""
+    __test_io_registry(ImageIORegistry)
+
+
+if __name__ == "__main__":
+    test_signal_io_registry()
+    test_image_io_registry()
+    test_get_file_extensions()

sigima/tests/io/objmeta_unit_test.py

@@ -0,0 +1,87 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+I/O metadata and ROI functions
+"""
+
+from __future__ import annotations
+
+import os.path as osp
+
+from sigima.io.common.objmeta import (
+    read_metadata,
+    read_roi,
+    write_metadata,
+    write_roi,
+)
+from sigima.tests.data import (
+    create_multigaussian_image,
+    create_paracetamol_signal,
+    create_test_image_rois,
+    create_test_metadata,
+    create_test_signal_rois,
+)
+from sigima.tests.env import execenv
+from sigima.tests.helpers import WorkdirRestoringTempDir, compare_metadata
+
+
+def test_signal_roi_io():
+    """Test reading and writing of signal ROIs."""
+    execenv.print("==============================================")
+    execenv.print("Testing signal ROI I/O")
+    execenv.print("==============================================")
+    with WorkdirRestoringTempDir() as temp_dir:
+        obj = create_paracetamol_signal()
+        for orig_roi in create_test_signal_rois(obj):
+            fname = osp.join(temp_dir, "test_signal_roi.json")
+            write_roi(fname, orig_roi)
+            roi = read_roi(fname)
+            try:
+                compare_metadata(roi.to_dict(), orig_roi.to_dict(), raise_on_diff=True)
+            except AssertionError as exc:
+                raise AssertionError(
+                    "Signal ROI read from file does not match original"
+                ) from exc
+
+
+def test_image_roi_io():
+    """Test reading and writing of image ROIs."""
+    execenv.print("==============================================")
+    execenv.print("Testing image ROI I/O")
+    execenv.print("==============================================")
+    with WorkdirRestoringTempDir() as temp_dir:
+        obj = create_multigaussian_image()
+        for orig_roi in create_test_image_rois(obj):
+            fname = osp.join(temp_dir, "test_image_roi.json")
+            write_roi(fname, orig_roi)
+            roi = read_roi(fname)
+            try:
+                compare_metadata(roi.to_dict(), orig_roi.to_dict(), raise_on_diff=True)
+            except AssertionError as exc:
+                raise AssertionError(
+                    "Image ROI read from file does not match original"
+                ) from exc
+
+
+def test_metadata_io():
+    """Test reading and writing of metadata."""
+    execenv.print("==============================================")
+    execenv.print("Testing metadata I/O")
+    execenv.print("==============================================")
+    with WorkdirRestoringTempDir() as temp_dir:
+        orig_metadata = create_test_metadata()
+        fname = osp.join(temp_dir, "test_metadata.json")
+        write_metadata(fname, orig_metadata)
+        metadata = read_metadata(fname)
+        try:
+            compare_metadata(metadata, orig_metadata, raise_on_diff=True)
+        except AssertionError as exc:
+            raise AssertionError(
+                "Metadata read from file does not match original"
+            ) from exc
+
+
+if __name__ == "__main__":
+    test_signal_roi_io()
+    test_image_roi_io()
+    test_metadata_io()

sigima/tests/io/readobj_unit_test.py

@@ -0,0 +1,130 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+I/O test
+
+Testing `sigima` specific formats.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+import pytest
+
+from sigima.io import read_images, read_signals
+from sigima.io.ftlab import FTLabImageFile, imread_ftlabima, sigread_ftlabsig
+from sigima.objects import ImageObj, SignalObj
+from sigima.tests import guiutils, helpers
+from sigima.tests.env import execenv
+
+
+def __read_objs(fname: str) -> list[ImageObj] | list[SignalObj]:
+    """Read objects from a file"""
+    if "curve" in fname:
+        objs = read_signals(fname)
+    else:
+        objs = read_images(fname)
+    for obj in objs:
+        if np.all(np.isnan(obj.data)):
+            raise ValueError("Data is all NaNs")
+    for obj in objs:
+        execenv.print(obj)
+    return objs
+
+
+def __read_and_view_objs(
+    fname: str | None = None, title: str | None = None
+) -> list[ImageObj]:
+    """Read and view objects from a file
+
+    Args:
+        fname: Name of the file to open.
+        title: Title for the view.
+
+    Returns:
+        List of ImageObj or SignalObj read from the file.
+    """
+    objs = __read_objs(fname)
+    guiutils.view_curves_and_images_if_gui(objs, title=f"{title} - {fname}")
+    return objs
+
+
+@helpers.try_open_test_data("Testing TXT file reader", "*.txt")
+def test_open_txt(fname: str | None = None, title: str | None = None) -> None:
+    """Testing TXT files."""
+    __read_and_view_objs(fname, title)
+
+
+@helpers.try_open_test_data("Testing CSV file reader", "*.csv")
+def test_open_csv(fname: str | None = None, title: str | None = None) -> None:
+    """Testing CSV files."""
+    __read_and_view_objs(fname, title)
+
+
+@helpers.try_open_test_data("Testing FTLab signal file reader", "*.sig")
+def test_open_sigdata(fname: str | None = None, title: str | None = None) -> None:
+    """Testing FTLab signal files."""
+    __read_and_view_objs(fname, title)
+
+    # Read the FTLab signal file and compare the data with the reference
+    data = sigread_ftlabsig(fname)
+    ref = read_signals(fname.replace(".sig", ".npy"))[0]
+    helpers.check_array_result(f"{fname}", data, ref.xydata)
+
+
+@helpers.try_open_test_data("Testing MCA file reader", "*.mca")
+def test_open_mca(fname: str | None = None, title: str | None = None) -> None:
+    """Testing MCA files."""
+    __read_and_view_objs(fname, title)
+
+
+@helpers.try_open_test_data("Testing MAT-File reader", "*.mat")
+def test_open_mat(fname: str | None = None, title: str | None = None) -> None:
+    """Testing MAT files."""
+    __read_and_view_objs(fname, title)
+
+
+@helpers.try_open_test_data("Testing SIF file handler", "*.sif")
+def test_open_sif(fname: str | None = None, title: str | None = None) -> None:
+    """Testing SIF files."""
+    __read_and_view_objs(fname, title)
+
+
+@helpers.try_open_test_data("Testing SCOR-DATA file handler", "*.scor-data")
+def test_open_scordata(fname: str | None = None, title: str | None = None) -> None:
+    """Testing SCOR-DATA files."""
+    __read_and_view_objs(fname, title)
+
+
+@helpers.try_open_test_data("Testing FTLab image file handler", "*.ima")
+def test_open_imadata(fname: str | None = None, title: str | None = None) -> None:
+    """Testing FTLab image files."""
+    __read_and_view_objs(fname, title)
+
+    # Read the FTLab image file and show the data
+    ftlab_file = FTLabImageFile(fname)
+    ftlab_file.read()
+    execenv.print(ftlab_file)
+
+    # Read the FTLab image file and compare the data with the reference
+    data = imread_ftlabima(fname)
+    ref = read_images(fname.replace(".ima", ".npy"))[0]
+    helpers.check_array_result(f"{fname}", data, ref.data)
+
+
+@pytest.mark.gui
+def test_read_obj_interactive() -> None:
+    """Interactive test for I/O: read and view objects from various formats."""
+    guiutils.enable_gui()
+    test_open_txt()
+    test_open_csv()
+    test_open_sigdata()
+    test_open_mca()
+    test_open_mat()
+    test_open_sif()
+    test_open_scordata()
+    test_open_imadata()
+
+
+if __name__ == "__main__":
+    test_read_obj_interactive()

sigima/tests/io/readwriteobj_unit_test.py

@@ -0,0 +1,67 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+I/O test
+
+Testing `sigima` specific formats.
+"""
+
+from __future__ import annotations
+
+import os.path as osp
+
+from sigima.io.image import ImageIORegistry
+from sigima.io.signal import SignalIORegistry
+from sigima.tests.env import execenv
+from sigima.tests.helpers import WorkdirRestoringTempDir, read_test_objects, reduce_path
+
+
+def __testfunc(
+    title: str,
+    registry: SignalIORegistry | ImageIORegistry,
+    pattern: str = "*.*",
+    in_folder: str | None = None,
+) -> None:
+    """Test I/O features: read and write objects, and check registry functionality
+
+    Args:
+        title: Title of the test
+        registry: I/O registry to use
+        pattern: File name pattern to match
+        in_folder: Folder to search for test files
+
+    Raises:
+        NotImplementedError: if format is not supported
+    """
+    execenv.print(f"  {title}:")
+    with WorkdirRestoringTempDir() as tmpdir:
+        # os.startfile(tmpdir)
+        objects = {}
+        for fname, obj in read_test_objects(registry, pattern, in_folder):
+            label = f"    Opening {reduce_path(fname)}"
+            execenv.print(label + ": ", end="")
+            if obj is None:
+                execenv.print("Skipped (not implemented)")
+            else:
+                execenv.print("OK")
+                objects[fname] = obj
+        execenv.print("    Saving:")
+        for fname, obj in objects.items():
+            path = osp.join(tmpdir, osp.basename(fname))
+            try:
+                execenv.print(f"      {path}: ", end="")
+                registry.write(path, obj)
+                execenv.print("OK")
+            except NotImplementedError:
+                execenv.print("Skipped (not implemented)")
+
+
+def test_read_write_obj():
+    """I/O test: read and write objects, check registry functionality"""
+    execenv.print("I/O unit test:")
+    __testfunc("Signals", SignalIORegistry)
+    __testfunc("Images", ImageIORegistry)
+
+
+if __name__ == "__main__":
+    test_read_write_obj()

sigima/tests/signal/analysis_unit_test.py

@@ -0,0 +1,135 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Unit tests for signal analysis features
+---------------------------------------
+
+Features from the "Analysis" menu are covered by this test.
+The "Analysis" menu contains functions to compute signal properties like
+bandwidth, ENOB, etc.
+"""
+
+# pylint: disable=invalid-name  # Allows short reference names like x, y, ...
+# pylint: disable=duplicate-code
+
+from __future__ import annotations
+
+import numpy as np
+import pytest
+
+import sigima.objects
+import sigima.params
+import sigima.proc.signal
+from sigima.tests import guiutils
+from sigima.tests.data import get_test_signal
+from sigima.tests.helpers import check_scalar_result
+
+
+@pytest.mark.validation
+def test_signal_bandwidth_3db() -> None:
+    """Validation test for the bandwidth computation."""
+    obj = get_test_signal("bandwidth.txt")
+    geometry = sigima.proc.signal.bandwidth_3db(obj)
+    assert geometry is not None, "Bandwidth computation failed."
+    with guiutils.lazy_qt_app_context() as qt_app:
+        if qt_app is not None:
+            # pylint: disable=import-outside-toplevel
+            from plotpy.builder import make
+
+            from sigima.tests import vistools
+
+            x0, y0, x1, y1 = geometry.coords[0]
+            x, y = obj.xydata
+            vistools.view_curve_items(
+                [
+                    make.mcurve(x.real, y.real, label=obj.title),
+                    vistools.create_signal_segment(x0, y0, x1, y1, "Bandwidth@-3dB"),
+                ],
+                title="Bandwidth@-3dB",
+            )
+    length = geometry.segments_lengths()[0]
+    check_scalar_result("Bandwidth@-3dB", length, 38.99301975103714)
+    p1 = sigima.params.AbscissaParam.create(x=length)
+    table = sigima.proc.signal.y_at_x(obj, p1)
+    check_scalar_result("Value@cutoff", table["y@x"][0], np.max(obj.y) - 3.0)
+
+
+@pytest.mark.validation
+def test_dynamic_parameters() -> None:
+    """Validation test for dynamic parameters computation."""
+    obj = get_test_signal("dynamic_parameters.txt")
+    param = sigima.params.DynamicParam.create(full_scale=1.0)
+    table = sigima.proc.signal.dynamic_parameters(obj, param)
+    assert table is not None, "Dynamic parameters computation failed"
+    tdict = table.as_dict()
+    check_scalar_result("ENOB", tdict["enob"], 5.1, rtol=0.001)
+    check_scalar_result("SINAD", tdict["sinad"], 32.49, rtol=0.001)
+    check_scalar_result("THD", tdict["thd"], -30.18, rtol=0.001)
+    check_scalar_result("SFDR", tdict["sfdr"], 34.03, rtol=0.001)
+    check_scalar_result("Freq", tdict["freq"], 49998377.464, rtol=0.001)
+    check_scalar_result("SNR", tdict["snr"], 101.52, rtol=0.001)
+
+
+@pytest.mark.validation
+def test_signal_sampling_rate_period() -> None:
+    """Validation test for the sampling rate and period computation."""
+    obj = get_test_signal("dynamic_parameters.txt")
+    table = sigima.proc.signal.sampling_rate_period(obj)
+    assert table is not None, "Sampling rate and period computation failed"
+    check_scalar_result("Sampling rate", table["fs"][0], 1.0e10, rtol=0.001)
+    check_scalar_result("Period", table["T"][0], 1.0e-10, rtol=0.001)
+
+
+@pytest.mark.validation
+def test_signal_contrast() -> None:
+    """Validation test for the contrast computation."""
+    obj = get_test_signal("fw1e2.txt")
+    table = sigima.proc.signal.contrast(obj)
+    assert table is not None, "Contrast computation failed"
+    check_scalar_result("Contrast", table["contrast"][0], 0.825, rtol=0.001)
+
+
+@pytest.mark.validation
+def test_signal_x_at_minmax() -> None:
+    """Validation test for the x value at min/max computation."""
+    obj = get_test_signal("fw1e2.txt")
+    table = sigima.proc.signal.x_at_minmax(obj)
+    assert table is not None, "X at min/max computation failed"
+    check_scalar_result("X@Ymin", table["X@Ymin"][0], 0.803, rtol=0.001)
+    check_scalar_result("X@Ymax", table["X@Ymax"][0], 5.184, rtol=0.001)
+
+
+@pytest.mark.validation
+def test_signal_x_at_y() -> None:
+    """Validation test for the abscissa finding computation."""
+    obj = sigima.objects.create_signal_from_param(sigima.objects.StepParam.create())
+    if obj is None:
+        raise ValueError("Failed to create test signal")
+    param = sigima.proc.signal.OrdinateParam.create(y=0.5)
+    table = sigima.proc.signal.x_at_y(obj, param)
+    assert table is not None, "X at Y computation failed"
+    check_scalar_result("x|y=0.5", table["x@y"][0], 0.0)
+
+
+@pytest.mark.validation
+def test_signal_y_at_x() -> None:
+    """Validation test for the ordinate finding computation."""
+    param = sigima.objects.TriangleParam.create(xmin=0.0, xmax=10.0, size=101)
+    obj = sigima.objects.create_signal_from_param(param)
+    if obj is None:
+        raise ValueError("Failed to create test signal")
+    param = sigima.proc.signal.AbscissaParam.create(x=2.5)
+    table = sigima.proc.signal.y_at_x(obj, param)
+    assert table is not None, "Y at X computation failed"
+    check_scalar_result("y|x=2.5", table["y@x"][0], 1.0)
+
+
+if __name__ == "__main__":
+    guiutils.enable_gui()
+    test_signal_bandwidth_3db()
+    test_dynamic_parameters()
+    test_signal_sampling_rate_period()
+    test_signal_contrast()
+    test_signal_x_at_minmax()
+    test_signal_x_at_y()
+    test_signal_y_at_x()