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

sigima/proc/signal/fitting.py

@@ -0,0 +1,276 @@
+# -*- coding: utf-8 -*-
+#
+# Licensed under the terms of the BSD 3-Clause
+# (see sigima/LICENSE for details)
+
+"""
+Curve fitting operations
+========================
+
+This module provides curve fitting operations for signal objects:
+
+- Linear and polynomial fits
+- Gaussian, Lorentzian, and Voigt fits
+- Exponential and CDF fits
+
+.. note::
+
+    Most operations use functions from :mod:`sigima.tools.signal.fitting` for
+    actual computations.
+"""
+
+from __future__ import annotations
+
+from typing import Callable
+
+import guidata.dataset as gds
+import numpy as np
+
+from sigima.config import _
+from sigima.objects import SignalObj
+from sigima.proc.base import dst_2_to_1
+from sigima.proc.decorator import computation_function
+from sigima.tools.signal import fitting
+
+from .base import dst_1_to_1
+
+
+def __generic_fit(
+    src: SignalObj,
+    fitfunc: Callable[[np.ndarray, np.ndarray], tuple[np.ndarray, dict[str, float]]],
+) -> SignalObj:
+    """Generic fitting function.
+
+    Args:
+        src: source signal
+        fitfunc: fitting function
+
+    Returns:
+        Fitting result signal object
+    """
+    dst = dst_1_to_1(src, fitfunc.__name__)
+
+    # Fit only on ROI if available
+    x_roi = src.x[~src.get_masked_view().mask]
+    y_roi = src.get_masked_view().compressed()
+    _fitted_y_roi, fit_params = fitfunc(x_roi, y_roi)
+
+    # Evaluate fit on full x range
+    fitted_y = fitting.evaluate_fit(src.x, **fit_params)
+    dst.set_xydata(src.x, fitted_y)
+
+    # Store fit parameters in metadata
+    dst.metadata["fit_params"] = fit_params
+    return dst
+
+
+@computation_function()
+def linear_fit(src: SignalObj) -> SignalObj:
+    """Compute linear fit with :py:func:`numpy.polyfit`
+
+    Args:
+        src: source signal
+
+    Returns:
+        Result signal object
+    """
+    return __generic_fit(src, fitting.linear_fit)
+
+
+class PolynomialFitParam(gds.DataSet, title=_("Polynomial fit")):
+    """Polynomial fitting parameters"""
+
+    degree = gds.IntItem(_("Degree"), 3, min=1, max=10, slider=True)
+
+
+@computation_function()
+def polynomial_fit(src: SignalObj, p: PolynomialFitParam) -> SignalObj:
+    """Compute polynomial fit with :py:func:`numpy.polyfit`
+
+    Args:
+        src: source signal
+        p: polynomial fitting parameters
+
+    Returns:
+        Result signal object
+    """
+    if p.degree < 1:
+        raise ValueError("The polynomial degree must be at least 1.")
+    return __generic_fit(src, lambda x, y: fitting.polynomial_fit(x, y, p.degree))
+
+
+@computation_function()
+def gaussian_fit(src: SignalObj) -> SignalObj:
+    """Compute Gaussian fit with :py:func:`scipy.optimize.curve_fit`
+
+    Args:
+        src: source signal
+
+    Returns:
+        Result signal object
+    """
+    return __generic_fit(src, fitting.gaussian_fit)
+
+
+@computation_function()
+def lorentzian_fit(src: SignalObj) -> SignalObj:
+    """Compute Lorentzian fit with :py:func:`scipy.optimize.curve_fit`
+
+    Args:
+        src: source signal
+
+    Returns:
+        Result signal object
+    """
+    return __generic_fit(src, fitting.lorentzian_fit)
+
+
+@computation_function()
+def voigt_fit(src: SignalObj) -> SignalObj:
+    """Compute Voigt fit with :py:func:`scipy.optimize.curve_fit`
+
+    Args:
+        src: source signal
+
+    Returns:
+        Result signal object
+    """
+    return __generic_fit(src, fitting.voigt_fit)
+
+
+@computation_function()
+def exponential_fit(src: SignalObj) -> SignalObj:
+    """Compute exponential fit with :py:func:`scipy.optimize.curve_fit`
+
+    Args:
+        src: source signal
+
+    Returns:
+        Result signal object
+    """
+    return __generic_fit(src, fitting.exponential_fit)
+
+
+@computation_function()
+def cdf_fit(src: SignalObj) -> SignalObj:
+    """Compute CDF fit with :py:func:`scipy.optimize.curve_fit`
+
+    Args:
+        src: source signal
+
+    Returns:
+        Result signal object
+    """
+    return __generic_fit(src, fitting.cdf_fit)
+
+
+@computation_function()
+def planckian_fit(src: SignalObj) -> SignalObj:
+    """Compute Planckian fit with :py:func:`scipy.optimize.curve_fit`
+
+    Args:
+        src: source signal
+
+    Returns:
+        Result signal object
+    """
+    return __generic_fit(src, fitting.planckian_fit)
+
+
+@computation_function()
+def twohalfgaussian_fit(src: SignalObj) -> SignalObj:
+    """Compute two-half-Gaussian fit with :py:func:`scipy.optimize.curve_fit`
+
+    Args:
+        src: source signal
+
+    Returns:
+        Result signal object
+    """
+    return __generic_fit(src, fitting.twohalfgaussian_fit)
+
+
+@computation_function()
+def sigmoid_fit(src: SignalObj) -> SignalObj:
+    """Compute sigmoid fit with :py:func:`scipy.optimize.curve_fit`
+
+    Args:
+        src: source signal
+
+    Returns:
+        Result signal object
+    """
+    return __generic_fit(src, fitting.sigmoid_fit)
+
+
+@computation_function()
+def piecewiseexponential_fit(src: SignalObj) -> SignalObj:
+    """Compute piecewise exponential fit (raise-decay) with
+    :py:func:`scipy.optimize.curve_fit`
+
+    Args:
+        src: source signal
+
+    Returns:
+        Result signal object
+    """
+    return __generic_fit(src, fitting.piecewiseexponential_fit)
+
+
+@computation_function()
+def sinusoidal_fit(src: SignalObj) -> SignalObj:
+    """Compute sinusoidal fit with :py:func:`scipy.optimize.curve_fit`
+
+    Args:
+        src: source signal
+
+    Returns:
+        Result signal object
+    """
+    return __generic_fit(src, fitting.sinusoidal_fit)
+
+
+def extract_fit_params(signal: SignalObj) -> dict[str, float | str]:
+    """Extract fit parameters from a fitted signal.
+
+    Args:
+        signal: Signal object containing fit metadata
+
+    Returns:
+        Fit parameters
+    """
+    if "fit_params" not in signal.metadata:
+        raise ValueError("Signal does not contain fit parameters")
+    fit_params_dict: dict[str, float | str] = signal.metadata["fit_params"]
+    assert "fit_type" in fit_params_dict, "No valid fit parameters found"
+    return fit_params_dict
+
+
+@computation_function()
+def evaluate_fit(src1: SignalObj, src2: SignalObj) -> SignalObj:
+    """Evaluate fit function from src1 on the x-axis of src2.
+
+    This function extracts fit parameters from `src1` (which must contain fit metadata
+    from a previous fitting operation) and evaluates the fit function on the x-axis
+    of `src2`.
+
+    Args:
+        src1: Signal object containing fit parameters in metadata (from a fit operation)
+        src2: Signal object whose x-axis will be used for evaluation
+
+    Returns:
+        New signal with the fit evaluated on src2's x-axis
+    """
+    fit_params = extract_fit_params(src1)
+    dst = dst_2_to_1(src1, src2, "evaluate_fit")
+
+    # Evaluate fit on src2's x-axis
+    x = src2.x
+    y = fitting.evaluate_fit(x, **fit_params)
+
+    dst.set_xydata(x, y)
+    dst.title = f"Fitted {fit_params['fit_type']}"
+
+    # Copy fit parameters to destination metadata
+    dst.metadata["fit_params"] = fit_params
+    return dst

