Smoothing and filtering

Functions are provided to smooth and filter spectra. Smoothing is useful to remove noise from spectra, while filtering can be used to remove specific frequency components.

Below you will find the documentation of the relevant functions, and have a look at the example notebooks too: Example notebooks

Smoothing

_images/smooth.png

Rampy provides the rampy.smooth() function to smooth a spectrum. 10 different algorithms are available, see the notebook on Github for examples of use.

You can also directly use the Whittaker smoother. This can be useful if you want to use weights, which can allow you to avoid smoothing some regions for instance, or it can offer you more control.

You will find example notebooks below as well as the docstrings of the functions!

class rampy.filters.smooth(x: ndarray, y: ndarray, method: str = 'whittaker', **kwargs)

Bases:

Smooths the provided signal using various smoothing algorithms.

This function applies different smoothing techniques to the input signal, including Whittaker smoothing, Savitzky-Golay filtering, spline-based methods, and window-based filters. Each method is designed to reduce noise while preserving signal features.

Parameters:

  • x (np.ndarray) – The x-axis values (e.g., time or wavelength). For window-based methods, these values should be equally spaced.

  • y (np.ndarray) –

    The y-axis values to be smoothed. method (str): The smoothing method to apply. Default is “whittaker”.

    Available options:

    • ”whittaker”: Whittaker smoother (Eilers 2003).

    • ”savgol”: Savitzky-Golay filter.

    • ”GCVSmoothedNSpline”: Spline with generalized cross-validation.

    • ”MSESmoothedNSpline”: Spline with mean squared error criterion (requires the gcvspline library).

    • ”DOFSmoothedNSpline”: Spline with degrees of freedom criterion (requires the gcvspline library).

    • ”flat”: Moving average window.

    • ”hanning”, “hamming”, “bartlett”, “blackman”: Various window filters.

  • **kwargs –

    Additional parameters specific to the chosen method. - window_length (int): Length of the filter window for window-based methods

    and Savitzky-Golay filter. Must be a positive odd integer. Default is 5.

    • polyorder (int): Polynomial order for Savitzky-Golay filter. Must be less than window_length. Default is 2.

    • Lambda (float): Smoothing parameter for the Whittaker filter. Higher values produce smoother fits. Default is (10^5).

    • d (int): Difference order in the Whittaker filter. Default is 2.

    • ese_y (float or np.ndarray): Errors associated with y values for spline methods. Default is 1.0.

Returns:

The smoothed signal sampled on x.

Return type:

np.ndarray

Raises:

  • ValueError – If the input vector is smaller than the window size or if an invalid smoothing method is specified.

  • ImportError – If gcvspline is not installed when using MSESmoothedNSpline or DOFSmoothedNSpline.

Notes

  • The “whittaker” method implements the perfect smoother described by Eilers (2003).

  • The “savgol” method uses scipy.signal.savgol_filter().

  • Spline methods require scipy >= 1.10.0 or the gcvspline package.

  • Window-based methods are implemented following the SciPy Cookbook.

Examples

Smooth a noisy signal using Savitzky-Golay filtering:

>>> import numpy as np
>>> x = np.linspace(0, 100, 101)
>>> y = np.sin(x / 10) + np.random.normal(0, 0.1, size=x.size)
>>> smoothed_signal = smooth(x, y, method="savgol", window_length=7, polyorder=3)

Apply Whittaker smoothing:

>>> smoothed_signal = smooth(x, y, method="whittaker", Lambda=1e6)

Use a moving average window:

>>> smoothed_signal = smooth(x, y, method="flat", window_length=5)
class rampy.filters.whittaker(y: ndarray, weights: ndarray = None, **kwargs)

Bases:

Smooths a signal using the Whittaker smoother.

This function applies Whittaker smoothing to reduce noise in a signal while preserving its features. It uses penalized least squares optimization with a specified smoothing coefficient.

