microeye 2.3.2__py3-none-any.whl

microEye/analysis/fitting/psf/rubost_mean.py

@@ -0,0 +1,150 @@
+import numpy as np
+from scipy.optimize import fmin
+
+
+def robust_mean(
+        data: np.ndarray, axis: int=None, k_sigma: float=3, fit_mean: bool=False):
+    '''
+    Calculate robust mean, standard deviation, and indices of inliers and outliers.
+
+    Parameters
+    ----------
+    data : numpy.ndarray
+        Input data.
+    axis : int, optional
+        Axis along which the mean is taken. Default is None.
+    k_sigma : float, optional
+        Number of sigmas at which to place the cut-off. Default is 3.
+    fit_mean : bool, optional
+        Whether or not to use fitting to robustly estimate the mean.
+        Default is False.
+        If True, mean is approximated by minimizing the median deviation.
+        If False, mean is approximated by the median.
+
+    Returns
+    -------
+    final_mean : float
+        Robust mean.
+    std_sample : float
+        Standard deviation of the data (divide by sqrt(n) to get std of the mean).
+    inlier_idx : numpy.ndarray
+        Index into data with the inliers.
+    outlier_idx : numpy.ndarray
+        Index into data with the outliers.
+
+    Warning
+    -------
+    NaN or Inf will be counted as neither in- nor outlier.
+    The code is based on (linear) Least Median Squares and
+    can be changed to include weights.
+
+    References
+    ----------
+    J. Ries https://github.com/jries/SMAP
+
+    Example
+    -------
+    >>> import numpy as np
+    >>> from scipy.stats import norm
+    >>> data = np.concatenate([norm.rvs(loc=0, scale=1, size=100),
+    ...                         norm.rvs(loc=10, scale=1, size=5)])
+    >>> final_mean, std_sample, inlier_idx, outlier_idx = robust_mean(data)
+    '''
+    if data.size == 0:
+        raise ValueError('Parameter data should be non-empty ndarray!')
+
+    if axis is None:
+        # make sure that the axis is correct if there's a vector
+        if np.any(np.array(data.shape) == 1) and len(data.shape) == 2:
+            axis = np.where(np.array(data.shape) > 1)[0][0]
+        else:
+            axis = 0
+
+    if k_sigma is None:
+        k_sigma = 3
+
+    if fit_mean and len(data.shape) > 1:
+        raise ValueError(f'Fitting {len(data.shape)}-D data is not supported!')
+
+    if np.sum(np.isfinite(data)) < 4:
+        print('Warning: Less than 4 finite data points!')
+        finite_data = data[np.isfinite(data)]
+        final_mean = np.nanmean(finite_data, axis=axis)
+        std_sample = np.nanstd(finite_data, axis=axis)
+        inlier_idx = np.where(np.isfinite(data))
+        outlier_idx = np.array([], dtype=int)
+        return final_mean, std_sample, inlier_idx, outlier_idx
+
+    # LEAST MEDIAN SQUARES
+    # define magic numbers:
+    magic_number2 = 1.4826**2  # see Danuser, 1992 or Rousseeuw & Leroy, 1987
+
+    # store data size and reduced data size
+    data_size = np.array(data.shape)
+    reduced_data_size = data_size.copy()
+    reduced_data_size[axis] = 1
+
+    # need this for later
+    blow_up_data_size = data_size // reduced_data_size
+
+    # count relevant dimensions besides choosen axis
+    real_dimensions = np.sum(data_size > 1)
+
+    # compute median
+    if fit_mean:
+        # minimize the median deviation from the mean
+        median_data = fmin(lambda x: np.median(np.abs(data - x)), np.median(data))
+    else:
+        median_data = np.nanmedian(data, axis=axis, keepdims=True)
+
+    # calculate statistics
+    res2 = (data - np.tile(median_data, blow_up_data_size))**2
+    med_res2 = np.maximum(
+        np.nanmedian(res2, axis=axis, keepdims=True), np.finfo(float).eps)
+
+    # test value to calculate weights
+    test_value = res2 / np.tile(magic_number2 * med_res2, blow_up_data_size)
+
+    if real_dimensions == 1:
+        # goodRows: weight 1, badRows: weight 0
+        inlier_idx = np.where(test_value <= k_sigma**2)
+        outlier_idx = np.where(test_value > k_sigma**2)
+
+        # calculate std of the sample
+        if len(inlier_idx[0]) > 4:
+            std_sample = np.sqrt(np.sum(res2[inlier_idx]) / (len(inlier_idx[0]) - 4))
+        else:
+            std_sample = np.nan
+
+        # MEAN
+        final_mean = np.mean(data[inlier_idx])
+
+    else:
+        # goodRows: weight 1, badRows: weight 0
+        inlier_idx = np.where(test_value <= k_sigma**2)
+        outlier_idx = np.where(test_value > k_sigma**2)
+
+        # mask outliers
+        res2[outlier_idx] = np.nan
+
+        # count inliers
+        n_inliers = np.sum(~np.isnan(res2), axis=axis, keepdims=True)
+
+        # calculate std of the sample
+
+        # put NaN wherever there are not enough data points to calculate a
+        # standard deviation
+        good_idx = np.sum(np.isfinite(res2), axis=axis, keepdims=True) > 4
+        good_idx_broadcasted = np.broadcast_to(good_idx, res2.shape)
+        std_sample = np.full_like(good_idx, np.nan, dtype=float).squeeze()
+        if np.any(good_idx_broadcasted):
+            std_sample[:] = np.sqrt(
+                np.nansum(
+                    res2 * good_idx_broadcasted, axis=axis) / (n_inliers[good_idx] - 4)
+            ).squeeze()
+
+        # MEAN
+        data[outlier_idx] = np.nan
+        final_mean = np.nanmean(data, axis=axis)
+
+    return final_mean, std_sample, inlier_idx, outlier_idx

