imops 0.8.1__cp36-cp36m-win32.whl → 0.8.3__cp36-cp36m-win32.whl

imops/src/_numeric.pyx

@@ -8,10 +8,19 @@
 import numpy as np
 
 cimport numpy as np
+from libc.stdint cimport uint16_t
 
 from cython.parallel import prange
 
 
+# https://stackoverflow.com/questions/47421443/using-half-precision-numpy-floats-in-cython
+cdef extern from "numpy/halffloat.h":
+    ctypedef uint16_t npy_half
+
+    float npy_half_to_float(npy_half h) nogil
+    npy_half npy_float_to_half(float f) nogil
+
+
 ctypedef fused NUM:
     short
     int
@@ -20,45 +29,214 @@ ctypedef fused NUM:
     double
 
 
-def _parallel_sum(NUM[:] nums, Py_ssize_t num_threads) -> NUM:
-    cdef NUM res = 0
-    cdef Py_ssize_t i, len_nums = len(nums)
+ctypedef fused NUM_AND_NPY_HALF:
+    NUM
+    npy_half
 
-    for i in prange(len_nums, num_threads=num_threads, nogil=True):
-        res += nums[i]
 
-    return res
-
-
-def _parallel_pointwise_mul(
+# TODO: Generalize code below to n-d
+def _pointwise_add_array_3d(
     NUM[:, :, :] nums1,
     NUM[:, :, :] nums2,
-    Py_ssize_t[:] res_shape,
-    Py_ssize_t num_threads
+    NUM[:, :, :] out,
+    Py_ssize_t num_threads,
 ) -> np.ndarray:
-    cdef NUM[:, :, ::1] contiguous_nums1 = np.ascontiguousarray(nums1), contiguous_nums2 = np.ascontiguousarray(nums2)
-    cdef Py_ssize_t rows = res_shape[0], cols = res_shape[1], dims = res_shape[2]
+    cdef Py_ssize_t rows = out.shape[0], cols = out.shape[1], dims = out.shape[2]
+    cdef Py_ssize_t i, j, k
+
+    for i in prange(rows, nogil=True, num_threads=num_threads):
+        for j in prange(cols):
+            for k in prange(dims):
+                out[i, j, k] = nums1[i, j, k] + nums2[i, j, k]
+
+    return np.asarray(out)
 
-    cdef char[:] broadcast_mask1 = np.array([x == y for x, y in zip(res_shape, nums1.shape)], dtype=np.int8)
-    cdef char[:] broadcast_mask2 = np.array([x == y for x, y in zip(res_shape, nums2.shape)], dtype=np.int8)
 
-    cdef NUM[:, :, ::1] mul = np.empty_like(nums1, shape=res_shape)
+def _pointwise_add_array_4d(
+    NUM[:, :, :, :] nums1,
+    NUM[:, :, :, :] nums2,
+    NUM[:, :, :, :] out,
+    Py_ssize_t num_threads,
+) -> np.ndarray:
+    cdef Py_ssize_t dim1 = out.shape[0], dim2 = out.shape[1], dim3 = out.shape[2], dim4 = out.shape[3]
+    cdef Py_ssize_t i1, i2, i3, i4
+
+    for i1 in prange(dim1, nogil=True, num_threads=num_threads):
+        for i2 in prange(dim2):
+            for i3 in prange(dim3):
+                for i4 in prange(dim4):
+                    out[i1, i2, i3, i4] = nums1[i1, i2, i3, i4] + nums2[i1, i2, i3, i4]
+
+    return np.asarray(out)
+
+
+def _pointwise_add_value_3d(
+    NUM[:, :, :] nums,
+    NUM value,
+    NUM[:, :, :] out,
+    Py_ssize_t num_threads,
+) -> np.ndarray:
+    cdef Py_ssize_t rows = out.shape[0], cols = out.shape[1], dims = out.shape[2]
     cdef Py_ssize_t i, j, k
 
     for i in prange(rows, nogil=True, num_threads=num_threads):
         for j in prange(cols):
             for k in prange(dims):
-                mul[i, j, k] = (
-                    contiguous_nums1[
-                        i * broadcast_mask1[0],
-                        j * broadcast_mask1[1],
-                        k * broadcast_mask1[2]
-                    ] *
-                    contiguous_nums2[
-                        i * broadcast_mask2[0],
-                        j * broadcast_mask2[1],
-                        k * broadcast_mask2[2]
-                    ]
-                )
-
-    return np.asarray(mul)
+                out[i, j, k] = nums[i, j, k] + value
+
+    return np.asarray(out)
+
+
+def _pointwise_add_value_4d(
+    NUM[:, :, :, :] nums,
+    NUM value,
+    NUM[:, :, :, :] out,
+    Py_ssize_t num_threads,
+) -> np.ndarray:
+    cdef Py_ssize_t dim1 = out.shape[0], dim2 = out.shape[1], dim3 = out.shape[2], dim4 = out.shape[3]
+    cdef Py_ssize_t i1, i2, i3, i4
+
+    for i1 in prange(dim1, nogil=True, num_threads=num_threads):
+        for i2 in prange(dim2):
+            for i3 in prange(dim3):
+                for i4 in prange(dim4):
+                    out[i1, i2, i3, i4] = nums[i1, i2, i3, i4] + value
+
+    return np.asarray(out)
+
+
+def _pointwise_add_array_3d_fp16(
+    npy_half[:, :, :] nums1,
+    npy_half[:, :, :] nums2,
+    npy_half[:, :, :] out,
+    Py_ssize_t num_threads,
+) -> np.ndarray:
+    cdef Py_ssize_t rows = out.shape[0], cols = out.shape[1], dims = out.shape[2]
+    cdef Py_ssize_t i, j, k
+
+    for i in prange(rows, nogil=True, num_threads=num_threads):
+        for j in prange(cols):
+            for k in prange(dims):
+                out[i, j, k] = (npy_float_to_half(npy_half_to_float(nums1[i, j, k]) +
+                                npy_half_to_float(nums2[i, j, k])))
+
+    return np.asarray(out)
+
+
+def _pointwise_add_array_4d_fp16(
+    npy_half[:, :, :, :] nums1,
+    npy_half[:, :, :, :] nums2,
+    npy_half[:, :, :, :] out,
+    Py_ssize_t num_threads,
+) -> np.ndarray:
+    cdef Py_ssize_t dim1 = out.shape[0], dim2 = out.shape[1], dim3 = out.shape[2], dim4 = out.shape[3]
+    cdef Py_ssize_t i1, i2, i3, i4
+
+    for i1 in prange(dim1, nogil=True, num_threads=num_threads):
+        for i2 in prange(dim2):
+            for i3 in prange(dim3):
+                for i4 in prange(dim4):
+                    out[i1, i2, i3, i4] = (npy_float_to_half(npy_half_to_float(nums1[i1, i2, i3, i4]) +
+                                           npy_half_to_float(nums2[i1, i2, i3, i4])))
+
+    return np.asarray(out)
+
+
+def _pointwise_add_value_3d_fp16(
+    npy_half[:, :, :] nums,
+    npy_half value,
+    npy_half[:, :, :] out,
+    Py_ssize_t num_threads,
+) -> np.ndarray:
+    cdef Py_ssize_t rows = out.shape[0], cols = out.shape[1], dims = out.shape[2]
+    cdef Py_ssize_t i, j, k
+
+    for i in prange(rows, nogil=True, num_threads=num_threads):
+        for j in prange(cols):
+            for k in prange(dims):
+                out[i, j, k] = npy_float_to_half(npy_half_to_float(nums[i, j, k]) + npy_half_to_float(value))
+
+    return np.asarray(out)
+
+
+def _pointwise_add_value_4d_fp16(
+    npy_half[:, :, :, :] nums,
+    npy_half value,
+    npy_half[:, :, :, :] out,
+    Py_ssize_t num_threads,
+) -> np.ndarray:
+    cdef Py_ssize_t dim1 = out.shape[0], dim2 = out.shape[1], dim3 = out.shape[2], dim4 = out.shape[3]
+    cdef Py_ssize_t i1, i2, i3, i4
+
+    for i1 in prange(dim1, nogil=True, num_threads=num_threads):
+        for i2 in prange(dim2):
+            for i3 in prange(dim3):
+                for i4 in prange(dim4):
+                    out[i1, i2, i3, i4] = (npy_float_to_half(npy_half_to_float(nums[i1, i2, i3, i4]) +
+                                           npy_half_to_float(value)))
+
+    return np.asarray(out)
+
+
+def _fill_3d(NUM_AND_NPY_HALF[:, :, :] nums, NUM_AND_NPY_HALF value, Py_ssize_t num_threads) -> None:
+    cdef Py_ssize_t rows = nums.shape[0], cols = nums.shape[1], dims = nums.shape[2]
+    cdef Py_ssize_t i, j, k
+
+    for i in prange(rows, nogil=True, num_threads=num_threads):
+        for j in prange(cols):
+            for k in prange(dims):
+                nums[i, j, k] = value
+
+
+def _fill_4d(NUM_AND_NPY_HALF[:, :, :, :] nums, NUM_AND_NPY_HALF value, Py_ssize_t num_threads) -> None:
+    cdef Py_ssize_t dim1 = nums.shape[0], dim2 = nums.shape[1], dim3 = nums.shape[2], dim4 = nums.shape[3]
+    cdef Py_ssize_t i1, i2, i3, i4
+
+    for i1 in prange(dim1, nogil=True, num_threads=num_threads):
+        for i2 in prange(dim2):
+            for i3 in prange(dim3):
+                for i4 in prange(dim4):
+                    nums[i1, i2, i3, i4] = value
+
+
+# FIXME: somehow `const NUM_AND_NPY_HALF` is not working
+cpdef void _copy_3d(const NUM[:, :, :] nums1, NUM[:, :, :] nums2, Py_ssize_t num_threads):
+    cdef Py_ssize_t rows = nums1.shape[0], cols = nums1.shape[1], dims = nums1.shape[2]
+    cdef Py_ssize_t i, j, k
+
+    for i in prange(rows, nogil=True, num_threads=num_threads):
+        for j in prange(cols):
+            for k in prange(dims):
+                nums2[i, j, k] = nums1[i, j, k]
+
+
+cpdef void _copy_4d(const NUM[:, :, :, :] nums1, NUM[:, :, :, :] nums2, Py_ssize_t num_threads):
+    cdef Py_ssize_t dim1 = nums1.shape[0], dim2 = nums1.shape[1], dim3 = nums1.shape[2], dim4 = nums1.shape[3]
+    cdef Py_ssize_t i1, i2, i3, i4
+
+    for i1 in prange(dim1, nogil=True, num_threads=num_threads):
+        for i2 in prange(dim2):
+            for i3 in prange(dim3):
+                for i4 in prange(dim4):
+                    nums2[i1, i2, i3, i4] = nums1[i1, i2, i3, i4]
+
+
+cpdef void _copy_3d_fp16(const npy_half[:, :, :] nums1, npy_half[:, :, :] nums2, Py_ssize_t num_threads):
+    cdef Py_ssize_t rows = nums1.shape[0], cols = nums1.shape[1], dims = nums1.shape[2]
+    cdef Py_ssize_t i, j, k
+
+    for i in prange(rows, nogil=True, num_threads=num_threads):
+        for j in prange(cols):
+            for k in prange(dims):
+                nums2[i, j, k] = nums1[i, j, k]
+
+
+cpdef void _copy_4d_fp16(const npy_half[:, :, :, :] nums1, npy_half[:, :, :, :] nums2, Py_ssize_t num_threads):
+    cdef Py_ssize_t dim1 = nums1.shape[0], dim2 = nums1.shape[1], dim3 = nums1.shape[2], dim4 = nums1.shape[3]
+    cdef Py_ssize_t i1, i2, i3, i4
+
+    for i1 in prange(dim1, nogil=True, num_threads=num_threads):
+        for i2 in prange(dim2):
+            for i3 in prange(dim3):
+                for i4 in prange(dim4):
+                    nums2[i1, i2, i3, i4] = nums1[i1, i2, i3, i4]

imops/src/_zoom.pyx

@@ -17,6 +17,7 @@ from libc.math cimport floor, sqrt
 
 ctypedef cython.floating FLOAT
 ctypedef fused NUM:
+    np.uint8_t
     short
     int
     long long

imops/utils.py

@@ -1,39 +1,92 @@
 import os
+from contextlib import contextmanager
 from itertools import permutations
-from typing import Callable, Optional, Sequence, Union
+from typing import Callable, Optional, Sequence, Tuple, Union
 from warnings import warn
 
 import numpy as np
 
-from .backend import BACKEND2NUM_THREADS_VAR_NAME, SINGLE_THREADED_BACKENDS, Backend
+from .backend import BACKEND_NAME2ENV_NUM_THREADS_VAR_NAME, SINGLE_THREADED_BACKENDS, Backend
 
 
 AxesLike = Union[int, Sequence[int]]
 AxesParams = Union[float, Sequence[float]]
 
 ZOOM_SRC_DIM = 4
+# TODO: define imops-specific environment variable like `OMP_NUM_THREADS`?
+IMOPS_NUM_THREADS = None
 
 
-def normalize_num_threads(num_threads: int, backend: Backend):
+def set_num_threads(num_threads: int) -> int:
+    assert isinstance(num_threads, int) or num_threads is None, 'Number of threads must be int value or None.'
+    global IMOPS_NUM_THREADS
+    current = IMOPS_NUM_THREADS
+    IMOPS_NUM_THREADS = num_threads
+    return current
+
+
+@contextmanager
+def imops_num_threads(num_threads: int):
+    previous = set_num_threads(num_threads)
+    try:
+        yield
+    finally:
+        set_num_threads(previous)
+
+
+def normalize_num_threads(num_threads: int, backend: Backend, warn_stacklevel: int = 1) -> int:
+    """Calculate the effective number of threads"""
+
+    global IMOPS_NUM_THREADS
     if backend.name in SINGLE_THREADED_BACKENDS:
         if num_threads != -1:
-            warn(f'"{backend.name}" backend is single-threaded. Setting `num_threads` has no effect.')
+            warn(
+                f'"{backend.name}" backend is single-threaded. Setting `num_threads` has no effect.',
+                stacklevel=warn_stacklevel,
+            )
         return 1
+
+    env_num_threads_var_name = BACKEND_NAME2ENV_NUM_THREADS_VAR_NAME[backend.name]
+    # here we also handle the case `env_num_threads_var_name`=" " gracefully
+    env_num_threads = os.environ.get(env_num_threads_var_name, '').strip()
+    env_num_threads = int(env_num_threads) if env_num_threads else None
+    # TODO: maybe let user set the absolute maximum number of threads?
+    num_available_cpus = len(os.sched_getaffinity(0))
+
+    max_num_threads = min(filter(bool, [IMOPS_NUM_THREADS, env_num_threads, num_available_cpus]))
+
     if num_threads >= 0:
         # FIXME
         if backend.name == 'Numba':
             warn(
                 'Setting `num_threads` has no effect with "Numba" backend. '
-                'Use `NUMBA_NUM_THREADS` environment variable.'
+                'Use `NUMBA_NUM_THREADS` environment variable.',
+                stacklevel=warn_stacklevel,
             )
-        return num_threads
-
-    num_threads_var_name = BACKEND2NUM_THREADS_VAR_NAME[backend.name]
-    # here we also handle the case `num_threads_var`=" " gracefully
-    env_num_threads = os.environ.get(num_threads_var_name, '').strip()
-    max_threads = int(env_num_threads) if env_num_threads else len(os.sched_getaffinity(0))
-
-    return max_threads + num_threads + 1
+            return num_threads
+
+        if num_threads > max_num_threads:
+            if max_num_threads == IMOPS_NUM_THREADS:
+                warn(
+                    f'Required number of threads ({num_threads}) is greater than `IMOPS_NUM_THREADS` '
+                    f'({IMOPS_NUM_THREADS}). Using {IMOPS_NUM_THREADS} threads.',
+                    stacklevel=warn_stacklevel,
+                )
+            elif max_num_threads == env_num_threads:
+                warn(
+                    f'Required number of threads ({num_threads}) is greater than `{env_num_threads_var_name}` '
+                    f'({env_num_threads}). Using {env_num_threads} threads.',
+                    stacklevel=warn_stacklevel,
+                )
+            else:
+                warn(
+                    f'Required number of threads ({num_threads}) is greater than number of available CPU-s '
+                    f'({num_available_cpus}). Using {num_available_cpus} threads.',
+                    stacklevel=warn_stacklevel,
+                )
+        return min(num_threads, max_num_threads)
+
+    return max_num_threads + num_threads + 1
 
 
 def get_c_contiguous_permutaion(array: np.ndarray) -> Optional[np.ndarray]:
@@ -104,3 +157,50 @@ def composition_args(f: Callable, g: Callable) -> Callable:
         return f(g(*args), *args[1:])
 
     return inner
+
+
+def morphology_composition_args(f, g) -> Callable:
+    def wrapper(
+        image: np.ndarray,
+        footprint: np.ndarray,
+        output: np.ndarray,
+        num_threads: int,
+    ):
+        temp = np.empty_like(image, dtype=bool)
+        temp = g(image, footprint, temp, num_threads)
+
+        return f(temp, footprint, output, num_threads)
+
+    return wrapper
+
+
+def build_slices(start: Sequence[int], stop: Sequence[int] = None, step: Sequence[int] = None) -> Tuple[slice, ...]:
+    """
+    Returns a tuple of slices built from `start` and `stop` with `step`.
+
+    Examples
+    --------
+    >>> build_slices([1, 2, 3], [4, 5, 6])
+    (slice(1, 4), slice(2, 5), slice(3, 6))
+    >>> build_slices([10, 11])
+    (slice(10), slice(11))
+    """
+
+    check_len(*filter(lambda x: x is not None, [start, stop, step]))
+
+    if stop is None and step is None:
+        return tuple(map(slice, start))
+
+    args = [
+        start,
+        stop if stop is not None else [None for _ in start],
+        step if step is not None else [None for _ in start],
+    ]
+
+    return tuple(map(slice, *args))
+
+
+def check_len(*args) -> None:
+    lengths = list(map(len, args))
+    if any(length != lengths[0] for length in lengths):
+        raise ValueError(f'Arguments of equal length are required: {", ".join(map(str, lengths))}')

imops/zoom.py

@@ -81,7 +81,7 @@ def zoom(
     """
     Rescale `x` according to `scale_factor` along the `axis`.
 
-    Uses a fast parallelizable implementation for fp32 / fp64 (and int16-32-64 if order == 0) inputs,
+    Uses a fast parallelizable implementation for fp32 / fp64 (and bool-int16-32-64 if order == 0) inputs,
     ndim <= 4 and order = 0 or 1.
 
     Parameters
@@ -120,6 +120,7 @@ def zoom(
     if callable(fill_value):
         fill_value = fill_value(x)
 
+    # TODO: does `fill_value/cval` change anythng?
     return _zoom(x, scale_factor, order=order, cval=fill_value, num_threads=num_threads, backend=backend)
 
 
@@ -135,7 +136,7 @@ def zoom_to_shape(
     """
     Rescale `x` to match `shape` along the `axis`.
 
-    Uses a fast parallelizable implementation for fp32 / fp64 (and int16-32-64 if order == 0) inputs,
+    Uses a fast parallelizable implementation for fp32 / fp64 (and bool-int16-32-64 if order == 0) inputs,
     ndim <= 4 and order = 0 or 1.
 
     Parameters
@@ -197,7 +198,7 @@ def _zoom(
     backend: BackendLike = None,
 ) -> np.ndarray:
     """
-    Faster parallelizable version of `scipy.ndimage.zoom` for fp32 / fp64 (and int16-32-64 if order == 0) inputs.
+    Faster parallelizable version of `scipy.ndimage.zoom` for fp32 / fp64 (and bool-int16-32-64 if order == 0) inputs.
 
     Works faster only for ndim <= 4. Shares interface with `scipy.ndimage.zoom`
     except for
@@ -207,7 +208,7 @@ def _zoom(
 
     See `https://docs.scipy.org/doc/scipy/reference/generated/scipy.ndimage.zoom.html`
     """
-    backend = resolve_backend(backend)
+    backend = resolve_backend(backend, warn_stacklevel=4)
     if backend.name not in ('Scipy', 'Numba', 'Cython'):
         raise ValueError(f'Unsupported backend "{backend.name}".')
 
@@ -215,7 +216,7 @@ def _zoom(
     dtype = input.dtype
     cval = np.dtype(dtype).type(cval)
     zoom = fill_by_indices(np.ones(input.ndim, 'float64'), zoom, range(input.ndim))
-    num_threads = normalize_num_threads(num_threads, backend)
+    num_threads = normalize_num_threads(num_threads, backend, warn_stacklevel=4)
 
     if backend.name == 'Scipy':
         return scipy_zoom(
@@ -227,7 +228,7 @@ def _zoom(
         or (
             dtype not in (np.float32, np.float64)
             if order == 1
-            else dtype not in (np.float32, np.float64, np.int16, np.int32, np.int64)
+            else dtype not in (bool, np.float32, np.float64, np.int16, np.int32, np.int64)
         )
         or ndim > 4
         or output is not None
@@ -235,10 +236,9 @@ def _zoom(
         or grid_mode
     ):
         warn(
-            'Fast zoom is only supported for ndim<=4, dtype=fp32 or fp64 (and int16-32-64 if order == 0), output=None, '
-            "order=0 or 1, mode='constant', grid_mode=False. Falling back to scipy's implementation.",
+            'Fast zoom is only supported for ndim<=4, dtype=fp32 or fp64 (and bool-int16-32-64 if order == 0), '
+            "output=None, order=0 or 1, mode='constant', grid_mode=False. Falling back to scipy's implementation.",
         )
-
         return scipy_zoom(
             input, zoom, output=output, order=order, mode=mode, cval=cval, prefilter=prefilter, grid_mode=grid_mode
         )

{imops-0.8.1.dist-info → imops-0.8.3.dist-info}/METADATA

@@ -1,12 +1,12 @@
 Metadata-Version: 2.1
 Name: imops
-Version: 0.8.1
+Version: 0.8.3
 Summary: Efficient parallelizable algorithms for multidimensional arrays to speed up your data pipelines
 Home-page: https://github.com/neuro-ml/imops
 Author: maxme1, vovaf709, talgat
 Author-email: maxs987@gmail.com, vovaf709@yandex.ru, saparov2130@gmail.com
 License: MIT
-Download-URL: https://github.com/neuro-ml/imops/archive/v0.8.1.tar.gz
+Download-URL: https://github.com/neuro-ml/imops/archive/v0.8.3.tar.gz
 Keywords: image processing,fast,ndarray,data pipelines
 Platform: UNKNOWN
 Classifier: Development Status :: 5 - Production/Stable
@@ -21,6 +21,7 @@ Requires-Python: >=3.6
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: scipy (<2.0.0,>=1.0)
+Requires-Dist: scikit-image
 Requires-Dist: connected-components-3d
 Requires-Dist: fastremap
 Requires-Dist: dataclasses ; python_version < "3.7"
@@ -38,7 +39,9 @@ Requires-Dist: numba ; extra == 'numba'
 
 # Imops
 
-Efficient parallelizable algorithms for multidimensional arrays to speed up your data pipelines. Docs are [here](https://neuro-ml.github.io/imops/).
+Efficient parallelizable algorithms for multidimensional arrays to speed up your data pipelines.
+- [Documentation](https://neuro-ml.github.io/imops/)
+- [Benchmarks](https://neuro-ml.github.io/imops/benchmarks/)
 
 # Install
 
@@ -47,15 +50,33 @@ pip install imops  # default install with Cython backend
 pip install imops[numba]  # additionally install Numba backend
 ```
 
+# How fast is it?
+
+Time comparisons (ms) for Intel(R) Xeon(R) Silver 4114 CPU @ 2.20GHz using 8 threads. All inputs are C-contiguous NumPy arrays. For morphology functions `bool` dtype is used and `float64` for all others.
+| function / backend   |  Scipy()  |  Cython(fast=False)  |  Cython(fast=True)  |  Numba()  |
+|:----------------------:|:-----------:|:----------------------:|:---------------------:|:-----------:|
+| `zoom(..., order=0)` |   2072    |         1114         |         **867**         |   3590    |
+| `zoom(..., order=1)` |   6527    |         596          |         **575**         |   3757    |
+| `interp1d`           |    780    |         149          |         **146**         |    420    |
+| `radon`              |   59711   |         5982         |        **4837**         |      -     |
+| `inverse_radon`      |   52928   |         8254         |        **6535**         |         -  |
+| `binary_dilation`    |   2207    |         310          |         **298**         |        -   |
+| `binary_erosion`     |   2296    |         326          |         **304**         |        -   |
+| `binary_closing`     |   4158    |         544          |         **469**         |        -   |
+| `binary_opening`     |   4410    |         567          |         **522**         |        -   |
+| `center_of_mass`     |   2237    |          **64**          |         **64**          |        -   |
+
+We use [`airspeed velocity`](https://asv.readthedocs.io/en/stable/) to benchmark our code. For detailed results visit [benchmark page](https://neuro-ml.github.io/imops/benchmarks/).
+
 # Features
 
-## Fast Radon transform
+### Fast Radon transform
 
 ```python
 from imops import radon, inverse_radon
 ```
 
-## Fast linear/bilinear/trilinear zoom
+### Fast 0/1-order zoom
 
 ```python
 from imops import zoom, zoom_to_shape
@@ -66,20 +87,20 @@ y = zoom(x, 2, axis=[0, 1])
 # without the need to compute the scale factor
 z = zoom_to_shape(x, (4, 120, 67))
 ```
-Works faster only for `ndim<=3, dtype=float32 or float64, output=None, order=1, mode='constant', grid_mode=False`
-## Fast 1d linear interpolation
+Works faster only for `ndim<=4, dtype=float32 or float64 (and bool-int16-32-64 if order == 0), output=None, order=0 or 1, mode='constant', grid_mode=False`
+### Fast 1d linear interpolation
 
 ```python
 from imops import interp1d  # same as `scipy.interpolate.interp1d`
 ```
-Works faster only for `ndim<=3, dtype=float32 or float64, order=1 or 'linear'`
-## Fast binary morphology
+Works faster only for `ndim<=3, dtype=float32 or float64, order=1`
+### Fast binary morphology
 
 ```python
 from imops import binary_dilation, binary_erosion, binary_opening, binary_closing
 ```
 These functions mimic `scikit-image` counterparts
-## Padding
+### Padding
 
 ```python
 from imops import pad, pad_to_shape
@@ -92,7 +113,7 @@ y = pad(x, 10, axis=[0, 1])
 z = pad_to_shape(x, (4, 120, 67), ratio=0.25)
 ```
 
-## Cropping
+### Cropping
 
 ```python
 from imops import crop_to_shape
@@ -104,7 +125,7 @@ from imops import crop_to_shape
 z = crop_to_shape(x, (4, 120, 67), ratio=0.25)
 ```
 
-## Labeling
+### Labeling
 
 ```python
 from imops import label
@@ -114,7 +135,7 @@ labeled, num_components = label(x, background=1, return_num=True)
 ```
 
 # Backends
-For `zoom`, `zoom_to_shape`, `interp1d`, `radon`, `inverse_radon` you can specify which backend to use. Backend can be specified by a string or by an instance of `Backend` class. The latter allows you to customize some backend options:
+For all heavy image routines except `label` you can specify which backend to use. Backend can be specified by a string or by an instance of `Backend` class. The latter allows you to customize some backend options:
 ```python
 from imops import Cython, Numba, Scipy, zoom
 
@@ -135,10 +156,9 @@ with imops_backend('Cython'):  # sets Cython backend via context manager
 ```
 Note that for `Numba` backend setting `num_threads` argument has no effect for now and you should use `NUMBA_NUM_THREADS` environment variable.
 Available backends:
-|                   | Scipy   | Cython  | Numba   |
-|-------------------|---------|---------|---------|
+|         function / backend            | Scipy   | Cython  | Numba   |
+|:-------------------:|:---------:|:---------:|:---------:|
 | `zoom`            | &check; | &check; | &check; |
-| `zoom_to_shape`   | &check; | &check; | &check; |
 | `interp1d`        | &check; | &check; | &check; |
 | `radon`           | &cross; | &check; | &cross; |
 | `inverse_radon`   | &cross; | &check; | &cross; |
@@ -146,6 +166,7 @@ Available backends:
 | `binary_erosion`  | &check; | &check; | &cross; |
 | `binary_closing`  | &check; | &check; | &cross; |
 | `binary_opening`  | &check; | &check; | &cross; |
+| `center_of_mass`  | &check; | &check; | &cross; |
 
 # Acknowledgements