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

sigima/tests/data.py

@@ -0,0 +1,998 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Test data functions
+
+Functions creating test data: curves, images, ...
+"""
+
+# pylint: disable=invalid-name  # Allows short reference names like x, y, ...
+# guitest: skip
+
+from __future__ import annotations
+
+from typing import Any, Callable, Generator
+
+import guidata.dataset as gds
+import numpy as np
+
+from sigima.config import _
+from sigima.io import read_image, read_signal
+from sigima.objects import (
+    GaussParam,
+    GeometryResult,
+    ImageDatatypes,
+    ImageObj,
+    ImageROI,
+    ImageTypes,
+    NewImageParam,
+    NewSignalParam,
+    NormalDistribution1DParam,
+    NormalDistribution2DParam,
+    SignalObj,
+    SignalROI,
+    SignalTypes,
+    TableResult,
+    create_image,
+    create_image_from_param,
+    create_image_roi,
+    create_signal_from_param,
+    create_signal_parameters,
+    create_signal_roi,
+)
+from sigima.objects.image import UniformDistribution2DParam, create_image_parameters
+from sigima.objects.scalar import KindShape
+from sigima.tests.env import execenv
+from sigima.tests.helpers import get_test_fnames
+
+
+def get_test_signal(filename: str) -> SignalObj:
+    """Return test signal
+
+    Args:
+        filename: Filename
+
+    Returns:
+        Signal object
+    """
+    return read_signal(get_test_fnames(filename)[0])
+
+
+def get_test_image(filename: str) -> ImageObj:
+    """Return test image
+
+    Args:
+        filename: Filename
+
+    Returns:
+        Image object
+    """
+    return read_image(get_test_fnames(filename)[0])
+
+
+def iterate_signal_creation(
+    size: int = 500,
+    non_zero: bool = False,
+    verbose: bool = True,
+    preproc: Callable[[NewSignalParam], None] | None = None,
+    postproc: Callable[[SignalObj], None] | None = None,
+) -> Generator[SignalObj, None, None]:
+    """Iterate over all possible signals created from parameters
+
+    Args:
+        size: Size of the data. Defaults to 500.
+        non_zero: If True, skip zero signals. Defaults to False.
+        verbose: If True, print the signal types being created. Defaults to True.
+        preproc: Callback function to preprocess the signal parameters set before
+         creation. Defaults to None.
+        postproc: Callback function to postprocess the signal object after creation.
+         Defaults to None.
+
+    Yields:
+        Signal object created from parameters.
+    """
+    if verbose:
+        execenv.print(
+            f"  Iterating over {len(SignalTypes)} signal types "
+            f"(size={size}, non_zero={non_zero}):"
+        )
+    for stype in SignalTypes:
+        if non_zero and stype in (SignalTypes.ZERO,):
+            continue
+        if verbose:
+            execenv.print(f"    {stype.value}")
+        param = create_signal_parameters(stype, size=size)
+        if preproc is not None:
+            preproc(param)
+        signal = create_signal_from_param(param)
+        if postproc is not None:
+            postproc(signal, stype)
+        yield signal
+
+
+def create_paracetamol_signal(
+    size: int | None = None, title: str | None = None
+) -> SignalObj:
+    """Create test signal (Paracetamol molecule spectrum)
+
+    Args:
+        size: Size of the data. Defaults to None.
+        title: Title of the signal. Defaults to None.
+
+    Returns:
+        Signal object
+    """
+    obj = read_signal(get_test_fnames("paracetamol.txt")[0])
+    if title is not None:
+        obj.title = title
+    if size is not None:
+        x0, y0 = obj.xydata
+        x1 = np.linspace(x0[0], x0[-1], size)
+        y1 = np.interp(x1, x0, y0)
+        obj.set_xydata(x1, y1)
+    return obj
+
+
+def add_gaussian_noise_to_signal(
+    signal: SignalObj, p: NormalDistribution1DParam | None = None
+) -> None:
+    """Add Gaussian (Normal-law) random noise to data
+
+    Args:
+        signal: Signal object
+        p: Gaussian noise parameters.
+    """
+    if p is None:
+        p = NormalDistribution1DParam()
+    rng = np.random.default_rng(p.seed)
+    signal.data += rng.normal(p.mu, p.sigma, size=signal.data.shape)
+    signal.title = f"GaussNoise({signal.title}, µ={p.mu}, σ={p.sigma})"
+
+
+def create_noisy_signal(
+    noiseparam: NormalDistribution1DParam | None = None,
+    param: NewSignalParam | None = None,
+    title: str | None = None,
+    noised: bool | None = None,
+) -> SignalObj:
+    """Create curve data, optionally noised
+
+    Args:
+        noiseparam: Noise parameters. Default: None: No noise
+        newparam: New signal parameters.
+         Default: Gaussian, size=500, xmin=-10, xmax=10,
+         a=1.0, sigma=1.0, mu=0.0, ymin=0.0
+        title: Title of the signal. Default: None
+         If not None, overrides the title in newparam
+        noised: If True, add noise to the signal.
+         Default: None (use noiseparam)
+         If True, eventually creates a new noiseparam if None
+
+    Returns:
+        Signal object
+    """
+    if param is None:
+        param = GaussParam()
+    if title is not None:
+        param.title = title
+    param.title = "Test signal (noisy)" if param.title is None else param.title
+    if noised is not None and noised and noiseparam is None:
+        noiseparam = NormalDistribution1DParam()
+        noiseparam.sigma = 5.0
+    sig = create_signal_from_param(param)
+    if noiseparam is not None:
+        add_gaussian_noise_to_signal(sig, noiseparam)
+    return sig
+
+
+def create_periodic_signal(
+    stype: SignalTypes,
+    freq: float = 50.0,
+    size: int = 10000,
+    xmin: float = -10.0,
+    xmax: float = 10.0,
+    a: float = 1.0,
+) -> SignalObj:
+    """Create a periodic signal
+
+    Args:
+        stype: Type of the signal (shape of the periodic signal).
+        freq: Frequency of the signal. Defaults to 50.0.
+        size: Size of the signal. Defaults to 10000.
+        xmin: Minimum value of the signal. Defaults to None.
+        xmax: Maximum value of the signal. Defaults to None.
+        a: Amplitude of the signal. Defaults to 1.0.
+
+    Returns:
+        Signal object
+    """
+    p = create_signal_parameters(stype, size=size, xmin=xmin, xmax=xmax, freq=freq, a=a)
+    return create_signal_from_param(p)
+
+
+def create_2d_steps_data(size: int, width: int, dtype: np.dtype) -> np.ndarray:
+    """Creating 2D steps data for testing purpose
+
+    Args:
+        size: Size of the data
+        width: Width of the steps
+        dtype: Data type
+
+    Returns:
+        2D data
+    """
+    data = np.zeros((size, size), dtype=dtype)
+    value = 1
+    for col in range(0, size - width + 1, width):
+        data[:, col : col + width] = np.array(value).astype(dtype)
+        value *= 10
+    data2 = np.zeros_like(data)
+    value = 1
+    for row in range(0, size - width + 1, width):
+        data2[row : row + width, :] = np.array(value).astype(dtype)
+        value *= 10
+    data += data2
+    return data
+
+
+def create_2d_random(
+    size: int, dtype: np.dtype, level: float = 0.1, seed: int = 1
+) -> np.ndarray:
+    """Creating 2D Uniform-law random image
+
+    Args:
+        size: Size of the data
+        dtype: Data type
+        level: Level of the random noise. Defaults to 0.1.
+        seed: Seed for random number generator. Defaults to 1.
+
+    Returns:
+        2D data
+    """
+    rng = np.random.default_rng(seed)
+    amp = (np.iinfo(dtype).max if np.issubdtype(dtype, np.integer) else 1.0) * level
+    return np.array(rng.random((size, size)) * amp, dtype=dtype)
+
+
+def create_2d_gaussian(
+    size: int,
+    dtype: np.dtype,
+    x0: float = 0,
+    y0: float = 0,
+    mu: float = 0.0,
+    sigma: float = 2.0,
+    amp: float | None = None,
+) -> np.ndarray:
+    """Creating 2D Gaussian (-10 <= x <= 10 and -10 <= y <= 10)
+
+    Args:
+        size: Size of the data
+        dtype: Data type
+        x0: x0. Defaults to 0.
+        y0: y0. Defaults to 0.
+        mu: mu. Defaults to 0.0.
+        sigma: sigma. Defaults to 2.0.
+        amp: Amplitude. Defaults to None.
+
+    Returns:
+        2D data
+    """
+    xydata = np.linspace(-10, 10, size)
+    x, y = np.meshgrid(xydata, xydata)
+    if amp is None:
+        try:
+            amp = np.iinfo(dtype).max * 0.5
+        except ValueError:
+            # dtype is not integer
+            amp = 1.0
+    return np.array(
+        amp
+        * np.exp(
+            -((np.sqrt((x - x0) ** 2 + (y - y0) ** 2) - mu) ** 2) / (2.0 * sigma**2)
+        ),
+        dtype=dtype,
+    )
+
+
+def get_laser_spot_data() -> list[np.ndarray]:
+    """Return a list of NumPy arrays containing images which are relevant for
+    testing laser spot image processing features
+
+    Returns:
+        List of NumPy arrays
+    """
+    znoise = create_2d_random(2000, np.uint16)
+    zgauss = create_2d_gaussian(2000, np.uint16, x0=2.0, y0=-3.0)
+    return [zgauss + znoise] + [
+        read_image(fname).data for fname in get_test_fnames("*.scor-data")
+    ]
+
+
+class PeakDataParam(gds.DataSet):
+    """Peak data test image parameters"""
+
+    size = gds.IntItem(_("Size"), default=2000, min=1)
+    n_points = gds.IntItem(_("Number"), default=4, min=1, help=_("Number of points"))
+    sigma_gauss2d = gds.FloatItem(
+        "σ<sub>Gauss2D</sub>", default=0.06, help=_("Sigma of the 2D Gaussian")
+    )
+    amp_gauss2d = gds.IntItem(
+        "A<sub>Gauss2D</sub>", default=1900, help=_("Amplitude of the 2D Gaussian")
+    )
+    mu_noise = gds.IntItem(
+        "μ<sub>noise</sub>", default=845, help=_("Mean of the Gaussian distribution")
+    )
+    sigma_noise = gds.IntItem(
+        "σ<sub>noise</sub>",
+        default=25,
+        help=_("Standard deviation of the Gaussian distribution"),
+    )
+    dx0 = gds.FloatItem("dx0", default=0.0)
+    dy0 = gds.FloatItem("dy0", default=0.0)
+    att = gds.FloatItem(_("Attenuation"), default=1.0)
+
+
+def get_peak2d_data(
+    p: PeakDataParam | None = None, seed: int | None = None, multi: bool = False
+) -> tuple[np.ndarray, np.ndarray]:
+    """Return a list of NumPy arrays containing images which are relevant for
+    testing 2D peak detection or similar image processing features
+
+    Args:
+        p: Peak data test image parameters. Defaults to None.
+        seed: Seed for random number generator. Defaults to None.
+        multi: If True, multiple peaks are generated. Defaults to False.
+
+    Returns:
+        A tuple containing the image data and coordinates of the peaks.
+    """
+    if p is None:
+        p = PeakDataParam()
+    delta = 0.1
+    rng = np.random.default_rng(seed)
+    coords_phys = (rng.random((p.n_points, 2)) - 0.5) * 10 * (1 - delta)
+    data = rng.normal(p.mu_noise, p.sigma_noise, size=(p.size, p.size))
+    multi_nb = 2 if multi else 1
+    for x0, y0 in coords_phys:
+        for idx in range(multi_nb):
+            if idx != 0:
+                p.dx0 = 0.08 + rng.random() * 0.08
+                p.dy0 = 0.08 + rng.random() * 0.08
+                p.att = 0.2 + rng.random() * 0.8
+            data += create_2d_gaussian(
+                p.size,
+                np.uint16,
+                x0=x0 + p.dx0,
+                y0=y0 + p.dy0,
+                sigma=p.sigma_gauss2d,
+                amp=p.amp_gauss2d / multi_nb * p.att,
+            )
+    # Convert coordinates to indices
+    coords = []
+    for x0, y0 in coords_phys:
+        x = (x0 + 10) / 20 * p.size
+        y = (y0 + 10) / 20 * p.size
+        if 0 <= x < p.size and 0 <= y < p.size:
+            coords.append((x, y))
+    return data, np.array(coords)
+
+
+CLASS_NAME = "class_name"
+
+
+def create_test_signal_rois(
+    obj: SignalObj,
+) -> Generator[SignalROI, None, None]:
+    """Create test signal ROIs (sigima.objects.SignalROI test object)
+
+    Yields:
+        SignalROI object
+    """
+    # ROI coordinates: for each ROI type, the coordinates are given for indices=True
+    # and indices=False (physical coordinates)
+    roi_coords = {
+        "segment": {
+            CLASS_NAME: "SegmentROI",
+            True: [50, 100],  # indices [x0, dx]
+            False: [7.5, 10.0],  # physical
+        },
+    }
+    for indices in (True, False):
+        execenv.print("indices:", indices)
+
+        for geometry, coords in roi_coords.items():
+            execenv.print("  geometry:", geometry)
+
+            roi = create_signal_roi(coords[indices], indices=indices)
+
+            sroi = roi.get_single_roi(0)
+            assert sroi.__class__.__name__ == coords[CLASS_NAME]
+
+            cds_ind = [int(val) for val in sroi.get_indices_coords(obj)]
+            assert cds_ind == coords[True]
+
+            cds_phys = [float(val) for val in sroi.get_physical_coords(obj)]
+            assert cds_phys == coords[False]
+
+            execenv.print("    get_physical_coords:", cds_phys)
+            execenv.print("    get_indices_coords: ", cds_ind)
+
+            yield roi
+
+
+def __idx_to_phys(obj: ImageObj, idx_coords: list[int]) -> list[float]:
+    """Convert index coordinates to physical coordinates.
+
+    Args:
+        obj: Image object
+        idx_coords: List of index coordinates [x0, y0, dx, dy].
+
+    Returns:
+        List of physical coordinates [x0, y0, dx, dy].
+    """
+    coords_array = np.array(idx_coords, dtype=float)
+    coords_array[::2] = coords_array[::2] * obj.dx + obj.x0
+    coords_array[1::2] = coords_array[1::2] * obj.dy + obj.y0
+    return coords_array.tolist()
+
+
+def create_test_image_rois(obj: ImageObj) -> Generator[ImageROI, None, None]:
+    """Create test image ROIs (sigima.objects.ImageROI test object)
+
+    Yields:
+        ImageROI object
+    """
+    # ROI coordinates: for each ROI type, the coordinates are given for indices=True
+    # and indices=False (physical coordinates)
+    rect_idx = [500, 750, 1000, 1250]  # [x0, y0, dx, dy]
+    circ_idx = [1500, 1500, 500]  # [x0, y0, radius]
+    poly_idx = [450, 150, 1300, 350, 1250, 950, 400, 1350]  # [x0, y0, ...]
+    roi_coords = {
+        "rectangle": {
+            CLASS_NAME: "RectangularROI",
+            True: rect_idx,  # indices [x0, y0, dx, dy]
+            False: __idx_to_phys(obj, rect_idx),  # physical
+        },
+        "circle": {
+            CLASS_NAME: "CircularROI",
+            True: circ_idx,  # indices [x0, y0, radius]
+            False: __idx_to_phys(obj, circ_idx),  # physical
+        },
+        "polygon": {
+            CLASS_NAME: "PolygonalROI",
+            True: poly_idx,  # indices [x0, y0, ...]
+            False: __idx_to_phys(obj, poly_idx),  # physical
+        },
+    }
+    for indices in (True, False):
+        execenv.print("indices:", indices)
+
+        for geometry, coords in roi_coords.items():
+            execenv.print("  geometry:", geometry)
+
+            roi = create_image_roi(geometry, coords[indices], indices=indices)
+
+            sroi = roi.get_single_roi(0)
+            assert sroi.__class__.__name__ == coords[CLASS_NAME]
+
+            bbox_phys = [float(val) for val in sroi.get_bounding_box(obj)]
+            if geometry in ("rectangle", "circle"):
+                # pylint: disable=unbalanced-tuple-unpacking
+                x0, y0, x1, y1 = obj.physical_to_indices(bbox_phys)
+                if geometry == "rectangle":
+                    coords_from_bbox = [int(xy) for xy in [x0, y0, x1 - x0, y1 - y0]]
+                else:
+                    coords_from_bbox = [
+                        int(xy) for xy in [(x0 + x1) / 2, (y0 + y1) / 2, (x1 - x0) / 2]
+                    ]
+                assert coords_from_bbox == coords[True]
+
+            cds_phys = np.array(sroi.get_physical_coords(obj), float)
+            assert all(np.isclose(cds_phys, coords[False]))
+            cds_ind = np.rint(sroi.get_indices_coords(obj))
+            assert all(np.isclose(cds_ind, coords[True]))
+
+            execenv.print("    get_bounding_box:   ", bbox_phys)
+            execenv.print("    get_physical_coords:", cds_phys)
+            execenv.print("    get_indices_coords: ", cds_ind)
+
+            yield roi
+
+
+def __iterate_image_datatypes(
+    itype: ImageTypes,
+    data_size: int,
+    verbose: bool,
+    preproc: Callable[[NewImageParam], None] | None = None,
+    postproc: Callable[[ImageObj, ImageTypes], None] | None = None,
+) -> Generator[ImageObj | None, None, None]:
+    """Iterate over all datatypes for a given image type
+
+    Args:
+        itype: Image type
+        data_size: Size of the data
+        verbose: If True, print the image types being created
+        preproc: Callback function to preprocess the image parameters set before
+         creation. Defaults to None.
+        postproc: Callback function to postprocess the image object after creation.
+         Defaults to None.
+
+    Yields:
+        Image object created from parameters
+    """
+    for idtype in ImageDatatypes:
+        if verbose:
+            execenv.print(f"      {idtype.value}")
+        param = create_image_parameters(
+            itype, idtype=idtype, width=data_size, height=data_size
+        )
+        if itype == ImageTypes.RAMP and idtype != ImageDatatypes.FLOAT64:
+            continue  # Testing only float64 for ramp
+        if itype == ImageTypes.UNIFORM_DISTRIBUTION:
+            assert isinstance(param, UniformDistribution2DParam)
+            param.set_from_datatype(idtype.value)
+        elif itype == ImageTypes.NORMAL_DISTRIBUTION:
+            assert isinstance(param, NormalDistribution2DParam)
+            param.set_from_datatype(idtype.value)
+        if preproc is not None:
+            preproc(param)
+        image = create_image_from_param(param)
+        if postproc is not None:
+            postproc(image, itype)
+        yield image
+
+
+def iterate_image_creation(
+    size: int = 500,
+    non_zero: bool = False,
+    verbose: bool = True,
+    preproc: Callable[[NewImageParam], None] | None = None,
+    postproc: Callable[[ImageObj, ImageTypes], None] | None = None,
+) -> Generator[ImageObj, None, None]:
+    """Iterate over all possible images created from parameters
+
+    Args:
+        size: Size of the data. Defaults to 500.
+        non_zero: If True, skip empty and zero images. Defaults to False.
+        verbose: If True, print the image types being created. Defaults to True.
+        preproc: Callback function to preprocess the image parameters set before
+         creation. Defaults to None.
+        postproc: Callback function to postprocess the image object after creation.
+
+    Yields:
+        Image object created from parameters.
+    """
+    if verbose:
+        execenv.print(
+            f"  Iterating over {len(ImageTypes)} image types "
+            f"(size={size}, non_zero={non_zero}):"
+        )
+    for itype in ImageTypes:
+        if non_zero and itype == ImageTypes.ZEROS:
+            continue
+        if verbose:
+            execenv.print(f"    {itype.value}")
+        yield from __iterate_image_datatypes(itype, size, verbose, preproc, postproc)
+
+
+def __set_default_size_dtype(
+    p: NewImageParam | None = None,
+) -> NewImageParam:
+    """Set default shape and dtype
+
+    Args:
+        p: Image parameters. Defaults to None. If None, a new object is created.
+
+    Returns:
+        Image parameters
+    """
+    if p is None:
+        p = NewImageParam()
+    p.height = 2000 if p.height is None else p.height
+    p.width = 2000 if p.width is None else p.width
+    p.dtype = ImageDatatypes.UINT16 if p.dtype is None else p.dtype
+    return p
+
+
+def create_checkerboard(p: NewImageParam | None = None, num_checkers=8) -> ImageObj:
+    """Generate a checkerboard pattern
+
+    Args:
+        p: Image parameters. Defaults to None.
+        num_checkers: Number of checkers. Defaults to 8.
+    """
+    p = __set_default_size_dtype(p)
+    p.title = "Test image (checkerboard)" if p.title is None else p.title
+    obj = create_image_from_param(p)
+    re = np.r_[num_checkers * [0, 1]]  # one row of the checkerboard
+    board = np.vstack(num_checkers * (re, re ^ 1))  # build the checkerboard
+    board = np.kron(
+        board, np.ones((p.height // num_checkers, p.height // num_checkers))
+    )  # scale up the board
+    obj.data = board
+    return obj
+
+
+def create_2dstep_image(p: NewImageParam | None = None) -> ImageObj:
+    """Creating 2D step image
+
+    Args:
+        p: Image parameters. Defaults to None.
+
+    Returns:
+        Image object
+    """
+    p = __set_default_size_dtype(p)
+    p.title = "Test image (2D step)" if p.title is None else p.title
+    obj = create_image_from_param(p)
+    obj.data = create_2d_steps_data(p.height, p.height // 10, p.dtype.to_numpy_dtype())
+    return obj
+
+
+class RingParam(gds.DataSet):
+    """Parameters for creating a ring image"""
+
+    image_size = gds.IntItem(_("Size"), default=1000)
+    xc = gds.IntItem(_("X<sub>center</sub>"), default=500)
+    yc = gds.IntItem(_("Y<sub>center</sub>"), default=500)
+    thickness = gds.IntItem(_("Thickness"), default=10)
+    radius = gds.IntItem(_("Radius"), default=250)
+    intensity = gds.IntItem(_("Intensity"), default=1000)
+
+
+def create_ring_data(
+    image_size: int, xc: int, yc: int, thickness: int, radius: int, intensity: int
+) -> np.ndarray:
+    """Create 2D ring data
+
+    Args:
+        image_size: Size of the image
+        xc: Center x coordinate
+        yc: Center y coordinate
+        thickness: Thickness of the ring
+        radius: Radius of the ring
+        intensity: Intensity of the ring
+
+    Returns:
+        2D data
+    """
+    data = np.zeros((image_size, image_size), dtype=np.uint16)
+    for x in range(data.shape[0]):
+        for y in range(data.shape[1]):
+            if (x - xc) ** 2 + (y - yc) ** 2 >= (radius - thickness) ** 2 and (
+                x - xc
+            ) ** 2 + (y - yc) ** 2 <= (radius + thickness) ** 2:
+                data[x, y] = intensity
+    return data
+
+
+def create_ring_image(p: RingParam | None = None) -> ImageObj:
+    """Creating 2D ring image
+
+    Args:
+        p: Ring image parameters. Defaults to None.
+
+    Returns:
+        Image object
+    """
+    if p is None:
+        p = RingParam()
+    obj = create_image(
+        f"Ring(size={p.image_size},xc={p.xc},yc={p.yc},thickness={p.thickness},"
+        f"radius={p.radius},intensity={p.intensity})"
+    )
+    obj.data = create_ring_data(
+        p.image_size,
+        p.xc,
+        p.yc,
+        p.thickness,
+        p.radius,
+        p.intensity,
+    )
+    return obj
+
+
+def create_peak_image(p: NewImageParam | None = None) -> ImageObj:
+    """Creating image with bright peaks
+
+    Args:
+        p: Image parameters. Defaults to None
+
+    Returns:
+        Image object
+    """
+    p = __set_default_size_dtype(p)
+    p.title = "Test image (2D peaks)" if p.title is None else p.title
+    obj = create_image_from_param(p)
+    param = PeakDataParam()
+    if p.height is not None and p.width is not None:
+        param.size = max(p.height, p.width)
+    obj.data, coords = get_peak2d_data(param)
+    obj.metadata["peak_coords"] = coords
+    return obj
+
+
+def create_sincos_image(p: NewImageParam | None = None) -> ImageObj:
+    """Creating test image (sin(x)+cos(y))
+
+    Args:
+        p: Image parameters. Defaults to None
+
+    Returns:
+        Image object
+    """
+    p = __set_default_size_dtype(p)
+    p.title = "Test image (sin(x)+cos(y))" if p.title is None else p.title
+    x, y = np.meshgrid(np.linspace(0, 10, p.width), np.linspace(0, 10, p.height))
+    raw_data = 0.5 * (np.sin(x) + np.cos(y)) + 0.5
+    obj = create_image_from_param(p)
+    if np.issubdtype(p.dtype.to_numpy_dtype(), np.floating):
+        obj.data = raw_data
+        return obj
+    dmin = np.iinfo(p.dtype.to_numpy_dtype()).min * 0.95
+    dmax = np.iinfo(p.dtype.to_numpy_dtype()).max * 0.95
+    obj.data = np.array(raw_data * (dmax - dmin) + dmin, dtype=p.dtype.to_numpy_dtype())
+    return obj
+
+
+def add_annotations_from_file(obj: SignalObj | ImageObj, filename: str) -> None:
+    """Add annotations from a file to a Signal or Image object
+
+    Args:
+        obj: Signal or Image object to which annotations will be added
+        filename: Filename containing annotations
+    """
+    with open(filename, "r", encoding="utf-8") as file:
+        json_str = file.read()
+    if obj.annotations:
+        json_str = obj.annotations[:-1] + "," + json_str[1:]
+    obj.annotations = json_str
+
+
+def create_noisy_gaussian_image(
+    p: NewImageParam | None = None,
+    center: tuple[float, float] | None = None,
+    level: float = 0.1,
+    add_annotations: bool = False,
+) -> ImageObj:
+    """Create test image (2D noisy gaussian)
+
+    Args:
+        p: Image parameters. Defaults to None.
+        center: Center of the gaussian. Defaults to None.
+        level: Level of the random noise. Defaults to 0.1.
+        add_annotations: If True, add annotations. Defaults to False.
+
+    Returns:
+        Image object
+    """
+    p = __set_default_size_dtype(p)
+    p.title = "Test image (noisy 2D Gaussian)" if p.title is None else p.title
+    obj = create_image_from_param(p)
+    if center is None:
+        # Default center
+        x0, y0 = 2.0, 3.0
+    else:
+        x0, y0 = center
+    obj.data = create_2d_gaussian(p.width, dtype=p.dtype.to_numpy_dtype(), x0=x0, y0=y0)
+    if level:
+        obj.data += create_2d_random(p.width, p.dtype.to_numpy_dtype(), level)
+    if add_annotations:
+        add_annotations_from_file(obj, get_test_fnames("annotations.json")[0])
+    return obj
+
+
+def iterate_noisy_images(size: int = 128) -> Generator[ImageObj, None, None]:
+    """Iterate over all possible noisy Gaussian images in different datatypes.
+
+    Args:
+        size: Size of the image. Defaults to 128.
+    """
+    for dtype in ImageDatatypes:
+        param = NewImageParam.create(dtype=dtype, height=size, width=size)
+        yield create_noisy_gaussian_image(param, level=0.0)
+
+
+def iterate_noisy_image_couples(
+    size: int = 128,
+) -> Generator[tuple[ImageObj, ImageObj], None, None]:
+    """Iterate over all possible pairs of noisy Gaussian images in different datatypes.
+
+    Args:
+        size: Size of the images. Defaults to 128.
+    """
+    for dtype1 in ImageDatatypes:
+        param1 = NewImageParam.create(dtype=dtype1, height=size, width=size)
+        ima1 = create_noisy_gaussian_image(param1, level=0.0)
+        for dtype2 in ImageDatatypes:
+            param2 = NewImageParam.create(dtype=dtype2, height=size, width=size)
+            ima2 = create_noisy_gaussian_image(param2, level=0.0)
+            yield ima1, ima2
+
+
+def create_n_images(n: int = 100) -> list[ImageObj]:
+    """Create a list of N different images for testing."""
+    images = []
+    for i in range(n):
+        param = NewImageParam.create(
+            dtype=ImageDatatypes.FLOAT32,
+            height=128,
+            width=128,
+        )
+        img = create_noisy_gaussian_image(param, level=(i + 1) * 0.1)
+        images.append(img)
+    return images
+
+
+class GridOfGaussianImages(gds.DataSet):
+    """Grid of Gaussian images"""
+
+    nrows = gds.IntItem(_("Number of rows"), default=3, min=1)
+    ncols = gds.IntItem(_("Number of columns"), default=3, min=1)
+
+
+def create_grid_of_gaussian_images(p: GridOfGaussianImages | None = None) -> ImageObj:
+    """Create a grid image with multiple noisy Gaussian images.
+
+    Args:
+        p: Grid of Gaussian images parameters. Defaults to None.
+
+    Returns:
+        Image object containing the grid of images.
+    """
+    p = p or GridOfGaussianImages()
+    size = 512
+    grid_data = np.zeros((size, size), dtype=np.float32)
+    xmin, xmax = -10.0, 10.0
+    ymin, ymax = -10.0, 10.0
+    xstep = (xmax - xmin) / p.ncols
+    ystep = (ymax - ymin) / p.nrows
+    sigma = 0.1
+    amp = 1.0
+    for j in range(p.ncols):
+        for i in range(p.nrows):
+            grid_data += create_2d_gaussian(
+                size,
+                dtype=float,
+                x0=(i + 0.5) * xstep + xmin,
+                y0=(j + 0.5) * ystep + ymin,
+                sigma=sigma,
+                amp=amp,
+            )
+            sigma += 0.05
+            amp *= 1.1
+    return create_image("Grid Image", grid_data)
+
+
+def create_multigaussian_image(p: NewImageParam | None = None) -> ImageObj:
+    """Create test image (multiple 2D-gaussian peaks)
+
+    Args:
+        p: Image parameters. Defaults to None.
+
+    Returns:
+        Image object
+    """
+    p = __set_default_size_dtype(p)
+    p.title = "Test image (multi-2D-gaussian)" if p.title is None else p.title
+    obj = create_image_from_param(p)
+    obj.data = (
+        create_2d_gaussian(p.width, p.dtype.to_numpy_dtype(), x0=0.5, y0=3.0)
+        + create_2d_gaussian(
+            p.width, p.dtype.to_numpy_dtype(), x0=-1.0, y0=-1.0, sigma=1.0
+        )
+        + create_2d_gaussian(p.width, p.dtype.to_numpy_dtype(), x0=7.0, y0=8.0)
+    )
+    return obj
+
+
+def create_annotated_image(title: str | None = None) -> ImageObj:
+    """Create test image with annotations
+
+    Returns:
+        Image object
+    """
+    data = create_2d_gaussian(600, np.uint16, x0=2.0, y0=3.0)
+    title = "Test image (with metadata)" if title is None else title
+    image = create_image(title, data)
+    add_annotations_from_file(image, get_test_fnames("annotations.json")[0])
+    return image
+
+
+def create_test_metadata() -> dict[str, Any]:
+    """Create test metadata for signals or images.
+
+    Returns:
+        Metadata dictionary
+    """
+    metadata = {}
+    metadata["tata"] = {
+        "lkl": 2,
+        "tototo": 3,
+        "arrdata": np.array([0, 1, 2, 3, 4, 5]),
+        "zzzz": "lklk",
+        "bool": True,
+        "float": 1.234,
+        "list": [1, 2.5, 3, "str", False, 5],
+        "d": {
+            "lkl": 2,
+            "tototo": 3,
+            "zzzz": "lklk",
+            "bool": True,
+            "float": 1.234,
+            "list": [
+                1,
+                2.5,
+                3,
+                "str",
+                False,
+                5,
+                {"lkl": 2, "l": [1, 2, 3]},
+            ],
+        },
+    }
+    metadata["toto"] = [
+        np.array([[1, 2], [-3, 0]]),
+        np.array([[1, 2], [-3, 0], [99, 241]]),
+    ]
+    metadata["array"] = np.array([-5, -4, -3, -2, -1])
+    return metadata
+
+
+def create_test_signal_with_metadata() -> SignalObj:
+    """Create a test signal with complex metadata for serialization testing.
+
+    Returns:
+        Signal object with metadata containing various data types.
+    """
+    signal = create_paracetamol_signal()
+    signal.metadata = create_test_metadata()
+    return signal
+
+
+def create_test_image_with_metadata() -> ImageObj:
+    """Create a test image with complex metadata for serialization testing.
+
+    Returns:
+        Image object with metadata containing various data types.
+    """
+    data = get_test_image("flower.npy").data
+    image = create_image("Test image with peaks", data)
+    image.metadata = create_test_metadata()
+    return image
+
+
+def generate_geometry_results() -> Generator[GeometryResult, None, None]:
+    """Create test geometry results.
+
+    Yields:
+        GeometryResult object
+    """
+    for index, (shape, coords) in enumerate(
+        (
+            (KindShape.CIRCLE, [[250, 250, 200]]),
+            (KindShape.RECTANGLE, [[300, 200, 150, 250]]),
+            (KindShape.SEGMENT, [[50, 250, 400, 400]]),
+            (KindShape.POINT, [[500, 500]]),
+            (
+                KindShape.POLYGON,
+                [[100, 100, 150, 100, 150, 150, 200, 100, 250, 50]],
+            ),
+        )
+    ):
+        yield GeometryResult(f"GeomResult{index}", shape, coords=np.asarray(coords))
+
+
+def generate_table_results() -> Generator[TableResult, None, None]:
+    """Create test table results.
+
+    Yields:
+        TableResult object
+    """
+    for index, (names, data) in enumerate(
+        (
+            (["A", "B", "C", "D"], [["banana", 2.5, -30909, 1.0]]),
+            (["P1", "P2", "P3", "P4"], [["apple", 1.232325, -9, 0]]),
+        )
+    ):
+        yield TableResult(f"TestProperties{index}", "test", names, data=data)