microeye 2.3.2__py3-none-any.whl

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

@@ -0,0 +1,104 @@
+import json
+import os
+from dataclasses import asdict
+from typing import Optional, Union
+
+from microEye.analysis.fitting.psf.stats.curve_fit import CurveFitMethod, CurveResult
+from microEye.analysis.fitting.psf.stats.slope_fit import SlopeResult
+from microEye.qt import QtWidgets, getOpenFileName, getSaveFileName
+from microEye.utils.enum_encoder import EnumEncoder
+
+
+def import_fit_curve(parent: Optional[QtWidgets.QWidget] = None, curDir: str = ''):
+    '''
+    Import curve fit results from a JSON file.
+
+    Parameters
+    ----------
+    parent : Optional[QtWidgets.QWidget]
+        Parent widget for file dialog
+    curDir : str
+        Initial directory for file dialog
+
+    Notes
+    -----
+    This function requires a QApplication instance to be running
+
+    Returns
+    -------
+    Tuple[Union[SlopeResult, CurveResult], str]
+        The curve fit results and the
+        filename from which they were imported
+    '''
+    filename, _ = getOpenFileName(
+        parent,
+        'Open Curve Fit',
+        curDir,
+        'JSON Files (*.json)',
+    )
+
+    if not filename:
+        return None, None
+
+    with open(filename) as file:
+        data = json.load(file)
+
+    if 'method' not in data:
+        return None, None
+
+    try:
+        data['method'] = CurveFitMethod(data['method'])
+
+        if data['method'] == CurveFitMethod.LINEAR:
+            return SlopeResult(**data), filename
+        else:
+            return CurveResult(**data), filename
+    except ValueError:
+        # Value is not a valid enum member; keep as is
+        return None, None
+
+
+def export_fit_curve(
+    results: Union[SlopeResult, CurveResult],
+    parent: Optional[QtWidgets.QWidget] = None,
+    curDir: str = '',
+):
+    '''
+    Export curve fit results to a JSON file.
+
+    Parameters
+    ----------
+    results : Union[SlopeResult, CurveResult]
+        The curve fit results to export
+    parent : Optional[QtWidgets.QWidget]
+        Parent widget for file dialog
+    curDir : str
+        Initial directory for file dialog
+
+    Notes
+    -----
+    This function requires a QApplication instance to be running
+
+    Returns
+    -------
+    bool
+        True if the results were successfully exported
+    '''
+    if results is None:
+        return False
+
+    filename, _ = getSaveFileName(
+        parent,
+        'Save Curve Fit',
+        curDir,
+        'JSON Files (*.json)',
+    )
+
+    if not filename:
+        return False
+
+    if isinstance(results, (SlopeResult, CurveResult)):
+        with open(filename, 'w') as file:
+            json.dump(asdict(results), file, cls=EnumEncoder)
+
+        return True

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