microEye/analysis/fitting/psf/spline.py

@@ -0,0 +1,167 @@
+import matplotlib.pyplot as plt
+import numpy as np
+from scipy.interpolate import UnivariateSpline, interp1d
+
+from microEye.analysis.fitting.pyfit3Dcspline.PSF.rubost_mean import robust_mean
+
+
+class Localization:
+    def __init__(self) -> None:
+        self.frames = None
+        self.frame_z0 = None
+        self.rois = None
+
+        self.fit_x = None
+        self.fit_y = None
+        self.fit_sigmax = None
+        self.fit_sigmay = None
+        self.fit_intensity = None
+        self.fit_background = None
+
+
+def get_spline_fits(beads: list[Localization], **kwargs):
+    # Initialize an empty list to store information about each curve
+    curves = []
+    dz = kwargs.get('dz', 10)
+
+    # Iterate over beads in reverse order
+    for bead in beads:
+        beadz0 = bead.frame_z0 * dz
+
+        if 'astig' in kwargs.get('zcorr', '') or 'corr' in kwargs.get('zcorr', ''):
+            beadz = (bead.frames * dz) - beadz0
+        else:
+            beadz = (bead.frames - kwargs['midpoint']) * dz
+
+        sx = bead.fit_sigmax
+        sy = bead.fit_sigmay
+        z = beadz
+        phot = bead.fit_intensity
+
+        # Filter values based on the specified z range
+        mask = (z >= kwargs['gaussrange'][0]) & (z <= kwargs['gaussrange'][1])
+
+        # Store information about the current curve
+        curves.append({
+            'sx': np.array(sx[mask]),
+            'sy': np.array(sy[mask]),
+            'z': np.array(z[mask]),
+            'phot': np.array(phot[mask]),
+            'xpos': np.mean(bead.fit_x),
+            'ypos': np.mean(bead.fit_y),
+        })
+
+    # Get calibrations
+    kwargs['ax'] = kwargs['ax_z']
+    spline, indgood = clean_and_get_spline(curves, **kwargs)
+
+    return spline, indgood, curves
+
+
+def clean_and_get_spline(curves, **kwargs):
+    """
+    Cleans the curves, fits splines, and returns the results.
+
+    Parameters:
+    - curves: List of curves containing 'sx', 'sy', and 'z'.
+    - p: Dictionary of parameters.
+
+    Returns:
+    - spline_result: Dictionary with 'x', 'y', 'zrange', and 'maxmaxrange'.
+    - indgood_result: Boolean array indicating 'good' curves.
+    """
+    za = np.concatenate([curve['z'] for curve in curves])
+    Sxa = np.concatenate([curve['sx'] for curve in curves])
+    Sya = np.concatenate([curve['sy'] for curve in curves])
+
+    indz = (za > kwargs['gaussrange'][0]) & (za < kwargs['gaussrange'][2])
+    z = za[indz]
+    Sx = Sxa[indz]
+    Sy = Sya[indz]
+
+    splinex = get_spline_interpolator(Sx, z, np.ones_like(z))
+    spliney = get_spline_interpolator(Sy, z, np.ones_like(z))
+
+    indgood2 = np.ones(len(curves), dtype=bool)
+
+    zg = np.concatenate([curve['z'][indgood2[i]] for i, curve in enumerate(curves)])
+    indz = (zg > kwargs['gaussrange'][0]) & (zg < kwargs['gaussrange'][2])
+    zg = zg[indz]
+    sxg = np.concatenate([curve['sx'][indgood2[i]] for i, curve in enumerate(curves)])
+    syg = np.concatenate([curve['sy'][indgood2[i]] for i, curve in enumerate(curves)])
+    sxg = sxg[indz]
+    syg = syg[indz]
+
+    splinex2 = get_spline_interpolator(sxg, zg, 1. / (np.abs(sxg - splinex(zg)) + 0.1))
+    spliney2 = get_spline_interpolator(syg, zg, 1. / (np.abs(syg - spliney(zg)) + 0.1))
+
+    zt = np.arange(min(zg), max(zg) + 0.01, 0.01)
+
+    plot_curves_and_spline(curves, indgood2, splinex2, spliney2, zt)
+
+    return {
+        'x': splinex2, 'y': spliney2,
+        'zrange': [zt[0], zt[-1]],
+        'maxmaxrange': [min(zg), max(zg)]}, indgood2
+
+
+def get_spline_interpolator(S, z, weights, smoothing_param=0.96):
+    '''
+    Returns a 1D cubic spline interpolator for given data.
+
+    Parameters:
+    - S: Values to be interpolated.
+    - z: Corresponding positions.
+    - weights: Weights for each data point.
+    - smoothing_param: Smoothing parameter for the spline.
+
+    Returns:
+    - spline: Cubic spline interpolator.
+    '''
+    sorted_indices = np.argsort(z)
+    sorted_z = np.sort(z)
+    sorted_S = S[sorted_indices]
+    sorted_weights = weights[sorted_indices]
+
+    spline = UnivariateSpline(
+        sorted_z, sorted_S, w=sorted_weights, k=3, s=smoothing_param)
+
+    return spline
+
+def plot_curves_and_spline(curves, indgood2, spline_x, spline_y, z_range):
+    """
+    Plots the curves, distinguished between 'good' and 'bad', and the splines.
+
+    Parameters:
+    - curves: List of curves containing 'sx', 'sy', and 'z'.
+    - indgood2: Boolean array indicating whether each curve is 'good'.
+    - spline_x: Interpolator for the x-coordinate.
+    - spline_y: Interpolator for the y-coordinate.
+    - z_range: Range of z values for plotting.
+    """
+    z1a, z2a, x1a, x2a = [], [], [], []
+
+    for k, curve in enumerate(curves):
+        if indgood2[k]:
+            z1a.extend(curve['z'])
+            x1a.extend(curve['sx'])
+        else:
+            z2a.extend(curve['z'])
+            x2a.extend(curve['sx'])
+
+    if not z2a:  # If z2a is empty, plot a bad point to have the legend correct
+        z2a = [0]
+        x2a = [0]
+
+    plt.plot(z2a, x2a, 'g.', label='Bad Curves')
+    plt.plot(z1a, x1a, 'r.', label='Good Curves')
+    plt.plot(z_range, spline_x(z_range), 'k', label='Spline X')
+    plt.plot(z_range, spline_y(z_range), 'k', label='Spline Y')
+
+    plt.xlim([z_range[0], z_range[-1]])
+    plt.ylim([0, min(5, max(max(spline_x(z_range)), max(spline_y(z_range))))])
+    plt.xlabel('z (nm)')
+    plt.ylabel('PSFx, PSFy (pixel)')
+    plt.title('Lateral size of the PSF')
+    plt.legend()
+    plt.show()

