imops 0.8.8__cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl

imops/interp1d.py

@@ -0,0 +1,207 @@
+from typing import Union
+from warnings import warn
+
+import numpy as np
+from scipy.interpolate import interp1d as scipy_interp1d
+
+from .backend import BackendLike, resolve_backend
+from .numeric import copy as _copy
+from .src._fast_zoom import _interp1d as cython_fast_interp1d
+from .src._zoom import _interp1d as cython_interp1d
+from .utils import normalize_num_threads
+
+
+class interp1d:
+    """
+    Faster parallelizable version of `scipy.interpolate.interp1d` for fp32 / fp64 inputs.
+
+    Works faster only for ndim <= 3. Shares interface with `scipy.interpolate.interp1d` except for `num_threads` and
+    `backend` arguments.
+
+    Parameters
+    ----------
+    x: np.ndarray
+        1-dimensional array of real values (aka coordinates)
+    y: np.ndarray
+        n-dimensional array of real values. The length of y along the interpolation axis must be equal to the x length
+    kind: Union[int, str]
+        specifies the kind of interpolation as a string or as an integer specifying the order of interpolation to use.
+        Only kind=1 and 'linear` are fast and parallelizable, other kinds will force to use `scipy` implementation
+    axis: int
+        specifies the axis of y along which to interpolate. Interpolation defaults to the last axis of y
+    copy: bool
+        if True, the class makes internal copies of x and y. If False, references to x and y are used
+    bounds_error: bool
+        if True, a ValueError is raised any time interpolation is attempted on a value outside of the range of x where
+        extrapolation is necessary. If False, out of bounds values are assigned fill_value. By default, an error is
+        raised unless fill_value='extrapolate'
+    fill_value: Union[float, str]
+        if a float, this value will be used to fill in for requested points outside of the data range. If not provided,
+        then the default is NaN. If 'extrapolate', values for points outside of the data range will be extrapolated
+    assume_sorted: bool
+        if False, values of x can be in any order and they are sorted first. If True, x has to be an array of
+        monotonically increasing values
+    num_threads: int
+        the number of threads to use for computation. Default = the cpu count. If negative value passed
+        cpu count + num_threads + 1 threads will be used
+    backend: BackendLike
+        which backend to use. `numba`, `cython` and `scipy` are available, `cython` is used by default
+
+    Methods
+    -------
+    __call__
+
+    Examples
+    --------
+    ```python
+    import numpy as np
+    from imops.interp1d import interp1d
+    x = np.arange(0, 10)
+    y = np.exp(-x/3.0)
+    f = interp1d(x, y)
+    xnew = np.arange(0, 9, 0.1)
+    ynew = f(xnew)   # use interpolation function returned by `interp1d`
+    ```
+    """
+
+    def __init__(
+        self,
+        x: np.ndarray,
+        y: np.ndarray,
+        kind: Union[int, str] = 'linear',
+        axis: int = -1,
+        copy: bool = True,
+        bounds_error: bool = None,
+        fill_value: Union[float, str] = np.nan,
+        assume_sorted: bool = False,
+        num_threads: int = -1,
+        backend: BackendLike = None,
+    ) -> None:
+        backend = resolve_backend(backend, warn_stacklevel=3)
+        if backend.name not in ('Scipy', 'Numba', 'Cython'):
+            raise ValueError(f'Unsupported backend "{backend.name}".')
+
+        self.backend = backend
+        self.dtype = y.dtype
+        self.num_threads = num_threads
+
+        if backend.name == 'Scipy':
+            self.scipy_interp1d = scipy_interp1d(x, y, kind, axis, copy, bounds_error, fill_value, assume_sorted)
+        elif self.dtype not in (np.float32, np.float64) or y.ndim > 3 or kind not in ('linear', 1):
+            warn(
+                "Fast interpolation is only supported for ndim<=3, dtype=float32 or float64, order=1 or 'linear'. "
+                "Falling back to scipy's implementation.",
+                stacklevel=2,
+            )
+            self.scipy_interp1d = scipy_interp1d(x, y, kind, axis, copy, bounds_error, fill_value, assume_sorted)
+        else:
+            if len(x) != y.shape[axis]:
+                raise ValueError(
+                    f'x and y arrays must be equal in length along interpolation axis: {len(x)} vs {y.shape[axis]}.'
+                )
+
+            if bounds_error and fill_value == 'extrapolate':
+                raise ValueError('Cannot extrapolate and raise at the same time.')
+
+            if fill_value == 'extrapolate' and len(x) < 2 or y.shape[axis] < 2:
+                raise ValueError('x and y arrays must have at least 2 entries.')
+
+            if fill_value == 'extrapolate':
+                self.bounds_error = False
+            else:
+                self.bounds_error = True if bounds_error is None else bounds_error
+
+            self.axis = axis
+
+            if axis not in (-1, y.ndim - 1):
+                y = np.swapaxes(y, -1, axis)
+
+            self.fill_value = fill_value
+            self.scipy_interp1d = None
+            # FIXME: how to accurately pass `num_threads` and `backend` arguments to `copy`?
+            self.x = _copy(x, order='C') if copy else x
+            self.n_dummy = 3 - y.ndim
+            self.y = y[(None,) * self.n_dummy] if self.n_dummy else y
+
+            if copy:
+                self.y = _copy(self.y, order='C')
+
+            self.assume_sorted = assume_sorted
+
+            if backend.name == 'Cython':
+                self.src_interp1d = cython_fast_interp1d if backend.fast else cython_interp1d
+
+            if backend.name == 'Numba':
+                from numba import njit
+
+                from .src._numba_zoom import _interp1d as numba_interp1d
+
+                njit_kwargs = {kwarg: getattr(backend, kwarg) for kwarg in backend.__dataclass_fields__.keys()}
+                self.src_interp1d = njit(**njit_kwargs)(numba_interp1d)
+
+    def __call__(self, x_new: np.ndarray) -> np.ndarray:
+        """
+        Evaluate the interpolant
+
+        Parameters
+        ----------
+        x_new: np.ndarray
+            1d array points to evaluate the interpolant at.
+
+        Returns
+        -------
+        y_new: np.ndarray
+            interpolated values. Shape is determined by replacing the interpolation axis in the original array with
+            the shape of x
+        """
+        num_threads = normalize_num_threads(self.num_threads, self.backend, warn_stacklevel=3)
+
+        if self.scipy_interp1d is not None:
+            return self.scipy_interp1d(x_new)
+
+        extrapolate = self.fill_value == 'extrapolate'
+        args = () if self.backend.name in ('Numba',) else (num_threads,)
+
+        if self.backend.name == 'Numba':
+            from numba import get_num_threads, set_num_threads
+
+            old_num_threads = get_num_threads()
+            set_num_threads(num_threads)
+        # TODO: Figure out how to properly handle multiple type signatures in Cython and remove `.astype`-s
+        out = self.src_interp1d(
+            self.y,
+            self.x.astype(np.float64, copy=False),
+            x_new.astype(np.float64, copy=False),
+            self.bounds_error,
+            0.0 if extrapolate else self.fill_value,
+            extrapolate,
+            self.assume_sorted,
+            *args,
+        )
+
+        if self.backend.name == 'Numba':
+            set_num_threads(old_num_threads)
+
+        out = out.astype(max(self.y.dtype, self.x.dtype, x_new.dtype, key=lambda x: x.type(0).itemsize), copy=False)
+
+        if self.n_dummy:
+            out = out[(0,) * self.n_dummy]
+        if self.axis not in (-1, out.ndim - 1):
+            out = np.swapaxes(out, -1, self.axis)
+        # FIXME: fix behaviour with np.inf-s
+        if np.isnan(out).any():
+            if not np.isinf(out).any():
+                raise RuntimeError("Can't decide how to handle nans in the output.")
+
+            have_neg = np.isneginf(out).any()
+            have_pos = np.isposinf(out).any()
+
+            if have_pos and have_neg:
+                raise RuntimeError("Can't decide how to handle nans in the output.")
+
+            if have_pos:
+                return np.nan_to_num(out, copy=False, nan=np.inf, posinf=np.inf)
+
+            return np.nan_to_num(out, copy=False, nan=-np.inf, neginf=-np.inf)
+
+        return out