sigima/proc/signal/fourier.py

@@ -0,0 +1,259 @@
+# -*- coding: utf-8 -*-
+#
+# Licensed under the terms of the BSD 3-Clause
+# (see sigima/LICENSE for details)
+
+"""
+Fourier transform and frequency domain operations
+=================================================
+
+This module provides Fourier transform and frequency domain operations:
+
+- FFT and inverse FFT
+- Magnitude and phase spectrum
+- Power spectral density (PSD)
+
+.. note::
+
+    Most operations use functions from :mod:`sigima.tools.signal.fourier` for actual
+    computations.
+"""
+
+from __future__ import annotations
+
+from math import ceil, log2
+
+import guidata.dataset as gds
+
+from sigima.config import _
+from sigima.enums import PadLocation1D
+from sigima.objects import SignalObj
+from sigima.proc.base import FFTParam, SpectrumParam
+from sigima.proc.decorator import computation_function
+from sigima.proc.signal.base import dst_1_to_1
+from sigima.tools.signal import fourier
+
+
+class ZeroPadding1DParam(gds.DataSet, title=_("Zero padding")):
+    """ZeroPadding1DParam manages the parameters for applying zero-padding to signals.
+
+    Attributes:
+        strategies: Available strategies ("next_pow2", "double", "triple", "custom").
+        strategy: Choice item for selecting the zero-padding strategy.
+        locations: Available locations for padding ("append", "prepend", "both").
+        location: Choice item for selecting where to add the padding.
+        n: Number of points to add as padding (active only for "custom" strategy).
+    """
+
+    def __init__(self, *args, **kwargs) -> None:
+        """Initialize zero padding parameters.
+
+        Args:
+            *args: Variable length argument list passed to the superclass.
+            **kwargs: Arbitrary keyword arguments passed to the superclass.
+        """
+        super().__init__(*args, **kwargs)
+        self.__obj: SignalObj | None = None
+
+    def update_from_obj(self, obj: SignalObj) -> None:
+        """Update parameters from signal.
+
+        Args:
+            obj: Signal object from which to update the dataset.
+        """
+        self.__obj = obj
+        self.strategy_callback(None, self.strategy)
+
+    @staticmethod
+    def next_power_of_two(size: int) -> int:
+        """Compute the next power of two greater than or equal to the given size.
+
+        Args:
+            size: The input integer.
+
+        Returns:
+            The smallest power of two greater than or equal to 'size'.
+        """
+        return 2 ** (ceil(log2(size)))
+
+    def strategy_callback(self, _, value):
+        """Callback for strategy choice item.
+
+        Args:
+            _: Unused argument (in this context).
+            value: The selected strategy value.
+        """
+        if self.__obj is None:
+            return
+        assert self.__obj.x is not None
+        size = self.__obj.x.size
+        if value == "next_pow2":
+            self.n = self.next_power_of_two(size) - size
+        elif value == "double":
+            self.n = size
+        elif value == "triple":
+            self.n = 2 * size
+
+    strategies = ("next_pow2", "double", "triple", "custom")
+    _prop = gds.GetAttrProp("strategy")
+    strategy = gds.ChoiceItem(
+        _("Strategy"), zip(strategies, strategies), default=strategies[0]
+    ).set_prop("display", store=_prop, callback=strategy_callback)
+    location = gds.ChoiceItem(
+        _("Location"),
+        PadLocation1D,
+        default=PadLocation1D.APPEND,
+        help=_("Where to add the padding"),
+    )
+    _func_prop = gds.FuncProp(_prop, lambda x: x == "custom")
+    n = gds.IntItem(
+        _("Number of points"), min=1, default=1, help=_("Number of points to add")
+    ).set_prop("display", active=_func_prop)
+
+
+@computation_function()
+def zero_padding(src: SignalObj, p: ZeroPadding1DParam) -> SignalObj:
+    """Compute zero padding with :py:func:`sigima.tools.signal.fourier.zero_padding`.
+
+    Args:
+        src: Source signal.
+        p: Parameters.
+
+    Returns:
+        Result signal object.
+    """
+    if p.strategy == "custom":
+        suffix = f"n={p.n}"
+    else:
+        suffix = f"strategy={p.strategy}"
+
+    assert p.n is not None
+    if p.location == PadLocation1D.APPEND:
+        n_prepend = 0
+        n_append = p.n
+    elif p.location == PadLocation1D.PREPEND:
+        n_prepend = p.n
+        n_append = 0
+    elif p.location == PadLocation1D.BOTH:
+        n_prepend = p.n // 2
+        n_append = p.n - n_prepend
+    else:
+        raise ValueError(f"Invalid padding location: {p.location}")
+
+    dst = dst_1_to_1(src, "zero_padding", suffix)
+    x, y = src.get_data()
+    x_padded, y_padded = fourier.zero_padding(x, y, n_prepend, n_append)
+    dst.set_xydata(x_padded, y_padded)
+
+    return dst
+
+
+@computation_function()
+def fft(src: SignalObj, p: FFTParam | None = None) -> SignalObj:
+    """Compute FFT with :py:func:`sigima.tools.signal.fourier.fft1d`.
+
+    Args:
+        src: Source signal.
+        p: Parameters.
+
+    Returns:
+        Result signal object.
+    """
+    dst = dst_1_to_1(src, "fft")
+    x, y = src.get_data()
+    fft_x, fft_y = fourier.fft1d(x, y, shift=bool(True if p is None else p.shift))
+    dst.set_xydata(fft_x, fft_y)
+    dst.save_attr_to_metadata("xunit", "Hz" if dst.xunit == "s" else "")
+    dst.save_attr_to_metadata("yunit", "")
+    dst.save_attr_to_metadata("xlabel", _("Frequency"))
+    return dst
+
+
+@computation_function()
+def ifft(src: SignalObj) -> SignalObj:
+    """Compute the inverse FFT with :py:func:`sigima.tools.signal.fourier.ifft1d`.
+
+    Args:
+        src: Source signal.
+
+    Returns:
+        Result signal object.
+    """
+    dst = dst_1_to_1(src, "ifft")
+    f, sp = src.get_data()
+    x, y = fourier.ifft1d(f, sp)
+    dst.set_xydata(x, y)
+    dst.restore_attr_from_metadata("xunit", "s" if src.xunit == "Hz" else "")
+    dst.restore_attr_from_metadata("yunit", "")
+    dst.restore_attr_from_metadata("xlabel", "")
+    return dst
+
+
+@computation_function()
+def magnitude_spectrum(src: SignalObj, p: SpectrumParam | None = None) -> SignalObj:
+    """Compute magnitude spectrum.
+
+    This function computes the magnitude spectrum of a signal using
+    :py:func:`sigima.tools.signal.fourier.magnitude_spectrum`.
+
+    Args:
+        src: Source signal.
+        p: Parameters.
+
+    Returns:
+        Result signal object.
+    """
+    decibel = bool(p is not None and p.decibel)
+    dst = dst_1_to_1(src, "magnitude_spectrum", f"dB={decibel}")
+    x, y = src.get_data()
+    mag_x, mag_y = fourier.magnitude_spectrum(x, y, decibel=decibel)
+    dst.set_xydata(mag_x, mag_y)
+    dst.xlabel = _("Frequency")
+    dst.xunit = "Hz" if dst.xunit == "s" else ""
+    dst.yunit = "dB" if decibel else ""
+    return dst
+
+
+@computation_function()
+def phase_spectrum(src: SignalObj) -> SignalObj:
+    """Compute phase spectrum.
+
+    This function computes the phase spectrum of a signal using
+    :py:func:`sigima.tools.signal.fourier.phase_spectrum`
+
+    Args:
+        src: Source signal.
+
+    Returns:
+        Result signal object.
+    """
+    dst = dst_1_to_1(src, "phase_spectrum")
+    x, y = src.get_data()
+    phase_x, phase_y = fourier.phase_spectrum(x, y)
+    dst.set_xydata(phase_x, phase_y)
+    dst.xlabel = _("Frequency")
+    dst.xunit = "Hz" if dst.xunit == "s" else ""
+    dst.yunit = ""
+    return dst
+
+
+@computation_function()
+def psd(src: SignalObj, p: SpectrumParam | None = None) -> SignalObj:
+    """Compute power spectral density with :py:func:`sigima.tools.signal.fourier.psd`.
+
+    Args:
+        src: Source signal.
+        p: Parameters.
+
+    Returns:
+        Result signal object.
+    """
+    decibel = p is not None and p.decibel
+    dst = dst_1_to_1(src, "psd", f"dB={decibel}")
+    x, y = src.get_data()
+    psd_x, psd_y = fourier.psd(x, y, decibel=decibel)
+    dst.set_xydata(psd_x, psd_y)
+    dst.xlabel = _("Frequency")
+    dst.xunit = "Hz" if dst.xunit == "s" else ""
+    dst.yunit = "dB/Hz" if decibel else ""
+    return dst