@@ -0,0 +1,171 @@
+from dataclasses import dataclass
+from typing import Callable, Optional
+
+import numpy as np
+from scipy import stats
+
+from microEye.analysis.fitting.psf.stats.core import ConfidenceMethod
+from microEye.analysis.fitting.psf.stats.curve_fit import CurveFitMethod
+
+
+@dataclass
+class SlopeResult:
+    '''Results from slope analysis'''
+    slope: float
+    intercept: float
+    r_squared: float
+    p_value: float
+    slope_ci: tuple[float, float]
+    data : dict
+    zero_crossing: Optional[float] = None
+    zero_crossing_ci: Optional[tuple[float, float]] = None
+    method: CurveFitMethod = CurveFitMethod.LINEAR
+
+class SlopeAnalyzer:
+    @staticmethod
+    def fit_stat_slope(
+        selected_stat: str,
+        get_stats: Callable,
+        region: tuple[int, int],
+        confidence_method: ConfidenceMethod = ConfidenceMethod.T_DIST,
+        confidence_level: float = 0.95,
+    ) -> Optional[SlopeResult]:
+        '''
+        Calculate slope and related statistics for the
+        selected statistic in the given region.
+
+        Parameters
+        ----------
+        selected_stat : str
+            The statistic to analyze
+        stats_calculator : StatsCalculator
+            Calculator for the statistic
+        region : tuple[int, int]
+            The z-region to analyze (start, end)
+        confidence_method : ConfidenceMethod
+            Method to calculate confidence intervals
+        confidence_level : float
+            Confidence level for intervals (0-1)
+
+        Returns
+        -------
+        Optional[SlopeResult]
+            Slope analysis results including confidence intervals and zero crossing
+        '''
+        if selected_stat not in ['Sigma (diff)', 'Sigma (x/y)', 'Sigma² (diff)']:
+            return None
+
+
+        # Get z values and stat data
+        z_indices, stat_data, lower_bounds, upper_bounds = get_stats()
+
+        # Select data within region
+        mask = (z_indices >= region[0]) & (z_indices <= region[1])
+        x_data = z_indices[mask]
+        y_data = stat_data[mask]
+
+        # Remove any NaN values
+        valid_mask = ~np.isnan(y_data)
+        x_data = x_data[valid_mask]
+        y_data = y_data[valid_mask]
+
+        if len(x_data) < 2:
+            return None
+
+        # Perform linear regression
+        slope, intercept, r_value, p_value, slope_std_err = stats.linregress(
+            x_data, y_data
+        )
+        r_squared = r_value**2
+
+        # Calculate slope confidence intervals
+        if confidence_method == ConfidenceMethod.T_DIST:
+            # t-distribution based CI
+            dof = len(x_data) - 2
+            t_val = stats.t.ppf((1 + confidence_level) / 2, dof)
+            slope_ci = (slope - t_val * slope_std_err, slope + t_val * slope_std_err)
+        elif confidence_method == ConfidenceMethod.BOOTSTRAP:
+            # Bootstrap confidence intervals for slope
+            n_bootstrap = 1000
+            bootstrap_slopes = []
+            for _ in range(n_bootstrap):
+                indices = np.random.randint(0, len(x_data), size=len(x_data))
+                x_boot = x_data[indices]
+                y_boot = y_data[indices]
+                boot_slope = np.polyfit(x_boot, y_boot, 1)[0]
+                bootstrap_slopes.append(boot_slope)
+            slope_ci = np.percentile(
+                bootstrap_slopes,
+                [(1 - confidence_level) * 100 / 2, (1 + confidence_level) * 100 / 2],
+            )
+        else:
+            # Simple min/max based on data uncertainty
+            lower_slope = np.polyfit(x_data, lower_bounds[mask][valid_mask], 1)[0]
+            upper_slope = np.polyfit(x_data, upper_bounds[mask][valid_mask], 1)[0]
+            slope_ci = (lower_slope, upper_slope)
+
+        # Calculate zero crossing
+        target = 0 if selected_stat == 'Sigma (diff)' else 1
+        zero_crossing = (target - intercept) / slope if abs(slope) > 1e-10 else None
+
+        # Calculate zero crossing confidence intervals
+        if zero_crossing is not None:
+            if confidence_method == ConfidenceMethod.T_DIST:
+                # Use error propagation for zero crossing uncertainty
+                intercept_std_err = stats.linregress(x_data, y_data).intercept_stderr
+                zero_crossing_err = np.sqrt(
+                    (intercept_std_err / slope) ** 2
+                    + ((target - intercept) * slope_std_err / slope**2) ** 2
+                )
+                t_val = stats.t.ppf((1 + confidence_level) / 2, len(x_data) - 2)
+                zero_crossing_ci = (
+                    zero_crossing - t_val * zero_crossing_err,
+                    zero_crossing + t_val * zero_crossing_err,
+                )
+            elif confidence_method == ConfidenceMethod.BOOTSTRAP:
+                # Bootstrap zero crossings
+                bootstrap_crossings = []
+                for _ in range(n_bootstrap):
+                    indices = np.random.randint(0, len(x_data), size=len(x_data))
+                    x_boot = x_data[indices]
+                    y_boot = y_data[indices]
+                    boot_slope, boot_intercept = np.polyfit(x_boot, y_boot, 1)
+                    if abs(boot_slope) > 1e-10:
+                        boot_crossing = (target - boot_intercept) / boot_slope
+                        bootstrap_crossings.append(boot_crossing)
+                if bootstrap_crossings:
+                    zero_crossing_ci = np.percentile(
+                        bootstrap_crossings,
+                        [
+                            (1 - confidence_level) * 100 / 2,
+                            (1 + confidence_level) * 100 / 2,
+                        ],
+                    )
+                else:
+                    zero_crossing_ci = None
+            else:
+                # Simple interval based on slope confidence intervals
+                crossings = [
+                    (target - intercept) / s for s in slope_ci if abs(s) > 1e-10
+                ]
+                zero_crossing_ci = (
+                    (min(crossings), max(crossings)) if crossings else None
+                )
+        else:
+            zero_crossing_ci = None
+
+        return SlopeResult(
+            slope=slope,
+            intercept=intercept,
+            r_squared=r_squared,
+            p_value=p_value,
+            slope_ci=slope_ci,
+            zero_crossing=zero_crossing,
+            zero_crossing_ci=zero_crossing_ci,
+            data = {
+                'z': x_data.tolist(),
+                'ratio': y_data.tolist(),
+                'lower_bounds': lower_bounds[mask][valid_mask].tolist(),
+                'upper_bounds': upper_bounds[mask][valid_mask].tolist()
+            }
+        )