imops/interp2d.py

@@ -0,0 +1,120 @@
+from platform import python_version
+
+import numpy as np
+from scipy.spatial import KDTree
+
+from .backend import Cython
+from .cpp.cpp_modules import Linear2DInterpolatorCpp
+from .utils import normalize_num_threads
+
+
+class Linear2DInterpolator(Linear2DInterpolatorCpp):
+    """
+    2D Delaunay triangulation and parallel linear interpolation
+
+    Parameters
+    ----------
+    points: np.ndarray
+        2-D array of data point coordinates
+    values: np.ndarray
+        1-D array of fp32/fp64 values
+    num_threads: int
+        the number of threads to use for computation. Default = the cpu count. If negative value passed
+        cpu count + num_threads + 1 threads will be used
+    triangels: np.ndarray
+        optional precomputed triangulation in the form of array or arrays of points indices
+
+    Methods
+    -------
+    __call__
+
+    Examples
+    --------
+    ```python
+    n, m = 1024, 2
+    points = np.random.randint(low=0, high=1024, size=(n, m))
+    points = np.unique(points, axis=0)
+    x_points = points[: n // 2]
+    values = np.random.uniform(low=0.0, high=1.0, size=(len(x_points),))
+    interp_points = points[n // 2:]
+    num_threads = -1  # will be equal to num of CPU cores
+    interpolator = Linear2DInterpolator(x_points, values, num_threads)
+    # Also you can pass values to __call__ and rewrite the ones that were passed to __init__
+    interp_values = interpolator(interp_points, values + 1.0, fill_value=0.0)
+    ```
+    """
+
+    def __init__(
+        self,
+        points: np.ndarray,
+        values: np.ndarray = None,
+        num_threads: int = 1,
+        triangles: np.ndarray = None,
+        **kwargs,
+    ):
+        if triangles is not None:
+            if not isinstance(triangles, np.ndarray):
+                raise TypeError(f'Wrong type of `triangles` argument, expected np.ndarray. Got {type(triangles)}')
+            if triangles.ndim != 2 or triangles.shape[1] != 3:
+                raise ValueError('Passed `triangles` argument has an incorrect shape')
+
+        if not isinstance(points, np.ndarray):
+            raise TypeError(f'Wrong type of `points` argument, expected np.ndarray. Got {type(points)}')
+
+        if points.ndim != 2 or points.shape[1] != 2:
+            raise ValueError('Passed `points` argument has an incorrect shape')
+
+        if values is not None:
+            if not isinstance(values, np.ndarray):
+                raise TypeError(f'Wrong type of `values` argument, expected np.ndarray. Got {type(values)}')
+
+            if values.ndim > 1:
+                raise ValueError(f'Wrong shape of `values` argument, expected ndim=1. Got shape {values.shape}')
+
+        super().__init__(points, num_threads, triangles)
+        self.kdtree = KDTree(data=points, **kwargs)
+        self.values = values
+        # FIXME: add backend dispatch
+        self.num_threads = normalize_num_threads(num_threads, Cython(), warn_stacklevel=3)
+
+    def __call__(self, points: np.ndarray, values: np.ndarray = None, fill_value: float = 0.0) -> np.ndarray:
+        """
+        Evaluate the interpolant
+
+        Parameters
+        ----------
+        points: np.ndarray
+            2-D array of data point coordinates to interpolate at
+        values: np.ndarray
+            1-D array of fp32/fp64 values to use at initial points
+        fill_value: float
+            value to fill past edges
+
+        Returns
+        -------
+        new_values: np.ndarray
+            interpolated values at given points
+        """
+        if values is None:
+            values = self.values
+
+        if values is None:
+            raise ValueError('`values` argument was never passed neither in __init__ or __call__ methods')
+
+        if not isinstance(values, np.ndarray):
+            raise TypeError(f'Wrong type of `values` argument, expected np.ndarray. Got {type(values)}')
+
+        if values.ndim > 1:
+            raise ValueError(f'Wrong shape of `values` argument, expected ndim=1. Got shape {values.shape}')
+
+        if not isinstance(points, np.ndarray):
+            raise TypeError(f'Wrong type of `points` argument, expected np.ndarray. Got {type(points)}')
+
+        if points.ndim != 2 or points.shape[1] != 2:
+            raise ValueError('Passed `points` argument has an incorrect shape')
+
+        _, neighbors = self.kdtree.query(
+            points, 1, **{'workers': self.num_threads} if python_version()[:3] != '3.6' else {}
+        )
+
+        return super().__call__(points, values, neighbors, fill_value)

