cellects 0.1.3__py3-none-any.whl → 0.2.7__py3-none-any.whl

cellects/utils/formulas.py

@@ -28,6 +28,7 @@ Notes:
 - Image processing functions expect binary (boolean/int8) input matrices
 """
 from copy import deepcopy
+import pandas as pd
 from cellects.utils.decorators import njit
 import numpy as np
 from numpy.typing import NDArray
@@ -115,10 +116,22 @@ def bracket_to_uint8_image_contrast(image: NDArray):
     -------
     ndarray of uint8
         Output image converted to uint8 type after normalization.
-    """
-    image -= np.min(image)
-    return to_uint8(255 * (image / np.max(image)))
 
+    Examples
+    --------
+    >>> image = np.random.randint(0, 255, (10, 10), dtype=np.uint8)
+    >>> res = bracket_to_uint8_image_contrast(image)
+    >>> print(res)
+
+    >>> image = np.zeros((10, 10), dtype=np.uint8)
+    >>> res = bracket_to_uint8_image_contrast(image)
+    >>> print(res)
+    """
+    image -= image.min()
+    if image.max() == 0:
+        return np.zeros_like(image, dtype=np.uint8)
+    else:
+        return to_uint8(255 * (image / np.max(image)))
 
 @njit()
 def linear_model(x: NDArray, a: float, b: float) -> float:
@@ -229,8 +242,11 @@ def get_var(mo: dict, binary_image: NDArray, Xn: NDArray, Yn: NDArray) -> Tuple[
     -----
     Performance considerations: This function uses Numba's `@njit` decorator for performance.
     """
-    vx = np.sum(binary_image * Xn) / mo["m00"]
-    vy = np.sum(binary_image * Yn) / mo["m00"]
+    if mo['m00'] == 0:
+        vx, vy = 0., 0.
+    else:
+        vx = np.sum(binary_image * Xn) / mo["m00"]
+        vy = np.sum(binary_image * Yn) / mo["m00"]
     return vx, vy
 
 
@@ -277,7 +293,17 @@ def get_skewness_kurtosis(mnx: float, mny: float, sx: float, sy: float, n: int)
     Kurtosis: nan
 
     """
-    return mnx / sx ** n, mny / sy ** n
+    if sx == 0:
+        fx = 0
+    else:
+        fx = mnx / sx ** n
+
+    if sy == 0:
+        fy = 0
+    else:
+        fy = mny / sy ** n
+
+    return fx, fy
 
 
 def get_standard_deviations(mo: dict, binary_image: NDArray, cx: float, cy: float) -> Tuple[float, float]:
@@ -635,3 +661,140 @@ def find_duplicates_coord(array1: NDArray[int]) -> NDArray[bool]:
     counts = np.bincount(inverse_indices)
     # A row is duplicate if its count > 1
     return counts[inverse_indices] > 1
+
+def detect_first_move(size_dynamics: NDArray, growth_threshold)-> int:
+    """
+    Detects the first move in a time series where the value exceeds the initial value by a given threshold.
+
+    Parameters
+    ----------
+    size_dynamics : numpy.ndarray
+        The time series data of dynamics.
+    growth_threshold: int or float
+        The threshold value for detecting the first move.
+
+    Returns
+    -------
+    int or pandas.NA
+        The index of the first move where the condition is met.
+        Returns `pandas.NA` if no such index exists.
+
+    Examples
+    --------
+    >>> size_dynamics = np.array([10, 12, 15, 18])
+    >>> growth_threshold = 5
+    >>> detect_first_move(size_dynamics, growth_threshold)
+    2
+    """
+    first_move = pd.NA
+    thresh_reached = np.nonzero(size_dynamics >= (size_dynamics[0] + growth_threshold))[0]
+    if len(thresh_reached) > 0:
+        first_move = thresh_reached[0]
+    return first_move
+
+@njit()
+def get_newly_explored_area(binary_vid: NDArray[np.uint8]) -> NDArray:
+    """
+    Get newly explored area in a binary video.
+
+    Calculate the number of new pixels that have become active (==1) from
+    the previous frame in a binary video representation.
+
+    Parameters
+    ----------
+    binary_vid : np.ndarray
+        The current frame of the binary video.
+
+    Returns
+    -------
+    np.ndarray
+        An array containing the number of new active pixels for each row.
+
+    Notes
+    -----
+    This function uses Numba's @njit decorator for performance.
+
+    Examples
+    --------
+    >>> binary_vid=np.zeros((4, 5, 5), dtype=np.uint8)
+    >>> binary_vid[:2, 3, 3] = 1
+    >>> binary_vid[1, 4, 3] = 1
+    >>> binary_vid[2, 3, 4] = 1
+    >>> binary_vid[3, 2, 3] = 1
+    >>> get_newly_explored_area(binary_vid)
+    array([0, 1, 1, 1])
+
+    >>> binary_vid=np.zeros((5, 5), dtype=np.uint8)[None, :, :]
+    >>> get_newly_explored_area(binary_vid)
+    array([0])
+    """
+    return ((binary_vid - binary_vid[0, ...]) == 1).reshape(binary_vid.shape[0], - 1).sum(1)
+
+def get_contour_width_from_im_shape(im_shape: Tuple) -> int:
+    """
+    Calculate the contour width based on image shape.
+
+    Parameters
+    ----------
+    im_shape : tuple of int, two items
+        The dimensions of the image.
+
+    Returns
+    -------
+    int
+        The calculated contour width.
+    """
+    return np.max((np.round(np.log10(np.max(im_shape)) - 2).astype(int), 1))
+
+def scale_coordinates(coord: NDArray, scale: Tuple, dims: Tuple) -> Tuple[NDArray[np.int64], np.int64, np.int64, np.int64, np.int64]:
+    """
+    Scale coordinates based on given scale factors and dimensions.
+
+    Parameters
+    ----------
+    coord : numpy.ndarray
+        A 2x2 array of coordinates to be scaled.
+    scale : tuple of float
+        Scaling factors for the x and y coordinates, respectively.
+    dims : tuple of int
+        Maximum dimensions (height, width) for the scaled coordinates.
+
+    Returns
+    -------
+    numpy.ndarray
+        Scaled and rounded coordinates.
+    int
+        Minimum y-coordinate.
+    int
+        Maximum y-coordinate.
+    int
+        Minimum x-coordinate.
+    int
+        Maximum x-coordinate.
+
+    Examples
+    --------
+    >>> coord = np.array(((47, 38), (59, 37)))
+    >>> scale = (0.92, 0.87)
+    >>> dims = (245, 300, 3)
+    >>> scaled_coord, min_y, max_y, min_x, max_x = scale_coordinates(coord, scale, dims)
+    >>> scaled_coord
+    array([[43, 33],
+           [54, 32]])
+    >>> min_y, max_y
+    (np.int64(43), np.int64(54))
+    >>> min_x, max_x
+    (np.int64(32), np.int64(33))
+
+    Notes
+    -----
+    This function assumes that the input coordinates are in a specific format
+    and will fail if not. The scaling factors should be positive.
+    """
+    coord = np.array(((np.round(coord[0][0] * scale[0]), np.round(coord[0][1] * scale[1])),
+                    (np.round(coord[1][0] * scale[0]), np.round(coord[1][1] * scale[1]))), dtype=np.int64)
+    min_y = np.max((0, np.min(coord[:, 0])))
+    max_y = np.min((dims[0], np.max(coord[:, 0])))
+    min_x = np.max((0, np.min(coord[:, 1])))
+    max_x = np.min((dims[1], np.max(coord[:, 1])))
+    return coord, min_y, max_y, min_x, max_x