tessl/pypi-pybaselines

A library of algorithms for the baseline correction of experimental data.

—

Pending

Overview

Eval results

Files

Morphological Methods

Name: tessl/pypi-pybaselines
Author: tessl

Mathematical morphology operations for baseline estimation using structuring elements and morphological transformations. These methods are particularly effective for chromatographic and mass spectrometry data, using operations like opening, closing, and erosion/dilation to separate baseline from peak features based on geometric properties.

Capabilities

Morphological Penalized Least Squares (mPLS)

Combines morphological operations with penalized least squares for hybrid baseline correction.

def mpls(data, half_window=None, lam=1e6, p=0.0, diff_order=2, tol=None, max_iter=None, weights=None, x_data=None):
    """
    Morphological penalized least squares baseline correction.
    
    Parameters:
    - data (array-like): Input y-values to fit baseline
    - half_window (int, optional): Half-window size for morphological operations
    - lam (float): Smoothing parameter for penalized least squares
    - p (float): Asymmetry parameter
    - diff_order (int): Order of differential matrix
    - tol (float, optional): Convergence tolerance (if None, uses default)
    - max_iter (int, optional): Maximum iterations (if None, uses default)
    - weights (array-like, optional): Initial weight array
    - x_data (array-like, optional): Input x-values
    
    Returns:
    tuple: (baseline, params)
    """

Morphological Opening (MOR)

Basic morphological baseline using opening operation (erosion followed by dilation).

def mor(data, half_window=None, x_data=None, window_kwargs=None, **kwargs):
    """
    Morphological baseline using opening operation.
    
    Parameters:
    - data (array-like): Input y-values to fit baseline
    - half_window (int, optional): Half-window size for structuring element
    - x_data (array-like, optional): Input x-values
    - window_kwargs (dict, optional): Window parameters for structuring element
    
    Returns:
    tuple: (baseline, params)
    """

Improved Morphological Opening (IMOR)

Enhanced morphological baseline with iterative refinement.

def imor(data, half_window=None, tol=1e-3, max_iter=200, x_data=None, window_kwargs=None, **kwargs):
    """
    Improved morphological baseline with iterative refinement.
    
    Parameters:
    - data (array-like): Input y-values to fit baseline
    - half_window (int, optional): Half-window size for operations
    - tol (float): Convergence tolerance for iterations
    - max_iter (int): Maximum iterations
    - x_data (array-like, optional): Input x-values
    - pad_kwargs (dict, optional): Padding parameters
    
    Returns:
    tuple: (baseline, params)
    """

Morphological Baseline with Mollification (MorMol)

Morphological baseline with mollification for smoothness improvement.

def mormol(data, half_window=None, tol=1e-3, max_iter=250, smooth_half_window=None, x_data=None, pad_kwargs=None):
    """
    Morphological baseline with mollification for smoothness.
    
    Parameters:
    - data (array-like): Input y-values to fit baseline
    - half_window (int, optional): Half-window size
    - tol (float): Convergence tolerance
    - max_iter (int): Maximum iterations
    - smooth_half_window (int, optional): Half-window for smoothing
    - x_data (array-like, optional): Input x-values
    - pad_kwargs (dict, optional): Padding parameters
    
    Returns:
    tuple: (baseline, params)
    """

Averaging Morphological Mollification (AMorMol)

Combines averaging with morphological mollification for improved baseline estimation.

def amormol(data, half_window=None, tol=1e-3, max_iter=200, pad_kwargs=None, x_data=None, **kwargs):
    """
    Averaging morphological baseline with mollification.
    
    Parameters:
    - data (array-like): Input y-values to fit baseline
    - half_window (int, optional): Half-window size
    - tol (float): Convergence tolerance
    - max_iter (int): Maximum iterations
    - pad_kwargs (dict, optional): Padding parameters
    - x_data (array-like, optional): Input x-values
    
    Returns:
    tuple: (baseline, params)
    """

Rolling Ball

Rolling ball algorithm that traces the path of a ball rolling under the data curve.

def rolling_ball(data, half_window=None, smooth_half_window=None, pad_kwargs=None, x_data=None):
    """
    Rolling ball baseline correction algorithm.
    
    Parameters:
    - data (array-like): Input y-values to fit baseline
    - half_window (int, optional): Half-window size (ball radius)
    - smooth_half_window (int, optional): Half-window for smoothing
    - pad_kwargs (dict, optional): Padding parameters
    - x_data (array-like, optional): Input x-values
    
    Returns:
    tuple: (baseline, params)
    """