microEye/analysis/fitting/psf/stats/__init__.py

@@ -0,0 +1,12 @@
+from microEye.analysis.fitting.psf.stats.core import (
+    ConfidenceMethod,
+    StatConfig,
+    StatsCalculator,
+)
+from microEye.analysis.fitting.psf.stats.curve_fit import (
+    CurveAnalyzer,
+    CurveFitMethod,
+    CurveResult,
+)
+from microEye.analysis.fitting.psf.stats.io import export_fit_curve, import_fit_curve
+from microEye.analysis.fitting.psf.stats.slope_fit import SlopeAnalyzer, SlopeResult

microEye/analysis/fitting/psf/stats/core.py

@@ -0,0 +1,295 @@
+from dataclasses import dataclass
+from enum import Enum
+from typing import Callable, Optional, Union
+
+import numpy as np
+from scipy import stats
+
+from microEye.analysis.fitting.results import PARAMETER_HEADERS
+
+
+class ConfidenceMethod(Enum):
+    NONE = 'None'
+    MIN_MAX = 'min_max'
+    T_DIST = 't_dist'
+    MEDIAN_STD = 'median_std'
+    PERCENTILE = 'percentile'
+    BOOTSTRAP = 'bootstrap'
+
+
+@dataclass
+class StatConfig:
+    '''Configuration for a statistic calculation'''
+
+    name: str
+    required_params: list[str]  # Parameters required from header
+    calculator: Callable  # Function to calculate the statistic
+    multi_output: bool = False  # Whether the stat returns multiple values
+
+
+class StatsCalculator:
+    def __init__(self, zero_plane: int, z_step: float, fitting_method: str):
+        self.zero_plane = zero_plane
+        self.z_step = z_step
+        self.fitting_method = fitting_method
+        self.header = PARAMETER_HEADERS[fitting_method]
+        self._register_stats()
+
+    def _register_stats(self):
+        '''Register all available statistics calculations'''
+        self.available_stats: dict[str, StatConfig] = {
+            'Counts': StatConfig(
+                name='Counts', required_params=[], calculator=lambda rois, _: len(rois)
+            ),
+            'Sigma': StatConfig(
+                name='Sigma',
+                required_params=['sigmax', 'sigmay'],
+                calculator=self._calc_sigma,
+                multi_output=True,
+            ),
+            'Sigma (sum)': StatConfig(
+                name='Sigma (sum)',
+                required_params=['sigmax', 'sigmay'],
+                calculator=lambda data_x, data_y: data_x + data_y,
+            ),
+            'Sigma (diff)': StatConfig(
+                name='Sigma (diff)',
+                required_params=['sigmax', 'sigmay'],
+                calculator=lambda data_x, data_y: data_x - data_y,
+            ),
+            'Sigma (abs(diff))': StatConfig(
+                name='Sigma (abs(diff))',
+                required_params=['sigmax', 'sigmay'],
+                calculator=lambda data_x, data_y: np.abs(data_x - data_y),
+            ),
+            'Sigma (x/y)': StatConfig(
+                name='Sigma (x/y)',
+                required_params=['sigmax', 'sigmay'],
+                calculator=lambda data_x, data_y: np.divide(
+                    data_x, data_y, out=np.zeros_like(data_x), where=data_y != 0
+                ),
+            ),
+            'Sigma² (diff)': StatConfig(
+                name='Sigma² (diff)',
+                required_params=['sigmax', 'sigmay'],
+                calculator=lambda data_x, data_y: np.square(data_x) - np.square(data_y),
+            ),
+            'Intensity': StatConfig(
+                name='Intensity',
+                required_params=['intensity'],
+                calculator=lambda data: data,
+            ),
+            'Background': StatConfig(
+                name='Background',
+                required_params=['background'],
+                calculator=lambda data: data,
+            ),
+        }
+
+    def _calc_sigma(
+        self, data_x: Optional[np.ndarray], data_y: Optional[np.ndarray]
+    ) -> list[np.ndarray]:
+        '''Calculate sigma statistics for x and y dimensions'''
+        results = []
+        for data in [data_x, data_y]:
+            if data is not None:
+                results.append(data)
+        return results
+
+    def _get_param_data(self, z_slice: dict, param_name: str) -> Optional[np.ndarray]:
+        '''Extract parameter data from z_slice if parameter exists'''
+        if param_name in self.header:
+            return z_slice['params'][:, self.header.index(param_name)]
+        return None
+
+    def _calculate_confidence_interval(
+        self,
+        data: np.ndarray,
+        method: ConfidenceMethod,
+        confidence_level: float = 0.95,
+        n_bootstrap: int = 1000,
+    ) -> tuple[float, float]:
+        '''Calculate confidence intervals using various methods'''
+        if len(data) == 0 or method == ConfidenceMethod.NONE:
+            return np.nan, np.nan
+
+        if method == ConfidenceMethod.MIN_MAX:
+            return np.nanmin(data), np.nanmax(data)
+
+        elif method == ConfidenceMethod.T_DIST:
+            if len(data) < 2:
+                return np.nan, np.nan
+            mean = np.nanmean(data)
+            std_err = np.nanstd(data, ddof=1) / np.sqrt(len(data))
+            t_value = stats.t.ppf((1 + confidence_level) / 2, len(data) - 1)
+            margin = t_value * std_err
+            return mean - margin, mean + margin
+
+        elif method == ConfidenceMethod.MEDIAN_STD:
+            median = np.nanmedian(data)
+            std = np.nanstd(data)
+            return median - std, median + std
+
+        elif method == ConfidenceMethod.PERCENTILE:
+            lower = (1 - confidence_level) / 2 * 100
+            upper = (1 + confidence_level) / 2 * 100
+            return np.nanpercentile(data, [lower, upper])
+
+        elif method == ConfidenceMethod.BOOTSTRAP:
+            if len(data) < 2:
+                return np.nan, np.nan
+            bootstrap_means = []
+            for _ in range(n_bootstrap):
+                sample = np.random.choice(data, size=len(data), replace=True)
+                bootstrap_means.append(np.nanmean(sample))
+            return np.percentile(
+                bootstrap_means,
+                [(1 - confidence_level) / 2 * 100, (1 + confidence_level) / 2 * 100],
+            )
+
+    def _calculate_stats(
+        self,
+        z_slice: dict[str, Union[int, np.ndarray, list, float]],
+        stat_config: StatConfig,
+        confidence_method: ConfidenceMethod = ConfidenceMethod.MIN_MAX,
+        confidence_level: float = 0.95,
+    ) -> tuple[list[float], list[float], list[float]]:
+        '''Calculate statistics for a single z-slice'''
+        if z_slice['rois'] is None:
+            return self._get_nan_result(stat_config.multi_output)
+
+        valid_rois = z_slice['rois'][~np.isnan(z_slice['rois']).any(axis=(1, 2))]
+
+        if len(valid_rois) == 0 and stat_config.name != 'Counts':
+            return self._get_nan_result(stat_config.multi_output)
+
+        if stat_config.name == 'Counts':
+            return [len(valid_rois)], [len(valid_rois)], [len(valid_rois)]
+
+        # Extract required parameters
+        param_data = [
+            self._get_param_data(z_slice, param)
+            for param in stat_config.required_params
+        ]
+
+        if (
+            any(data is None for data in param_data)
+            and len(stat_config.required_params) > 0
+        ):
+            return self._get_nan_result(stat_config.multi_output)
+
+        # Calculate statistics
+        result = stat_config.calculator(*param_data)
+        if stat_config.multi_output:
+            means = [np.nanmean(r) for r in result]
+            conf_intervals = [
+                self._calculate_confidence_interval(
+                    r, confidence_method, confidence_level
+                )
+                for r in result
+            ]
+            return (
+                means,
+                [ci[0] for ci in conf_intervals],
+                [ci[1] for ci in conf_intervals],
+            )
+
+        mean = np.nanmean(result)
+        lower, upper = self._calculate_confidence_interval(
+            result, confidence_method, confidence_level
+        )
+        return [mean], [lower], [upper]
+
+    def _get_nan_result(
+        self, multi_output: bool
+    ) -> tuple[list[float], list[float], list[float]]:
+        '''Return NaN results based on whether multiple outputs are expected'''
+        if multi_output:
+            return [np.nan, np.nan], [np.nan, np.nan], [np.nan, np.nan]
+        return [np.nan], [np.nan], [np.nan]
+
+    def get_stats(
+        self,
+        zslices: list[dict[str, Union[int, np.ndarray, list, float]]],
+        selected_stat: str,
+        confidence_method: ConfidenceMethod = ConfidenceMethod.MIN_MAX,
+        confidence_level: float = 0.95,
+    ):
+        '''
+        Get the statistic data for all z-slices.
+
+        Parameters
+        ----------
+        selected_stat : str
+            The selected statistic to return
+
+        Returns
+        -------
+        tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]
+            Z-indices, statistic data, minimum data, maximum
+        '''
+        if selected_stat not in self.available_stats:
+            raise ValueError(f'Unknown statistic: {selected_stat}')
+
+        z_indices = (np.arange(len(zslices)) - self.zero_plane) * self.z_step
+        stat_config = self.available_stats[selected_stat]
+
+        param_stat = []
+        param_lower = []
+        param_upper = []
+
+        # Initialize lists for multi-output statistics
+        if stat_config.multi_output:
+            param_stat = [[] for _ in range(len(stat_config.required_params))]
+            param_lower = [[] for _ in range(len(stat_config.required_params))]
+            param_upper = [[] for _ in range(len(stat_config.required_params))]
+
+        for z_slice in zslices:
+            stats, mins, maxs = self._calculate_stats(
+                z_slice, stat_config, confidence_method, confidence_level
+            )
+
+            if stat_config.multi_output:
+                for i, (stat, min_val, max_val) in enumerate(zip(stats, mins, maxs)):
+                    param_stat[i].append(stat)
+                    param_lower[i].append(min_val)
+                    param_upper[i].append(max_val)
+            else:
+                param_stat.extend(stats)
+                param_lower.extend(mins)
+                param_upper.extend(maxs)
+
+        return (
+            z_indices,
+            np.array(param_stat),
+            np.array(param_lower),
+            np.array(param_upper),
+        )
+
+    def add_statistic(
+        self,
+        name: str,
+        required_params: list[str],
+        calculator: Callable,
+        multi_output: bool = False,
+    ):
+        '''
+        Add a new statistic calculation method.
+
+        Parameters
+        ----------
+        name : str
+            Name of the new statistic
+        required_params : list[str]
+            List of parameter names required from the header
+        calculator : Callable
+            Function to calculate the statistic
+        multi_output : bool, optional
+            Whether the statistic returns multiple values, by default False
+        '''
+        self.available_stats[name] = StatConfig(
+            name=name,
+            required_params=required_params,
+            calculator=calculator,
+            multi_output=multi_output,
+        )