dclab 0.67.0__cp39-cp39-macosx_11_0_arm64.whl → 0.67.3__cp39-cp39-macosx_11_0_arm64.whl

dclab/features/emodulus/scale_linear.py

@@ -1,47 +1,60 @@
 """Scale conversion applicable to a linear elastic model"""
+from __future__ import annotations
 
 import warnings
 
 import numpy as np
-
-
-def convert(area_um, deform, channel_width_in, channel_width_out,
-            emodulus=None, flow_rate_in=None, flow_rate_out=None,
-            viscosity_in=None, viscosity_out=None, inplace=False):
-    """convert area-deformation-emodulus triplet
+import numpy.typing as npt
+
+
+def convert(area_um: npt.NDArray,
+            deform: npt.NDArray,
+            channel_width_in: float,
+            channel_width_out: float,
+            emodulus: npt.NDArray = None,
+            flow_rate_in: float = None,
+            flow_rate_out: float = None,
+            viscosity_in: float = None,
+            viscosity_out: float | npt.NDArray = None,
+            inplace: bool = False
+            ) -> (
+        tuple[npt.NDArray, npt.NDArray] |
+        tuple[npt.NDArray, npt.NDArray, npt.NDArray]
+):
+    """Convert area-deformation-emodulus triplet
 
     The conversion formula is described in :cite:`Mietke2015`.
 
     Parameters
     ----------
-    area_um: ndarray
+    area_um
         Convex cell area [µm²]
-    deform: ndarray
+    deform
         Deformation
-    channel_width_in: float
+    channel_width_in
         Original channel width [µm]
-    channel_width_out: float
+    channel_width_out
         Target channel width [µm]
-    emodulus: ndarray
+    emodulus
         Young's Modulus [kPa]
-    flow_rate_in: float
+    flow_rate_in
         Original flow rate [µL/s]
-    flow_rate_out: float
+    flow_rate_out
         Target flow rate [µL/s]
-    viscosity_in: float
+    viscosity_in
         Original viscosity [mPa*s]
-    viscosity_out: float or ndarray
+    viscosity_out
         Target viscosity [mPa*s]; This can be an array
-    inplace: bool
+    inplace
         If True, override input arrays with corrected data
 
     Returns
     -------
-    area_um_corr: ndarray
+    area_um_corr
         Corrected cell area [µm²]
-    deform_corr: ndarray
+    deform_corr
         Deformation (a copy if `inplace` is False)
-    emodulus_corr: ndarray
+    emodulus_corr
         Corrected emodulus [kPa]; only returned if `emodulus` is given.
 
     Notes