Moving Window Minimum Value (MWMV)

Uses moving window minimum values for baseline estimation.

def mwmv(data, half_window=None, smooth_half_window=None, pad_kwargs=None, x_data=None):
    """
    Moving window minimum value baseline correction.
    
    Parameters:
    - data (array-like): Input y-values to fit baseline
    - half_window (int, optional): Half-window size for minimum calculation
    - smooth_half_window (int, optional): Half-window for smoothing
    - pad_kwargs (dict, optional): Padding parameters
    - x_data (array-like, optional): Input x-values
    
    Returns:
    tuple: (baseline, params)
    """

Top-Hat

Top-hat morphological operation for baseline extraction.

def tophat(data, half_window=None, x_data=None, window_kwargs=None, **kwargs):
    """
    Top-hat morphological baseline correction.
    
    Parameters:
    - data (array-like): Input y-values to fit baseline
    - half_window (int, optional): Half-window size for structuring element
    - x_data (array-like, optional): Input x-values
    - pad_kwargs (dict, optional): Padding parameters
    
    Returns:
    tuple: (baseline, params)
    """

Morphological Penalized Spline (MPSpline)

Combines morphological operations with penalized spline fitting.

def mpspline(data, half_window=None, lam=1e4, lam_smooth=1e-2, p=0.0, num_knots=100, spline_degree=3, diff_order=2, max_iter=50, tol=1e-3, weights=None, x_data=None):
    """
    Morphological penalized spline baseline correction.
    
    Parameters:
    - data (array-like): Input y-values to fit baseline
    - half_window (int, optional): Half-window for morphological operations
    - lam (float): Smoothing parameter for spline
    - lam_smooth (float): Smoothing parameter for morphological operations
    - p (float): Asymmetry parameter
    - num_knots (int): Number of knots for spline
    - spline_degree (int): Degree of spline
    - diff_order (int): Order of differential matrix
    - max_iter (int): Maximum iterations
    - tol (float): Convergence tolerance
    - weights (array-like, optional): Initial weight array
    - x_data (array-like, optional): Input x-values
    
    Returns:
    tuple: (baseline, params)
    """

Jansen-Berendschot Closing with Dilation (JBCD)

Advanced morphological method with closing and dilation operations.

def jbcd(data, half_window=None, alpha=0.1, beta=1e1, gamma=1., beta_mult=1.1, gamma_mult=0.909, tol=1e-3, max_iter=200, x_data=None):
    """
    Jansen-Berendschot Closing with Dilation baseline correction.
    
    Parameters:
    - data (array-like): Input y-values to fit baseline
    - half_window (int, optional): Half-window size
    - alpha (float): Asymmetry parameter
    - beta (float): Beta parameter for operations
    - gamma (float): Gamma parameter
    - beta_mult (float): Beta multiplication factor
    - gamma_mult (float): Gamma multiplication factor
    - tol (float): Convergence tolerance
    - max_iter (int): Maximum iterations
    - x_data (array-like, optional): Input x-values
    
    Returns:
    tuple: (baseline, params)
    """

Usage Examples

Basic morphological opening:

import numpy as np
from pybaselines.morphological import mor

# Sample chromatographic data
x = np.linspace(0, 30, 3000)  # 30 minutes
baseline = 100 + 2 * x  # Linear drift
peaks = (1000 * np.exp(-((x - 5) / 0.5)**2) +   # Sharp peak
         800 * np.exp(-((x - 15) / 1.2)**2) +    # Medium peak  
         600 * np.exp(-((x - 25) / 0.8)**2))     # Another peak
data = baseline + peaks

# Apply morphological opening
baseline_est, params = mor(data, half_window=50, x_data=x)
corrected = data - baseline_est

Rolling ball baseline:

from pybaselines.morphological import rolling_ball

# Good for mass spectrometry data
baseline_est, params = rolling_ball(data, half_window=100, x_data=x)
corrected = data - baseline_est

Iterative morphological refinement:

from pybaselines.morphological import imor

# Iteratively refined morphological baseline
baseline_est, params = imor(data, half_window=75, tol=1e-4, max_iter=50, x_data=x)
corrected = data - baseline_est

Install with Tessl CLI