nanopyx.methods.esrrf.eSRRF_workflow

  1from ..workflow import Workflow
  2from ...core.transform import eSRRF_ST
  3from ...core.transform.mpcorrector import macro_pixel_corrector
  4from ...core.transform.sr_temporal_correlations import (
  5    calculate_eSRRF_temporal_correlations,
  6)
  7import numpy as np
  8
  9# TODO check correlations and error map
 10
 11
 12def eSRRF(
 13    image,
 14    magnification: int = 5,
 15    radius: float = 1.5,
 16    sensitivity: float = 1,
 17    frames_per_timepoint: int = 0,
 18    temporal_correlation: str = "AVG",
 19    doIntensityWeighting: bool = True,
 20    macro_pixel_correction: bool = True,
 21    pad_edges: bool = False,
 22    _force_run_type=None,
 23):
 24    """
 25    Perform eSRRF analysis on an image.
 26
 27    Args:
 28          image (numpy.ndarray): The input image for eSRRF analysis.
 29          magnification (int, optional): Magnification factor (default is 5).
 30          radius (float, optional): Radius parameter for eSRRF analysis (default is 1.5).
 31          sensitivity (float, optional): Sensitivity parameter for eSRRF analysis (default is 1).
 32          frames_per_timepoint (int, optional): Number of frames per timepoint (default is 0, which means all frames are used).
 33          temporal_correlation (str, optional): Type of temporal correlation to calculate. Options are: AVG, VAR or TAC2 (default is "AVG").
 34          doIntensityWeighting (bool, optional): Enable intensity weighting (default is True).
 35          macro_pixel_correction (bool, optional): Enable macro pixel correction (default is True).
 36          pad_edges (bool, optional): Enable edge padding for borders calculation instead of setting the edges to 0 (default is False).
 37          _force_run_type (str, optional): Force a specific run type for the analysis (default is None).
 38
 39    Returns:
 40          numpy.ndarray: The result of eSRRF analysis, typically representing the localizations.
 41
 42    Example:
 43          result = eSRRF(image, magnification=5, radius=1.5, sensitivity=1, doIntensityWeighting=True)
 44
 45    Note:
 46          - eSRRF (enhanced Super-Resolution Radial Fluctuations) is a method for super-resolution localization microscopy.
 47          - This function sets up a workflow to perform eSRRF analysis on the input image.
 48          - The workflow includes eSRRF_ST as a step and can be customized with various parameters.
 49          - The result is typically a numpy array representing the localized points.
 50
 51    See Also:
 52          - eSRRF_ST: The eSRRF step that performs the actual analysis.
 53          - Workflow: The class used to define and run analysis workflows.
 54    """
 55
 56    if frames_per_timepoint == 0:
 57        frames_per_timepoint = image.shape[0]
 58    elif frames_per_timepoint > image.shape[0]:
 59        frames_per_timepoint = image.shape[0]
 60
 61    number_of_timepoints = image.shape[0] // frames_per_timepoint
 62    if image.shape[0] % frames_per_timepoint != 0:
 63        number_of_timepoints += 1
 64
 65    output_array = np.zeros(
 66        (
 67            number_of_timepoints,
 68            image.shape[1] * magnification,
 69            image.shape[2] * magnification,
 70        ),
 71        dtype=np.float32,
 72    )
 73
 74    for i in range(number_of_timepoints):
 75
 76        _eSRRF = Workflow(
 77            (
 78                eSRRF_ST(verbose=False),
 79                (
 80                    image[
 81                        frames_per_timepoint
 82                        * i : frames_per_timepoint
 83                        * (i + 1)
 84                    ],
 85                ),
 86                {
 87                    "magnification": magnification,
 88                    "radius": radius,
 89                    "sensitivity": sensitivity,
 90                    "doIntensityWeighting": doIntensityWeighting,
 91                    "pad_edges": pad_edges,
 92                },
 93            )
 94        )
 95        if macro_pixel_correction:
 96            output_array[i] = macro_pixel_corrector(
 97                np.expand_dims(
 98                    np.asarray(
 99                        calculate_eSRRF_temporal_correlations(
100                            _eSRRF.calculate(_force_run_type=_force_run_type)[
101                                0
102                            ],
103                            temporal_correlation,
104                        )
105                    ),
106                    axis=0,
107                ),
108                magnification=magnification,
109            )
110        else:
111            output_array[i] = np.asarray(
112                calculate_eSRRF_temporal_correlations(
113                    _eSRRF.calculate(_force_run_type=_force_run_type)[0],
114                    temporal_correlation,
115                )
116            )
117
118    return np.squeeze(output_array.astype(np.float32))