imops/measure.py

@@ -0,0 +1,228 @@
+from collections import namedtuple
+from platform import python_version
+from typing import List, NamedTuple, Sequence, Tuple, Union
+from warnings import warn
+
+import numpy as np
+from cc3d import connected_components
+from fastremap import remap, unique
+from scipy.ndimage import center_of_mass as scipy_center_of_mass
+from skimage.measure import label as skimage_label
+
+from .backend import BackendLike, resolve_backend
+from .src._fast_measure import (
+    _center_of_mass as _fast_center_of_mass,
+    _labeled_center_of_mass as _fast_labeled_center_of_mass,
+)
+from .src._measure import _center_of_mass, _labeled_center_of_mass
+from .utils import normalize_num_threads
+
+
+# (ndim, skimage_connectivity) -> cc3d_connectivity
+_SKIMAGE2CC3D = {
+    (1, 1): 4,
+    (2, 1): 4,
+    (2, 2): 8,
+    (3, 1): 6,
+    (3, 2): 18,
+    (3, 3): 26,
+}
+
+
+def label(
+    label_image: np.ndarray,
+    background: int = None,
+    connectivity: int = None,
+    return_num: bool = False,
+    return_labels: bool = False,
+    return_sizes: bool = False,
+    dtype: type = None,
+) -> Union[np.ndarray, NamedTuple]:
+    """
+    Fast version of `skimage.measure.label` which optionally returns number of connected components, labels and sizes.
+    If 2 or more outputs are requested `NamedTuple` is returned.
+
+    Parameters
+    ----------
+    label_image: np.ndarray
+        image to label
+    background: int
+        consider all pixels with this value as background pixels, and label them as 0. By default, 0-valued pixels are
+        considered as background pixels
+    connectivity: int
+        maximum number of orthogonal hops to consider a pixel/voxel as a neighbor. Accepted values are ranging from 1
+        to input.ndim. If None, a full connectivity of input.ndim is used
+    return_num: bool
+        whether to return the number of connected components
+    return_labels: bool
+        whether to return assigned labels
+    return_sizes: bool
+        whether to return sizes of connected components (excluding background)
+    dtype:
+        if specified, must be one of np.uint16, np.uint32 or np.uint64. If not specified, it will be automatically
+        determined. Most of the time, you should leave this off so that the smallest safe dtype will be used. However,
+        in some applications you can save an up-conversion in the next operation by outputting the appropriately sized
+        type instead. Has no effect for python3.6
+
+    Returns
+    -------
+    labeled_image: np.ndarray
+        array of np.uint16, np.uint32 or np.uint64 numbers depending on the number of connected components and
+        `dtype`
+    num_components: int
+        number of connected components excluding background. Returned if `return_num` is True
+    labels: np.ndarray
+        components labels. Returned if `return_labels` is True
+    sizes: np.ndarray
+        components sizes. Returned if `return_sizes` is True
+
+    Examples
+    --------
+    ```python
+    labeled = label(x)
+    labeled, num_components, sizes = label(x, return_num=True, return_sizes=True)
+    out = label(x, return_labels=True, return_sizes=True)
+    out.labeled_image, out.labels, out.sizes  # output fields can be accessed this way
+    ```
+    """
+    ndim = label_image.ndim
+    connectivity = connectivity or ndim
+
+    if not 1 <= connectivity <= ndim:
+        raise ValueError(f'Connectivity for {ndim}D image should be in [1, ..., {ndim}]. Got {connectivity}.')
+
+    if ndim > 3:
+        warn("Fast label is only supported for ndim<=3, Falling back to scikit-image's implementation.", stacklevel=2)
+        labeled_image, num_components = skimage_label(
+            label_image, background=background, return_num=True, connectivity=connectivity
+        )
+        if dtype is not None:
+            labeled_image = labeled_image.astype(dtype, copy=False)
+    else:
+        if ndim == 1:
+            label_image = label_image[None]
+
+        if background:
+            label_image = remap(
+                label_image,
+                {background: 0, 0: background},
+                preserve_missing_labels=True,
+                in_place=False,
+            )
+
+        labeled_image, num_components = connected_components(
+            label_image,
+            connectivity=_SKIMAGE2CC3D[(ndim, connectivity)],
+            return_N=True,
+            **{'out_dtype': dtype} if python_version()[:3] != '3.6' else {},
+        )
+
+        if ndim == 1:
+            labeled_image = labeled_image[0]
+
+    res = [('labeled_image', labeled_image)]
+
+    if return_num:
+        res.append(('num_components', num_components))
+    if return_labels:
+        res.append(('labels', np.array(range(1, num_components + 1))))
+    if return_sizes:
+        _, sizes = unique(labeled_image, return_counts=True)
+        res.append(('sizes', sizes[1:] if 0 in labeled_image else sizes))
+
+    if len(res) == 1:
+        return labeled_image
+
+    return namedtuple('Labeling', [subres[0] for subres in res])(*[subres[1] for subres in res])
+
+
+def center_of_mass(
+    array: np.ndarray,
+    labels: np.ndarray = None,
+    index: Union[int, Sequence[int]] = None,
+    num_threads: int = -1,
+    backend: BackendLike = None,
+) -> Union[Tuple[float, ...], List[Tuple[float, ...]]]:
+    """
+    Calculate the center of mass of the values.
+
+    Works faster for ndim <= 3
+
+    Parameters
+    ----------
+    array: np.ndarray
+        data from which to calculate center-of-mass. The masses can either be positive or negative
+    labels: np.ndarray
+        labels for objects in input, as generated by `imops.measure.label`. Dimensions must be the same as input. If
+        specified, `index` also must be specified and have same dtype
+    index: Union[int, Sequence[int]]
+        labels for which to calculate centers-of-mass. If specified, `labels` also must be specified and have same dtype
+    num_threads: int
+        the number of threads to use for computation. Default = the cpu count. If negative value passed
+        cpu count + num_threads + 1 threads will be used. If `labels` and `index` are specified, only 1 thread will be
+        used
+    backend: BackendLike
+        which backend to use. `cython` and `scipy` are available, `cython` is used by default
+
+    Returns
+    -------
+    center_of_mass: tuple, or list of tuples
+        coordinates of centers-of-mass
+
+    Examples
+    --------
+    ```python
+    center = center_of_mass(np.ones((2, 2)))  # (0.5, 0.5)
+    ```
+    """
+    if (labels is None) ^ (index is None):
+        raise ValueError('`labels` and `index` should be both specified or both not specified.')
+
+    backend = resolve_backend(backend, warn_stacklevel=3)
+
+    if backend.name not in ('Scipy', 'Cython'):
+        raise ValueError(f'Unsupported backend "{backend.name}".')
+
+    num_threads = normalize_num_threads(num_threads, backend, warn_stacklevel=3)
+
+    if backend.name == 'Scipy':
+        return scipy_center_of_mass(array, labels, index)
+
+    ndim = array.ndim
+    if ndim > 3:
+        warn("Fast center-of-mass is only supported for ndim<=3. Falling back to scipy's implementation.", stacklevel=2)
+        return scipy_center_of_mass(array, labels, index)
+
+    if labels is None:
+        src_center_of_mass = _fast_center_of_mass if backend.fast else _center_of_mass
+    else:
+        is_sequence = isinstance(index, (Sequence, np.ndarray))
+        index = np.array([index] if not is_sequence else index)
+
+        if labels.shape != array.shape:
+            raise ValueError(f'`array` and `labels` must be the same shape, got {array.shape} and {labels.shape}.')
+
+        if labels.dtype != index.dtype:
+            raise ValueError(f'`labels` and `index` must have same dtype, got {labels.dtype} and {index.dtype}.')
+
+        if len(index) != len(unique(index.astype(int, copy=False))):
+            raise ValueError('`index` should consist of unique values.')
+
+        if num_threads > 1:
+            warn('Using single-threaded implementation as `labels` and `index` are specified.', stacklevel=2)
+
+        src_center_of_mass = _fast_labeled_center_of_mass if backend.fast else _labeled_center_of_mass
+
+    if array.dtype != 'float64':
+        array = array.astype(float)
+
+    n_dummy = 3 - ndim
+    if n_dummy:
+        array = array[(None,) * n_dummy]
+
+    if labels is None:
+        return tuple(src_center_of_mass(array, num_threads))[n_dummy:]
+
+    output = [tuple(x)[n_dummy:] for x in src_center_of_mass(array, labels[(None,) * n_dummy], index)]
+
+    return output if is_sequence else output[0]