Parameters:

  • y (np.ndarray) – An array containing the values to smooth. The data should be equally spaced.

  • weights (np.ndarray, optional) – Weights for the signal. Regions with weight 0 will not

  • points. (be smoothed. Default is uniform weights across all) –

  • **kwargs –

    Additional parameters for Whittaker smoothing. - Lambda (float): The smoothing coefficient; higher values produce smoother results.

    Default is (10^5).

Returns:

An array containing the smoothed values.

Return type:

np.ndarray

Raises:

ValueError – If y or weights are invalid.

Notes

  • This implementation follows the description provided by Eilers (2003).

References

Eilers, P.H.C., 2003. A Perfect Smoother. Anal. Chem. 75, 3631–3636.

Examples

Smooth a noisy signal using default weights and Lambda:

>>> import numpy as np
>>> y = np.sin(np.linspace(0, 10, 100)) + np.random.normal(0, 0.1, size=100)
>>> smoothed_signal = whittaker(y)

Apply custom weights and Lambda:

>>> weights = np.ones(100)
>>> weights[40:60] = 0  # Do not smooth this region
>>> smoothed_signal = whittaker(y, weights=weights, Lambda=1e6)

Filtering

The rampy.spectrafilter() function allows you to filter your spectra using a Butterworth filter. Low, high, bandstop and bandpass filters are possible. Can be useful to remove wavelets from FTIR spectra for instance!

class rampy.filters.spectrafilter(spectre: ndarray, filtertype: str, fq: int, numtaps: int, columns: ndarray)

Bases:

Applies a Butterworth filter to specific columns of spectral data.

This function filters specific frequencies in the provided spectral data using a Butterworth filter. It supports low-pass, high-pass, band-pass, and band-stop filtering. The input spectra must be provided as an array where the first column represents the x-axis (e.g., wavelength or time), and subsequent columns represent the y-axis values of multiple spectra.

Parameters:

  • spectre (np.ndarray) – A 2D array of spectral data. The first column contains x-axis values (e.g., time or wavelength), and subsequent columns contain y-axis values for multiple spectra.

  • filtertype (str) – The type of filter to apply. Choose from: - ‘low’: Low-pass filter. - ‘high’: High-pass filter. - ‘bandpass’: Band-pass filter. - ‘bandstop’: Band-stop filter.

  • fq (float or np.ndarray) – The cutoff frequency/frequencies for the filter. For ‘low’ or ‘high’ filters, this is a single float value. For ‘bandpass’ or ‘bandstop’, this must be a sequence of two values [low_cutoff, high_cutoff].

  • numtaps (int) – The order of the Butterworth filter. Higher values result in sharper transitions but may introduce more ringing artifacts.

  • columns (np.ndarray) – An array specifying which columns in the input spectre to apply the filter to. Each value should correspond to a valid column index.

Returns:

A 2D array with the same shape as spectre, where the specified columns have been filtered.

Return type:

np.ndarray

Raises:

ValueError – If an invalid filtertype is provided or if fq is improperly specified for ‘bandpass’ or ‘bandstop’ filters.

Notes

  • The x-axis values (first column) are copied directly to the output without modification.

  • The cutoff frequencies (fq) are normalized based on the Nyquist frequency, which is calculated from the sampling rate inferred from the x-axis spacing.

  • The Butterworth filter is applied using zero-phase filtering (scipy.signal.filtfilt) to avoid phase distortion.

Examples

Apply a low-pass filter to a single spectrum:

>>> import numpy as np
>>> import rampy
>>> x = np.linspace(0, 10, 1000)  # Time axis
>>> y = np.sin(2 * np.pi * 5 * x) + np.sin(2 * np.pi * 50 * x)  # Signal with two frequencies
>>> spectre = np.column_stack((x, y))
>>> filtered_spectre = rampy.spectrafilter(spectre, filtertype='low', fq=10, numtaps=4, columns=np.array([1]))

Apply a band-pass filter to multiple spectra:

>>> spectre = np.column_stack((x, y, y * 0.5))  # Two spectra
>>> filtered_spectre = spectrafilter(spectre, filtertype='bandpass', fq=[5, 15], numtaps=4, columns=np.array([1, 2]))

References