@@ -81,8 +94,11 @@ def convert(area_um, deform, channel_width_in, channel_width_out,
         return area_um_corr, deform_corr, emodulus_corr
 
 
-def scale_area_um(area_um, channel_width_in, channel_width_out, inplace=False,
-                  **kwargs):
+def scale_area_um(area_um: npt.NDArray,
+                  channel_width_in: float,
+                  channel_width_out: float,
+                  inplace: bool = False,
+                  **kwargs) -> npt.NDArray:
     """Perform scale conversion for area_um (linear elastic model)
 
     The area scales with the characteristic length
@@ -94,20 +110,20 @@ def scale_area_um(area_um, channel_width_in, channel_width_out, inplace=False,
 
     Parameters
     ----------
-    area_um: ndarray
+    area_um
         Convex area [µm²]
-    channel_width_in: float
+    channel_width_in
         Original channel width [µm]
-    channel_width_out: float
+    channel_width_out
         Target channel width [µm]
-    inplace: bool
+    inplace
         If True, override input arrays with corrected data
-    kwargs:
+    kwargs
         not used
 
     Returns
     -------
-    area_um_corr: ndarray
+    area_um_corr
         Scaled area [µm²]
     """
     copy = not inplace
@@ -120,9 +136,14 @@ def scale_area_um(area_um, channel_width_in, channel_width_out, inplace=False,
     return area_um_corr
 
 
-def scale_emodulus(emodulus, channel_width_in, channel_width_out,
-                   flow_rate_in, flow_rate_out, viscosity_in,
-                   viscosity_out, inplace=False):
+def scale_emodulus(emodulus: npt.NDArray,
+                   channel_width_in: float,
+                   channel_width_out: float,
+                   flow_rate_in: float,
+                   flow_rate_out: float,
+                   viscosity_in: float,
+                   viscosity_out: float | npt.NDArray,
+                   inplace: bool = False) -> npt.NDArray:
     """Perform scale conversion for area_um (linear elastic model)
 
     The conversion formula is described in :cite:`Mietke2015`.
@@ -131,26 +152,26 @@ def scale_emodulus(emodulus, channel_width_in, channel_width_out,
 
     Parameters
     ----------
-    emodulus: ndarray
+    emodulus
         Young's Modulus [kPa]
-    channel_width_in: float
+    channel_width_in
         Original channel width [µm]
-    channel_width_out: float
+    channel_width_out
         Target channel width [µm]
-    flow_rate_in: float
+    flow_rate_in
         Original flow rate [µL/s]
-    flow_rate_out: float
+    flow_rate_out
         Target flow rate [µL/s]
-    viscosity_in: float
+    viscosity_in
         Original viscosity [mPa*s]
-    viscosity_out: float or ndarray
+    viscosity_out
         Target viscosity [mPa*s]; This can be an array
-    inplace: bool
+    inplace
         If True, override input arrays with corrected data
 
     Returns
     -------
-    emodulus_corr: ndarray
+    emodulus_corr
         Scaled emodulus [kPa]
     """
     copy = not inplace
@@ -182,7 +203,10 @@ def scale_emodulus(emodulus, channel_width_in, channel_width_out,
     return emodulus_corr
 
 
-def scale_feature(feat, data, inplace=False, **scale_kw):
+def scale_feature(feat: str,
+                  data: float | npt.NDArray,
+                  inplace: bool = False,
+                  **scale_kw) -> npt.NDArray:
     """Convenience function for scale conversions (linear elastic model)
 
     This method wraps around all the other scale_* methods and also
@@ -190,13 +214,13 @@ def scale_feature(feat, data, inplace=False, **scale_kw):
 
     Parameters
     ----------
-    feat: str
+    feat
         Valid scalar feature name
-    data: float or ndarray
+    data
         Feature data
-    inplace: bool
+    inplace
         If True, override input arrays with corrected data
-    **scale_kw:
+    **scale_kw
         Scale keyword arguments for the wrapped methods
     """
     if feat == "area_um":
@@ -212,8 +236,11 @@ def scale_feature(feat, data, inplace=False, **scale_kw):
         raise KeyError("No recipe to scale feature '{}'!".format(feat))
 
 
-def scale_volume(volume, channel_width_in, channel_width_out, inplace=False,
-                 **kwargs):
+def scale_volume(volume: npt.NDArray,
+                 channel_width_in: float,
+                 channel_width_out: float,
+                 inplace: bool = False,
+                 **kwargs) -> npt.NDArray:
     """Perform scale conversion for volume (linear elastic model)
 
     The volume scales with the characteristic length
@@ -223,20 +250,20 @@ def scale_volume(volume, channel_width_in, channel_width_out, inplace=False,
 
     Parameters
     ----------
-    volume: ndarray
+    volume
         Volume [µm³]
-    channel_width_in: float
+    channel_width_in
         Original channel width [µm]
-    channel_width_out: float
+    channel_width_out
         Target channel width [µm]
-    inplace: bool
+    inplace
         If True, override input arrays with corrected data
-    kwargs:
+    kwargs
         not used
 
     Returns
     -------
-    volume_corr: ndarray
+    volume_corr
         Scaled volume [µm³]
     """
     copy = not inplace

dclab/features/emodulus/viscosity.py

@@ -5,6 +5,7 @@ from typing import Literal
 import warnings
 
 import numpy as np
+import numpy.typing as npt
 
 from ...warn import PipelineWarning
 
@@ -45,10 +46,17 @@ class TemperatureOutOfRangeWarning(PipelineWarning):
 
 
 def check_temperature(model: str,
-                      temperature: float | np.array,
+                      temperature: float | npt.NDArray,
                       tmin: float,
-                      tmax: float):
-    """Raise a TemperatureOutOfRangeWarning if applicable"""
+                      tmax: float) -> None:
+    """Raise a TemperatureOutOfRangeWarning if applicable
+
+    Raises
+    ------
+    TemperatureOutOfRangeWarning
+        If the given temperature is out of the given range.
+
+    """
     if np.min(temperature) < tmin or np.max(temperature) > tmax:
         warnings.warn(
             f"For the {model} model, the temperature should be "
@@ -60,11 +68,12 @@ def check_temperature(model: str,
 def get_viscosity(medium: str = "0.49% MC-PBS",
                   channel_width: float = 20.0,
                   flow_rate: float = 0.16,
-                  temperature: float | np.ndarray = 23.0,
+                  temperature: float | npt.NDArray = 23.0,
                   model: Literal['herold-2017',
                                  'herold-2017-fallback',
                                  'buyukurganci-2022',
-                                 'kestin-1978'] = 'herold-2017-fallback'):
+                                 'kestin-1978'] = 'herold-2017-fallback'
+                  ) -> float | npt.NDArray:
     """Returns the viscosity for RT-DC-specific media
 
     Media that are not pure (e.g. ketchup or polymer solutions)
@@ -83,16 +92,16 @@ def get_viscosity(medium: str = "0.49% MC-PBS",
 
     Parameters
     ----------
-    medium: str
+    medium
         The medium to compute the viscosity for; Valid values
         are defined in :const:`KNOWN_MEDIA`.
-    channel_width: float
+    channel_width
         The channel width in µm
-    flow_rate: float
+    flow_rate
         Flow rate in µL/s
-    temperature: float or ndarray
+    temperature
         Temperature in °C
-    model: str
+    model
         The model name to use for computing the medium viscosity.
         For water, this value is ignored, as there is only the
         'kestin-1978' model :cite:`Kestin_1978`. For MC-PBS media,
@@ -101,7 +110,7 @@ def get_viscosity(medium: str = "0.49% MC-PBS",
 
     Returns
     -------
-    viscosity: float or ndarray
+    viscosity
         Viscosity in mPa*s
 
     Notes
@@ -152,21 +161,23 @@ def get_viscosity(medium: str = "0.49% MC-PBS",
     return eta
 
 
-def shear_rate_square_channel(flow_rate, channel_width, flow_index):
+def shear_rate_square_channel(flow_rate: float,
+                              channel_width: float,
+                              flow_index: float) -> float:
     """Returns The wall shear rate of a power law liquid in a squared channel.
 
     Parameters
     ----------
-    flow_rate: float
+    flow_rate
         Flow rate in µL/s
-    channel_width: float
+    channel_width
         The channel width in µm
-    flow_index: float
+    flow_index
         Flow behavior index aka the power law exponent of the shear thinning
 
     Returns
     -------
-    shear_rate: float
+    shear_rate
         Shear rate in 1/s.
     """
     # convert channel width to mm
@@ -180,7 +191,7 @@ def get_viscosity_mc_pbs_buyukurganci_2022(
                         "0.83% MC-PBS"] = "0.49% MC-PBS",
         channel_width: float = 20.0,
         flow_rate: float = 0.16,
-        temperature: float = 23.0):
+        temperature: float = 23.0) -> float | npt.NDArray:
     """Compute viscosity of MC-PBS according to :cite:`Buyukurganci2022`
 
     This viscosity model was derived in :cite:`Buyukurganci2022`
@@ -215,7 +226,7 @@ def get_viscosity_mc_pbs_herold_2017(
         medium: Literal["0.49% MC-PBS", "0.59% MC-PBS"] = "0.49% MC-PBS",
         channel_width: float = 20.0,
         flow_rate: float = 0.16,
-        temperature: float = 23.0):
+        temperature: float = 23.0) -> float | npt.NDArray:
     r"""Compute viscosity of MC-PBS according to :cite:`Herold2017`
 
     Note that all the factors in equation 5.2 in :cite:`Herold2017`
@@ -246,7 +257,8 @@ def get_viscosity_mc_pbs_herold_2017(
     return eta
 
 
-def get_viscosity_water_kestin_1978(temperature: float = 23.0):
+def get_viscosity_water_kestin_1978(
+        temperature: float | npt.NDArray = 23.0) -> float | npt.NDArray:
     """Compute the viscosity of water according to :cite:`Kestin_1978`"""
     # see equation (15) in Kestin et al, J. Phys. Chem. 7(3) 1978
     check_temperature("'kestin-1978' water", temperature, 0, 40)

dclab/features/fl_crosstalk.py

@@ -1,9 +1,13 @@
 """Crosstalk-correction for fluorescence data"""
+from __future__ import annotations
 
 import numpy as np
+import numpy.typing as npt
 
 
-def get_compensation_matrix(ct21, ct31, ct12, ct32, ct13, ct23):
+def get_compensation_matrix(
+        ct21: float, ct31: float, ct12: float,
+        ct32: float, ct13: float, ct23: float) -> npt.NDArray:
     """Compute crosstalk inversion matrix
 
     The spillover matrix is
@@ -18,12 +22,12 @@ def get_compensation_matrix(ct21, ct31, ct12, ct32, ct13, ct23):
 
     Parameters
     ----------
-    cij: float
+    cij
         Spill from channel i to channel j
 
     Returns
     -------
-    inv: np.ndarray
+    inv
         Compensation matrix (inverted spillover matrix)
     """
     ct11 = 1
@@ -55,18 +59,23 @@ def get_compensation_matrix(ct21, ct31, ct12, ct32, ct13, ct23):
     return np.linalg.inv(crosstalk)
 
 
-def correct_crosstalk(fl1, fl2, fl3, fl_channel,
-                      ct21=0, ct31=0, ct12=0, ct32=0, ct13=0, ct23=0):
+def correct_crosstalk(
+        fl1: int | float | npt.NDArray,
+        fl2: int | float | npt.NDArray,
+        fl3: int | float | npt.NDArray,
+        fl_channel: int,
+        ct21: float = 0, ct31: float = 0, ct12: float = 0,
+        ct32: float = 0, ct13: float = 0, ct23: float = 0) -> npt.NDArray:
     """Perform crosstalk correction
 
     Parameters
     ----------
-    fli: int, float, or np.ndarray
+    fli
         Measured fluorescence signals
-    fl_channel: int (1, 2, or 3)
-        The channel number for which the crosstalk-corrected signal
-        should be computed
-    cij: float
+    fl_channel
+        The channel number (1, 2, or 3) for which the crosstalk-corrected
+        signal should be computed
+    cij
         Spill (crosstalk or bleed-through) from channel i to channel j
         This spill is computed from the fluorescence signal of e.g.
         single-stained positive control cells; It is defined by the

dclab/features/inert_ratio.py

@@ -1,11 +1,14 @@
 """Computation of inertia ratio from contour data"""
+from __future__ import annotations
+
 import numpy as np
+import numpy.typing as npt
 import scipy.spatial as ssp
 
 
-def cont_moments_cv(cont,
-                    flt_epsilon=1.19209e-07,
-                    dbl_epsilon=2.2204460492503131e-16):
+def cont_moments_cv(cont: npt.NDArray,
+                    flt_epsilon: float = 1.19209e-07,
+                    dbl_epsilon: float = 2.2204460492503131e-16) -> dict:
     """Compute the moments of a contour
 
     The moments are computed in the same way as they are computed
@@ -13,11 +16,11 @@ def cont_moments_cv(cont,
 
     Parameters
     ----------
-    cont: array of shape (N,2)
+    cont: ndarray of shape (N,2)
         The contour for which to compute the moments.
-    flt_epsilon: float
+    flt_epsilon
         The value of ``FLT_EPSILON`` in OpenCV/gcc.
-    dbl_epsilon: float
+    dbl_epsilon
         The value of ``DBL_EPSILON`` in OpenCV/gcc.
 
     .. versionchanged:: 0.48.2
@@ -28,7 +31,7 @@ def cont_moments_cv(cont,
 
     Returns
     -------
-    moments: dict
+    moments
         A dictionary of moments. If the moment `m00` is smaller
         than half of `flt_epsilon`, `None` is returned.
     """
@@ -120,7 +123,8 @@ def cont_moments_cv(cont,
         return None
 
 
-def get_inert_ratio_cvx(cont):
+def get_inert_ratio_cvx(
+        cont: npt.NDArray | list[npt.NDArray]) -> float | npt.NDArray:
     """Compute the inertia ratio of the convex hull of a contour
 
     The inertia ratio is computed from the central second order of moments
@@ -190,7 +194,8 @@ def get_inert_ratio_cvx(cont):
     return inert_ratio_cvx
 
 
-def get_inert_ratio_prnc(cont):
+def get_inert_ratio_prnc(
+        cont: npt.NDArray | list[npt.NDArray]) -> float | npt.NDArray:
     """Compute principal inertia ratio of a contour
 
     The principal inertia ratio is rotation-invariant, which
@@ -256,7 +261,8 @@ def get_inert_ratio_prnc(cont):
     return inert_ratio_prnc
 
 
-def get_inert_ratio_raw(cont):
+def get_inert_ratio_raw(
+        cont: npt.NDArray | list[npt.NDArray]) -> float | npt.NDArray:
     """Compute the inertia ratio of a contour
 
     The inertia ratio is computed from the central second order of moments
@@ -321,7 +327,8 @@ def get_inert_ratio_raw(cont):
     return inert_ratio_raw
 
 
-def get_tilt(cont):
+def get_tilt(
+        cont: npt.NDArray | list[npt.NDArray]) -> float | npt.NDArray:
     """Compute tilt of raw contour relative to channel axis
 
     Parameters

dclab/features/volume.py

@@ -1,8 +1,16 @@
 """Volume computation based on contour revolution"""
+from __future__ import annotations
+
 import numpy as np
+import numpy.typing as npt
 
 
-def get_volume(cont, pos_x, pos_y, pix, fix_orientation=False):
+def get_volume(
+        cont: npt.NDArray | list[npt.NDArray],
+        pos_x: float | npt.NDArray,
+        pos_y: float | npt.NDArray,
+        pix: float,
+        fix_orientation: bool = False) -> float | npt.NDArray:
     """Calculate the volume of a polygon revolved around an axis
 
     The volume estimation assumes rotational symmetry.
@@ -20,10 +28,10 @@ def get_volume(cont, pos_x, pos_y, pix, fix_orientation=False):
     pos_y: float or ndarray of length N
         The y coordinate(s) of the centroid of the event(s) [µm]
         e.g. obtained using `mm.pos_y`
-    pix: float
+    pix
         The detector pixel size in µm.
         e.g. obtained using: `mm.config["imaging"]["pixel size"]`
-    fix_orientation: bool
+    fix_orientation
         If set to True, make sure that the orientation of the
         contour is counter-clockwise in the r-z plane
         (see :func:`vol_revolve`). This is False by default, because
@@ -34,7 +42,7 @@ def get_volume(cont, pos_x, pos_y, pix, fix_orientation=False):
 
     Returns
     -------
-    volume: float or ndarray
+    volume
         volume in um^3
 
     Notes
@@ -43,7 +51,7 @@ def get_volume(cont, pos_x, pos_y, pix, fix_orientation=False):
     upper and the lower halves of the contour from which the
     average is then used.
 
-    The volume is computed radially from the the center position
+    The volume is computed radially from the center position
     given by (`pos_x`, `pos_y`). For sufficiently smooth contours,
     such as densely sampled ellipses, the center position does not
     play an important role. For contours that are given on a coarse
@@ -125,7 +133,7 @@ def get_volume(cont, pos_x, pos_y, pix, fix_orientation=False):
     return v_avg
 
 
-def counter_clockwise(cx, cy):
+def counter_clockwise(cx: npt.NDArray, cy: npt.NDArray) -> tuple[float, float]:
     """Put contour coordinates into counter-clockwise order
 
     Parameters
@@ -135,7 +143,7 @@ def counter_clockwise(cx, cy):
 
     Returns
     -------
-    cx_cc, cy_cc:
+    cx_cc, cy_cc
         The x- and y-coordinates of the contour in
         counter-clockwise orientation.
 
@@ -152,7 +160,9 @@ def counter_clockwise(cx, cy):
         return cx, cy
 
 
-def vol_revolve(r, z, point_scale=1.):
+def vol_revolve(r: npt.NDArray,
+                z: npt.NDArray,
+                point_scale: float = 1.) -> float | npt.NDArray:
     r"""Calculate the volume of a polygon revolved around the Z-axis
 
     This implementation yields the same results as the volRevolve
@@ -183,11 +193,11 @@ def vol_revolve(r, z, point_scale=1.):
 
     Parameters
     ----------
-    r: 1d np.ndarray
+    r: 1d ndarray
         radial coordinates (perpendicular to the z axis)
-    z: 1d np.ndarray
+    z: 1d ndarray
         coordinate along the axis of rotation
-    point_scale: float
+    point_scale
         point size in your preferred units; The volume is multiplied
         by a factor of `point_scale**3`.
 
@@ -222,9 +232,9 @@ def vol_revolve(r, z, point_scale=1.):
     # dr = R - r and dz = h, then we get three terms for the volume
     # (as opposed to four terms in Olynyk's script). Those three terms
     # all resemble area slices multiplied by the z-distance dz.
-    a1 = 3 * rp**2
-    a2 = 3 * rp*dr
-    a3 = dr**2
+    a1 = 3 * rp ** 2
+    a2 = 3 * rp * dr
+    a3 = dr ** 2
 
     # Note that the formula for computing the volume is symmetric
     # with respect to r and R. This means that it does not matter

dclab/kde/base.py

@@ -288,21 +288,24 @@ class KernelDensityEstimator:
         xc = xs[~bad]
         yc = ys[~bad]
 
-        xnum = int(np.ceil((xc.max() - xc.min()) / xacc))
-        ynum = int(np.ceil((yc.max() - yc.min()) / yacc))
+        if xc.size:
+            # Compute the mesh for rastering
+            xnum = int(np.ceil((xc.max() - xc.min()) / xacc))
+            ynum = int(np.ceil((yc.max() - yc.min()) / yacc))
 
-        xlin = np.linspace(xc.min(), xc.max(), xnum, endpoint=True)
-        ylin = np.linspace(yc.min(), yc.max(), ynum, endpoint=True)
+            xlin = np.linspace(xc.min(), xc.max(), xnum, endpoint=True)
+            ylin = np.linspace(yc.min(), yc.max(), ynum, endpoint=True)
 
-        xmesh, ymesh = np.meshgrid(xlin, ylin, indexing="ij")
+            xmesh, ymesh = np.meshgrid(xlin, ylin, indexing="ij")
 
-        kde_fct = methods[kde_type]
-        if len(x):
+            # Compute the KDE for each point on the mesh
+            kde_fct = methods[kde_type]
             density = kde_fct(events_x=xs, events_y=ys,
                               xout=xmesh, yout=ymesh,
                               **kde_kwargs)
         else:
-            density = np.array([])
+            xmesh, ymesh = np.meshgrid([0, 1], [0, 1], indexing="ij")
+            density = np.array(np.nan * xmesh)
 
         # Convert mesh back to linear scale if applicable
         if xscale == "log":