microEye/analysis/fitting/psf/temp.py

@@ -0,0 +1,147 @@
+import numpy as np
+from scipy.optimize import fmin
+
+
+def robust_mean(data: np.ndarray, dim: int=None, k: float=3, fit: bool=False):
+    '''
+    Calculate robust mean, standard deviation, and indices of inliers and outliers.
+
+    Parameters
+    ----------
+    data : numpy.ndarray
+        Input data.
+    dim : int, optional
+        Dimension along which the mean is taken. Default is None.
+    k : float, optional
+        Number of sigmas at which to place the cut-off. Default is 3.
+    fit : 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('Please supply non-empty data to robust_mean')
+
+    if dim is None:
+        # make sure that the dimension is correct if there's a vector
+        if np.any(np.array(data.shape) == 1) and len(data.shape) == 2:
+            dim = np.where(np.array(data.shape) > 1)[0][0]
+        else:
+            dim = 0
+
+    if k is None:
+        k=3
+
+    if fit 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 data points!')
+        finite_data = data[np.isfinite(data)]
+        final_mean = np.nanmean(finite_data, axis=dim)
+        std_sample = np.nanstd(finite_data, axis=dim)
+        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
+
+    # remember data size and reduced dataSize
+    data_size = np.array(data.shape)
+    reduced_data_size = data_size.copy()
+    reduced_data_size[dim] = 1
+
+    # need this for later repmats
+    blow_up_data_size = data_size // reduced_data_size
+
+    # count how many relevant dimensions we have besides dim
+    real_dimensions = np.sum(data_size > 1)
+
+    # calc median - reduce dimension dim to length 1
+    if fit:
+        # 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=dim)
+
+    # calculate statistics
+    res2 = (data - np.tile(median_data, blow_up_data_size))**2
+    med_res2 = np.maximum(np.nanmedian(res2, axis=dim), 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**2)
+        outlier_idx = np.where(test_value > k**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**2)
+        outlier_idx = np.where(test_value > k**2)
+
+        # mask outliers
+        res2[outlier_idx] = np.nan
+
+        # count inliers
+        n_inliers = np.sum(~np.isnan(res2), axis=dim)
+
+        # calculate std of the sample;
+        if np.any(n_inliers > 4):
+            # put NaN wherever there are not enough data points to calculate a
+            # standard deviation
+            good_idx = np.sum(np.isfinite(res2), axis=dim) > 4
+            std_sample = np.full_like(good_idx, np.nan, dtype=float)
+            std_sample[good_idx] = np.sqrt(
+                np.nansum(res2[good_idx], axis=dim) / (n_inliers[good_idx] - 4)
+            )
+        else:
+            std_sample = np.full_like(n_inliers, np.nan, dtype=float)
+
+        # MEAN
+        data[outlier_idx] = np.nan
+        final_mean = np.nanmean(data, axis=dim)
+
+    return final_mean, std_sample, inlier_idx, outlier_idx

microEye/analysis/fitting/psf/test.py

@@ -0,0 +1,47 @@
+import numpy as np
+
+
+# Placeholder functions, replace with actual implementations
+def images2beads_globalfit(p):
+    # Replace with actual implementation
+    pass
+
+def mleFit_LM(stack, num_params, max_iterations, tol, display, verbose):
+    # Replace with actual implementation
+    pass
+
+def stackas2z_so(PSFxpix, PSFypix, frames, phot, p):
+    # Replace with actual implementation
+    pass
+
+def getspline_so(beadsh, p):
+    # Replace with actual implementation
+    pass
+
+def getstackcal_g(beadsh, p):
+    # Replace with actual implementation
+    pass
+
+def getgausscal_so(ch, p):
+    # Replace with actual implementation
+    pass
+
+def testfit_spline(testallrois, coeffZ, i, p, cellarray, axzernikef):
+    # Replace with actual implementation
+    pass
+
+def plotCRLBcsplinePSF(cspline, axcrlb):
+    # Replace with actual implementation
+    pass
+
+def vectorPSF2cspline(num, zernikefit, p):
+    # Replace with actual implementation
+    pass
+
+def zernikefitBeadstack(stack, zernikefit_params, axzernike, axPupil, axMode):
+    # Replace with actual implementation
+    pass
+
+def Spline3D_interp(PSFZernike):
+    # Replace with actual implementation
+    pass