phasorpy 0.2__cp313-cp313-win_amd64.whl → 0.4__cp313-cp313-win_amd64.whl

phasorpy/_phasorpy.pyx

@@ -49,6 +49,12 @@ ctypedef fused float_t:
     float
     double
 
+ctypedef fused uint_t:
+    uint8_t
+    uint16_t
+    uint32_t
+    uint64_t
+
 ctypedef fused signal_t:
     uint8_t
     uint16_t
@@ -68,7 +74,8 @@ def _phasor_from_signal(
     float_t[:, :, ::1] phasor,
     const signal_t[:, :, ::1] signal,
     const double[:, :, ::1] sincos,
-    const int num_threads
+    const bint normalize,
+    const int num_threads,
 ):
     """Return phasor coordinates from signal along middle axis.
 
@@ -97,6 +104,8 @@ def _phasor_from_signal(
         1. number samples
         2. cos and sin
 
+    normalize : bool
+        Normalize phasor coordinates.
     num_threads : int
         Number of OpenMP threads to use for parallelization.
 
@@ -145,14 +154,16 @@ def _phasor_from_signal(
                             dc = dc + sample
                             re = re + sample * sincos[h, k, 0]
                             im = im + sample * sincos[h, k, 1]
-                        if dc != 0.0:
-                            re = re / dc
-                            im = im / dc
-                            dc = dc /samples
-                        else:
-                            dc = 0.0
-                            re = NAN if re == 0.0 else re * INFINITY
-                            im = NAN if im == 0.0 else im * INFINITY
+                        if normalize:
+                            if dc != 0.0:
+                                # includes isnan(dc)
+                                re = re / dc
+                                im = im / dc
+                                dc = dc / samples
+                            else:
+                                # dc = 0.0
+                                re = NAN if re == 0.0 else re * INFINITY
+                                im = NAN if im == 0.0 else im * INFINITY
                         if h == 0:
                             mean[i, j] = <float_t> dc
                         real[h, i, j] = <float_t> re
@@ -173,14 +184,16 @@ def _phasor_from_signal(
                             dc = dc + sample
                             re = re + sample * sincos[h, k, 0]
                             im = im + sample * sincos[h, k, 1]
-                        if dc != 0.0:
-                            re = re / dc
-                            im = im / dc
-                            dc = dc /samples
-                        else:
-                            dc = 0.0
-                            re = NAN if re == 0.0 else re * INFINITY
-                            im = NAN if im == 0.0 else im * INFINITY
+                        if normalize:
+                            if dc != 0.0:
+                                # includes isnan(dc)
+                                re = re / dc
+                                im = im / dc
+                                dc = dc / samples
+                            else:
+                                # dc = 0.0
+                                re = NAN if re == 0.0 else re * INFINITY
+                                im = NAN if im == 0.0 else im * INFINITY
                         if h == 0:
                             mean[i, j] = <float_t> dc
                         real[h, i, j] = <float_t> re
@@ -201,14 +214,16 @@ def _phasor_from_signal(
                             dc += sample
                             re += sample * sincos[h, k, 0]
                             im += sample * sincos[h, k, 1]
-                        if dc != 0.0:
-                            re /= dc
-                            im /= dc
-                            dc /= samples
-                        else:
-                            dc = 0.0
-                            re = NAN if re == 0.0 else re * INFINITY
-                            im = NAN if im == 0.0 else im * INFINITY
+                        if normalize:
+                            if dc != 0.0:
+                                # includes isnan(dc)
+                                re /= dc
+                                im /= dc
+                                dc = dc / samples
+                            else:
+                                # dc = 0.0
+                                re = NAN if re == 0.0 else re * INFINITY
+                                im = NAN if im == 0.0 else im * INFINITY
                         if h == 0:
                             mean[i, j] = <float_t> dc
                         real[h, i, j] = <float_t> re
@@ -924,32 +939,41 @@ cdef (float_t, float_t) _phasor_at_harmonic(
 
 @cython.ufunc
 cdef (float_t, float_t) _phasor_multiply(
-    float_t real1,
-    float_t imag1,
+    float_t real,
+    float_t imag,
     float_t real2,
     float_t imag2,
 ) noexcept nogil:
-    """Return multiplication of two phasors."""
-    return real1 * real2 - imag1 * imag2, real1 * imag2 + imag1 * real2
+    """Return complex multiplication of two phasors."""
+    return (
+        real * real2 - imag * imag2,
+        real * imag2 + imag * real2
+    )
 
 
 @cython.ufunc
 cdef (float_t, float_t) _phasor_divide(
-    float_t real1,
-    float_t imag1,
+    float_t real,
+    float_t imag,
     float_t real2,
     float_t imag2,
 ) noexcept nogil:
-    """Return division of two phasors."""
+    """Return complex division of two phasors."""
     cdef:
-        float_t denom = real2 * real2 + imag2 * imag2
+        float_t divisor = real2 * real2 + imag2 * imag2
 
-    if isnan(denom) or denom == 0.0:
-        return <float_t> NAN, <float_t> NAN
+    if divisor != 0.0:
+        # includes isnan(divisor)
+        return (
+            (real * real2 + imag * imag2) / divisor,
+            (imag * real2 - real * imag2) / divisor
+        )
 
+    real = real * real2 + imag * imag2
+    imag = imag * real2 - real * imag2
     return (
-        (real1 * real2 + imag1 * imag2) / denom,
-        (imag1 * real2 - real1 * imag2) / denom
+        NAN if real == 0.0 else real * INFINITY,
+        NAN if imag == 0.0 else imag * INFINITY
     )
 
 
@@ -2141,3 +2165,66 @@ def _median_filter_2d(
                     image[i, j] = filtered_image[i, j]
 
         free(kernel)
+
+
+###############################################################################
+# Decoder functions
+
+
+def _flimlabs_signal(
+    uint_t[:, :, ::] signal,   # channel, pixel, bin
+    list data,  # list[list[list[[int, int]]]]
+    ssize_t channel = -1  # -1 == None
+):
+    """Return TCSPC histogram image from FLIM LABS JSON intensity data."""
+    cdef:
+        list channels, pixels
+        ssize_t c, i, h, count
+
+    if channel < 0:
+        c = 0
+        for channels in data:
+            i = 0
+            for pixels in channels:
+                for h, count in pixels:
+                    signal[c, i, h] = <uint_t> count
+                i += 1
+            c += 1
+    else:
+        i = 0
+        for pixels in data[channel]:
+            for h, count in pixels:
+                signal[0, i, h] = <uint_t> count
+            i += 1
+
+
+def _flimlabs_mean(
+    float_t[:, ::] mean,   # channel, pixel
+    list data,  # list[list[list[[int, int]]]]
+    ssize_t channel = -1  # -1 == None
+):
+    """Return mean intensity image from FLIM LABS JSON intensity data."""
+    cdef:
+        list channels, pixels
+        ssize_t c, i, h, count
+        double sum
+
+    if channel < 0:
+        c = 0
+        for channels in data:
+            i = 0
+            for pixels in channels:
+                sum = 0.0
+                for h, count in pixels:
+                    sum += <double> count
+                mean[c, i] = <float_t> (sum / 255.0)
+                i += 1
+            c += 1
+    else:
+        i = 0
+        for pixels in data[channel]:
+            sum = 0.0
+            for h, count in pixels:
+                sum += <double> count
+            mean[0, i] = <float_t> (sum / 255.0)
+            i += 1

phasorpy/_utils.py

@@ -1,6 +1,4 @@
-"""Private auxiliary and convenience functions.
-
-"""
+"""Private auxiliary and convenience functions."""
 
 from __future__ import annotations
 
@@ -10,6 +8,7 @@ __all__: list[str] = [
     'kwargs_notnone',
     'parse_harmonic',
     'parse_kwargs',
+    'parse_signal_axis',
     'phasor_from_polar_scalar',
     'phasor_to_polar_scalar',
     'scale_matrix',
@@ -247,6 +246,72 @@ def phasor_from_polar_scalar(
     return real, imag
 
 
+def parse_signal_axis(
+    signal: ArrayLike,
+    /,
+    axis: int | str | None = None,
+) -> tuple[int, str]:
+    """Return axis over which phasor coordinates are computed.
+
+    The axis parameter is not validated against the signal shape.
+
+    Parameters
+    ----------
+    signal : array_like
+        Image stack.
+    axis : int or str, optional
+        Axis over which phasor coordinates are computed.
+        By default, the 'H' or 'C' axes if `signal` contains such
+        dimension names, else the last axis (-1).
+
+    Returns
+    -------
+    axis : int
+        Axis over which phasor coordinates are computed.
+    axis_label: str
+        Axis label from `signal.dims` if any.
+
+    Raises
+    ------
+    ValueError
+        Axis not found in signal.dims or invalid for signal type.
+
+    Examples
+    --------
+    >>> parse_signal_axis([])
+    (-1, '')
+    >>> parse_signal_axis([], 1)
+    (1, '')
+    >>> class DataArray:
+    ...     dims = ('C', 'H', 'Y', 'X')
+    ...
+    >>> parse_signal_axis(DataArray())
+    (1, 'H')
+    >>> parse_signal_axis(DataArray(), 'C')
+    (0, 'C')
+    >>> parse_signal_axis(DataArray(), 1)
+    (1, 'H')
+
+    """
+    if hasattr(signal, 'dims'):
+        assert isinstance(signal.dims, tuple)
+        if axis is None:
+            for ax in 'HC':
+                if ax in signal.dims:
+                    return signal.dims.index(ax), ax
+            return -1, signal.dims[-1]
+        if isinstance(axis, int):
+            return axis, signal.dims[axis]
+        if axis in signal.dims:
+            return signal.dims.index(axis), axis
+        raise ValueError(f'{axis=} not found in {signal.dims}')
+    if axis is None:
+        return -1, ''
+    if isinstance(axis, int):
+        return axis, ''
+    raise ValueError(f'{axis=} not valid for {type(signal)=}')
+
+
 def parse_harmonic(
     harmonic: int | Sequence[int] | Literal['all'] | str | None,
     harmonic_max: int | None = None,
@@ -259,7 +324,7 @@ def parse_harmonic(
 
     Parameters
     ----------
-    harmonic : int, list of int, 'all', or None
+    harmonic : int, sequence of int, 'all', or None
         Harmonic parameter to parse.
     harmonic_max : int, optional
         Maximum value allowed in `hamonic`. Must be one or greater.
@@ -329,7 +394,7 @@ def chunk_iter(
     shape: tuple[int, ...],
     chunk_shape: tuple[int, ...],
     /,
-    axes: str | Sequence[str] | None = None,
+    dims: Sequence[str] | None = None,
     *,
     pattern: str | None = None,
     squeeze: bool = False,
@@ -343,11 +408,11 @@ def chunk_iter(
         Shape of C-order ndarray to chunk.
     chunk_shape : tuple of int
         Shape of chunks in the most significant dimensions.
-    axes : str or sequence of str, optional
+    dims : sequence of str, optional
         Labels for each axis in shape if `pattern` is None.
     pattern : str, optional
         String to format chunk indices.
-        If None, use ``_[{axes[index]}{chunk_index[index]}]`` for each axis.
+        If None, use ``_[{dims[index]}{chunk_index[index]}]`` for each axis.
     squeeze : bool
         If true, do not include length-1 chunked dimensions in label
         unless dimensions are part of `chunk_shape`.
@@ -384,11 +449,11 @@ def chunk_iter(
     ndim = len(shape)
 
     sep = '_'
-    if axes is None:
-        axes = sep * ndim
+    if dims is None:
+        dims = sep * ndim
         sep = ''
-    elif ndim != len(axes):
-        raise ValueError(f'{len(shape)=} != {len(axes)=}')
+    elif ndim != len(dims):
+        raise ValueError(f'{len(shape)=} != {len(dims)=}')
 
     if pattern is not None:
         try:
@@ -406,7 +471,7 @@ def chunk_iter(
 
     chunked_shape = []
     pattern_list = []
-    for i, (size, chunk_size, ax) in enumerate(zip(shape, chunk_shape, axes)):
+    for i, (size, chunk_size, ax) in enumerate(zip(shape, chunk_shape, dims)):
         if size <= 0:
             raise ValueError('shape must contain positive sizes')
         if chunk_size <= 0:

phasorpy/color.py

@@ -59,8 +59,7 @@ def wavelength2rgb(
         else:
             rgb = rgb.astype(dtype)
     if astuple:
-        rgb_list = rgb.tolist()
-        return (rgb_list[0], rgb_list[1], rgb_list[2])
+        return tuple(rgb.tolist()[:3])
     return rgb
 
 

phasorpy/datasets.py

@@ -305,6 +305,85 @@ CONVALLARIA_FBD = pooch.create(
     },
 )
 
+FLIMLABS = pooch.create(
+    path=pooch.os_cache('phasorpy'),
+    base_url='https://github.com/phasorpy/phasorpy-data/raw/main/flimlabs',
+    env=ENV,
+    registry={
+        'calibrator_2_5_1737112045_imaging.json': (
+            'sha256:'
+            'a34c7077e88d1e7272953a46b2bb4e3ab8adf5a2f61c824dfc27032d952b920e'
+        ),
+        'calibrator_2_5_1737112045_imaging.json.zip': (
+            'sha256:'
+            'fea791b28afd8365152018810cbbaaac1177cb72827578073587a1050d1af329'
+        ),
+        'calibrator_2_5_1737112045_imaging_calibration.json': (
+            'sha256:'
+            '8f2ebe9b544fae9524dc13221c1a5ab1b57d9dfd40ec2eb06a7b1475fcd63057'
+        ),
+        'calibrator_2_5_bis_1737112494_imaging.json': (
+            'sha256:'
+            '0509c5aba066419b03f83264eba58acbf4aae470aa1057c52f45e60225e033a4'
+        ),
+        'calibrator_2_5_bis_1737112494_imaging.json.zip': (
+            'sha256:'
+            'bdc5df2a3f08a64ec7b7bb57b36e21546de142e67c59c052318252dbb66d8abf'
+        ),
+        'calibrator_2_5_bis_1737112494_imaging_calibration.json': (
+            'sha256:'
+            '9bb0e21b1e7c04add672aa8a78048b09908c860fcaf907ca33c0c87d161f6ebf'
+        ),
+        'convallaria_1_1737112980_phasor_ch1.json': (
+            'sha256:'
+            '4a296a0d7898dc660a388e1bba5cf98b43c35fe12d94b7aba48d00245e37242d'
+        ),
+        'convallaria_1_1737112980_phasor_ch1.json.zip': (
+            'sha256:'
+            '79c416b9099c9f58d2092fe5b26ea6d0f695977b877784cf564d3ead896d9354'
+        ),
+        'convallaria_2_1737113097_phasor_ch1.json': (
+            'sha256:'
+            'da549645ffd898238c26f7a1eac3aca4ffccec86653c0d241a6ece674dfce90d'
+        ),
+        'convallaria_2_1737113097_phasor_ch1.json.zip': (
+            'sha256:'
+            '8801bb14b457dceaef42e8b3bf6af770a2e14264cd2b282ba7e3d70b91ea954c'
+        ),
+        'data_2_calibrator_2_5_1737112409_phasor_ch1.json': (
+            'sha256:'
+            'ea8683892eb76f52231e5d6ceab64a3737454aa95fe73185366de8f758fd9b70'
+        ),
+        'data_2_calibrator_2_5_1737112409_phasor_ch1.json.zip': (
+            'sha256:'
+            '40d2aa90b95fd8864a2392337c83a1a4f4931d7359cb30a486f65173f208de0a'
+        ),
+        'data_calibrator_2_5_1737112133_phasor_ch1.json': (
+            'sha256:'
+            '6a8790212bc62014d597402ec5feb0e50ec6ae2aa62d63fae8cb62c6c5656268'
+        ),
+        'data_calibrator_2_5_1737112133_phasor_ch1.json.zip': (
+            'sha256:'
+            'c9ef343bdbd7a51d23fdf4082e379dcdb1ce9f3e2ba065289bf2925d68ef55ba'
+        ),
+    },
+)
+
+FIGSHARE_22336594 = pooch.create(
+    path=pooch.os_cache('phasorpy'),
+    base_url=(
+        'https://github.com/phasorpy/phasorpy-data/raw/main/figshare_22336594'
+        if DATA_ON_GITHUB
+        else 'doi:10.6084/m9.figshare.22336594.v1'
+    ),
+    env=ENV,
+    registry={
+        'FLIM_testdata.lif': (
+            'sha256:'
+            '902d8fa6cd39da7cf062b32d43aab518fa2a851eab72b4bd8b8eca1bad591850'
+        ),
+    },
+)
 
 REPOSITORIES: dict[str, pooch.Pooch] = {
     'tests': TESTS,
@@ -313,6 +392,8 @@ REPOSITORIES: dict[str, pooch.Pooch] = {
     'napari-flim-phasor-plotter': NAPARI_FLIM_PHASOR_PLOTTER,
     'zenodo-13625087': ZENODO_13625087,
     'convallaria-fbd': CONVALLARIA_FBD,
+    'flimlabs': FLIMLABS,
+    'figshare_22336594': FIGSHARE_22336594,
 }
 """Pooch repositories."""