imops 0.8.8__cp38-cp38-manylinux_2_17_i686.manylinux2014_i686.whl

imops/testing.py

@@ -0,0 +1,57 @@
+import warnings
+
+import numpy as np
+from skimage.transform import iradon as iradon_, radon as radon_
+
+
+def sk_iradon(xs):
+    with warnings.catch_warnings():
+        warnings.filterwarnings('ignore', module='numpy')
+        warnings.simplefilter('ignore', DeprecationWarning)
+        warnings.simplefilter('ignore', np.VisibleDeprecationWarning)
+        return np.stack([iradon_(x) for x in xs])
+
+
+def sk_radon(xs):
+    with warnings.catch_warnings():
+        warnings.filterwarnings('ignore', module='numpy')
+        warnings.simplefilter('ignore', DeprecationWarning)
+        warnings.simplefilter('ignore', np.VisibleDeprecationWarning)
+        warnings.filterwarnings('error', '.*image must be zero.*', module='skimage')
+        return np.stack([radon_(x) for x in xs])
+
+
+def sample_ct(n_slices, size, fill=0):
+    shape = (n_slices, size, size)
+
+    water = np.random.randn(*shape) * 100
+    air = np.random.randn(*shape) * 100 - 1000
+    choice = np.random.binomial(1, 0.5, shape).astype(bool)
+
+    image = choice * water + ~choice * air
+    return fill_outside(image, fill)
+
+
+def fill_outside(x, fill):
+    x = x.copy()
+    size = x.shape[-1]
+    radius = size // 2
+    xpr, ypr = np.mgrid[:size, :size] - radius
+    x[:, (xpr**2 + ypr**2) > radius**2] = fill
+    return x
+
+
+def seeded_by(seed):
+    def wrapper(func):
+        def inner(*args, **kwargs):
+            old_state = np.random.get_state()
+            np.random.seed(seed)
+
+            try:
+                return func(*args, **kwargs)
+            finally:
+                np.random.set_state(old_state)
+
+        return inner
+
+    return wrapper

imops/utils.py

@@ -0,0 +1,205 @@
+import os
+from contextlib import contextmanager
+from itertools import permutations
+from typing import Callable, Optional, Sequence, Tuple, Union
+from warnings import warn
+
+import numpy as np
+
+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 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.',
+                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.',
+                stacklevel=warn_stacklevel,
+            )
+            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]:
+    for permutation in permutations(range(array.ndim)):
+        if np.transpose(array, permutation).data.c_contiguous:
+            return np.array(permutation)
+
+    return None
+
+
+def inverse_permutation(permutation: np.ndarray) -> np.ndarray:
+    inverse_permutation = np.arange(permutation.shape[0])
+    inverse_permutation[permutation] = inverse_permutation.copy()
+
+    return inverse_permutation
+
+
+def axis_from_dim(axis: Union[AxesLike, None], dim: int) -> tuple:
+    if axis is None:
+        return tuple(range(dim))
+
+    return np.core.numeric.normalize_axis_tuple(axis, dim, 'axis')
+
+
+def broadcast_axis(axis: Union[AxesLike, None], dim: int, *values: Union[AxesLike, AxesParams]):
+    axis = axis_from_dim(axis, dim)
+    values = [to_axis(axis, x) for x in values]
+    sizes = set(map(len, values))
+    if not sizes <= {len(axis)}:
+        raise ValueError(f"Params sizes don't match with the axes: {axis} vs {sizes}.")
+
+    return (axis, *values)
+
+
+def to_axis(axis, value):
+    value = np.atleast_1d(value)
+    if len(value) == 1:
+        value = np.repeat(value, len(axis), 0)
+
+    return value
+
+
+def fill_by_indices(target, values, indices):
+    target = np.array(target)
+    target[list(indices)] = values
+
+    return tuple(target)
+
+
+def broadcast_to_axis(axis: AxesLike, *arrays: AxesParams):
+    if not arrays:
+        raise ValueError('No arrays provided.')
+
+    arrays = list(map(np.atleast_1d, arrays))
+    lengths = list(map(len, arrays))
+    if axis is None:
+        raise ValueError('`axis` cannot be None.')
+
+    if not all(len(axis) == x or x == 1 for x in lengths):
+        raise ValueError(f'Axes and arrays are not broadcastable: {len(axis)} vs {", ".join(map(str, lengths))}.')
+
+    return tuple(np.repeat(x, len(axis) // len(x), 0) for x in arrays)
+
+
+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
+    --------
+    ```python
+    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))}')
+
+
+def assert_subdtype(dtype, ref_dtype, name):
+    if not np.issubdtype(dtype, ref_dtype):
+        raise ValueError(f'`{name}` must be of {ref_dtype.__name__} dtype, got {dtype}')

imops/zoom.py

@@ -0,0 +1,297 @@
+from platform import python_version
+from typing import Callable, Sequence, Union
+from warnings import warn
+
+import numpy as np
+from scipy.ndimage import zoom as _scipy_zoom
+
+from .backend import BackendLike, resolve_backend
+from .src._fast_zoom import (
+    _zoom3d_linear as cython_fast_zoom3d_linear,
+    _zoom3d_nearest as cython_fast_zoom3d_nearest,
+    _zoom4d_linear as cython_fast_zoom4d_linear,
+    _zoom4d_nearest as cython_fast_zoom4d_nearest,
+)
+from .src._zoom import (
+    _zoom3d_linear as cython_zoom3d_linear,
+    _zoom3d_nearest as cython_zoom3d_nearest,
+    _zoom4d_linear as cython_zoom4d_linear,
+    _zoom4d_nearest as cython_zoom4d_nearest,
+)
+from .utils import (
+    AxesLike,
+    AxesParams,
+    broadcast_axis,
+    fill_by_indices,
+    get_c_contiguous_permutaion,
+    inverse_permutation,
+    normalize_num_threads,
+)
+
+
+def scipy_zoom(*args, grid_mode, **kwargs):
+    return _scipy_zoom(*args, **kwargs)
+
+
+scipy_zoom = scipy_zoom if python_version()[:3] == '3.6' else _scipy_zoom
+
+
+def _choose_cython_zoom(ndim: int, order: int, fast: bool) -> Callable:
+    assert ndim <= 4, ndim
+    assert order in (0, 1), order
+
+    if ndim <= 3:
+        if order == 0:
+            return cython_fast_zoom3d_nearest if fast else cython_zoom3d_nearest
+
+        return cython_fast_zoom3d_linear if fast else cython_zoom3d_linear
+
+    if order == 0:
+        return cython_fast_zoom4d_nearest if fast else cython_zoom4d_nearest
+
+    return cython_fast_zoom4d_linear if fast else cython_zoom4d_linear
+
+
+def _choose_numba_zoom(ndim: int, order: int) -> Callable:
+    assert ndim <= 4, ndim
+    assert order in (0, 1), order
+
+    if ndim <= 3:
+        if order == 0:
+            from .src._numba_zoom import _zoom3d_nearest as numba_zoom
+        else:
+            from .src._numba_zoom import _zoom3d_linear as numba_zoom
+    elif order == 0:
+        from .src._numba_zoom import _zoom4d_nearest as numba_zoom
+    else:
+        from .src._numba_zoom import _zoom4d_linear as numba_zoom
+
+    return numba_zoom
+
+
+def zoom(
+    x: np.ndarray,
+    scale_factor: AxesParams,
+    axis: AxesLike = None,
+    order: int = 1,
+    fill_value: Union[float, Callable] = 0,
+    num_threads: int = -1,
+    backend: BackendLike = None,
+) -> np.ndarray:
+    """
+    Rescale `x` according to `scale_factor` along the `axis`.
+
+    Uses a fast parallelizable implementation for fp32-fp64 and bool-int16-32-64-uint8-16-32 if order == 0 inputs,
+    ndim <= 4 and order = 0 or 1.
+
+    Parameters
+    ----------
+    x: np.ndarray
+        n-dimensional array
+    scale_factor: AxesParams
+        float or sequence of floats describing how to scale along axes
+    axis: AxesLike
+        axis along which array will be scaled
+    order: int
+        order of interpolation
+    fill_value: float | Callable
+        value to fill past edges. If Callable (e.g. `numpy.min`) - `fill_value(x)` will be used
+    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
+
+    Returns
+    -------
+    zoomed: np.ndarray
+        zoomed array
+
+    Examples
+    --------
+    ```python
+    zoomed = zoom(x, 2, axis=[0, 1])  # 3d array
+    zoomed = zoom(x, [1, 2, 3])  # different scales along each axes
+    zoomed = zoom(x.astype(int))  # will fall back to scipy's implementation because of int dtype
+    ```
+    """
+    x = np.asarray(x)
+    axis, scale_factor = broadcast_axis(axis, x.ndim, scale_factor)
+    scale_factor = fill_by_indices(np.ones(x.ndim, 'float64'), scale_factor, axis)
+
+    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)
+
+
+def zoom_to_shape(
+    x: np.ndarray,
+    shape: AxesLike,
+    axis: AxesLike = None,
+    order: int = 1,
+    fill_value: Union[float, Callable] = 0,
+    num_threads: int = -1,
+    backend: BackendLike = None,
+) -> np.ndarray:
+    """
+    Rescale `x` to match `shape` along the `axis`.
+
+    Uses a fast parallelizable implementation for fp32-fp64 and bool-int16-32-64-uint8-16-32 if order == 0 inputs,
+    ndim <= 4 and order = 0 or 1.
+
+    Parameters
+    ----------
+    x: np.ndarray
+        n-dimensional array
+    shape: AxesLike
+        float or sequence of floats describing desired lengths along axes
+    axis: AxesLike
+        axis along which array will be scaled
+    order: int
+        order of interpolation
+    fill_value: float | Callable
+        value to fill past edges. If Callable (e.g. `numpy.min`) - `fill_value(x)` will be used
+    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
+
+    Returns
+    -------
+    zoomed: np.ndarray
+        zoomed array
+
+    Examples
+    --------
+    ```python
+    zoomed = zoom_to_shape(x, [3, 4, 5])  # 3d array
+    zoomed = zoom_to_shape(x, [6, 7], axis=[1, 2])  # zoom to shape along specified axes
+    zoomed = zoom_to_shape(x.astype(int))  # will fall back to scipy's implementation because of int dtype
+    ```
+    """
+    x = np.asarray(x)
+    axis, shape = broadcast_axis(axis, x.ndim, shape)
+    old_shape = np.array(x.shape, 'float64')
+    new_shape = np.array(fill_by_indices(x.shape, shape, axis), 'float64')
+
+    return zoom(
+        x,
+        new_shape / old_shape,
+        range(x.ndim),
+        order=order,
+        fill_value=fill_value,
+        num_threads=num_threads,
+        backend=backend,
+    )
+
+
+def _zoom(
+    image: np.ndarray,
+    zoom: Sequence[float],
+    output: np.ndarray = None,
+    order: int = 1,
+    mode: str = 'constant',
+    cval: float = 0.0,
+    prefilter: bool = True,
+    *,
+    grid_mode: bool = False,
+    num_threads: int = -1,
+    backend: BackendLike = None,
+) -> np.ndarray:
+    """
+    Faster parallelizable version of `scipy.ndimage.zoom` for fp32-fp64 and bool-int16-32-64-uint8-16-32 if order == 0
+
+    Works faster only for ndim <= 4. Shares interface with `scipy.ndimage.zoom`
+    except for
+    - `num_threads` argument defining how many threads to use (all available threads are used by default).
+    - `backend` argument defining which backend to use. `numba`, `cython` and `scipy` are available,
+        `cython` is used by default.
+
+    See `https://docs.scipy.org/doc/scipy/reference/generated/scipy.ndimage.zoom.html`
+    """
+    backend = resolve_backend(backend, warn_stacklevel=4)
+    if backend.name not in ('Scipy', 'Numba', 'Cython'):
+        raise ValueError(f'Unsupported backend "{backend.name}".')
+
+    ndim = image.ndim
+    dtype = image.dtype
+    cval = np.dtype(dtype).type(cval)
+    zoom = fill_by_indices(np.ones(image.ndim, 'float64'), zoom, range(image.ndim))
+    num_threads = normalize_num_threads(num_threads, backend, warn_stacklevel=4)
+
+    if backend.name == 'Scipy':
+        return scipy_zoom(
+            image, zoom, output=output, order=order, mode=mode, cval=cval, prefilter=prefilter, grid_mode=grid_mode
+        )
+
+    if (
+        (order not in (0, 1))
+        or (
+            dtype not in (np.float32, np.float64)
+            if order == 1
+            else dtype
+            not in (bool, np.float32, np.float64, np.int16, np.int32, np.int64, np.uint8, np.uint16, np.uint32)
+        )
+        or ndim > 4
+        or output is not None
+        or mode != 'constant'
+        or grid_mode
+    ):
+        warn(
+            'Fast zoom is only supported for ndim<=4, dtype=fp32-fp64 and bool-int16-32-64-uint8-16-32 if order == 0, '
+            "output=None, order=0 or 1 , mode='constant', grid_mode=False. Falling back to scipy's implementation.",
+            stacklevel=3,
+        )
+        return scipy_zoom(
+            image, zoom, output=output, order=order, mode=mode, cval=cval, prefilter=prefilter, grid_mode=grid_mode
+        )
+
+    if backend.name == 'Cython':
+        src_zoom = _choose_cython_zoom(ndim, order, backend.fast)
+
+    if backend.name == 'Numba':
+        from numba import get_num_threads, njit, set_num_threads
+
+        old_num_threads = get_num_threads()
+        set_num_threads(num_threads)
+
+        njit_kwargs = {kwarg: getattr(backend, kwarg) for kwarg in backend.__dataclass_fields__.keys()}
+        src_zoom = njit(**njit_kwargs)(_choose_numba_zoom(ndim, order))
+
+    n_dummy = 3 - ndim if ndim <= 3 else 0
+
+    if n_dummy:
+        image = image[(None,) * n_dummy]
+        zoom = [*(1,) * n_dummy, *zoom]
+
+    zoom = np.array(zoom, dtype=np.float64)
+    is_contiguous = image.data.c_contiguous
+    c_contiguous_permutaion = None
+    args = () if backend.name in ('Numba',) else (num_threads,)
+
+    if not is_contiguous:
+        c_contiguous_permutaion = get_c_contiguous_permutaion(image)
+        if c_contiguous_permutaion is not None:
+            out = src_zoom(
+                np.transpose(image, c_contiguous_permutaion),
+                zoom[c_contiguous_permutaion],
+                cval,
+                *args,
+            )
+        else:
+            warn("Input array can't be represented as C-contiguous, performance can drop a lot.", stacklevel=3)
+            out = src_zoom(image, zoom, cval, *args)
+    else:
+        out = src_zoom(image, zoom, cval, *args)
+
+    if c_contiguous_permutaion is not None:
+        out = np.transpose(out, inverse_permutation(c_contiguous_permutaion))
+    if n_dummy:
+        out = out[(0,) * n_dummy]
+    if backend.name == 'Numba':
+        set_num_threads(old_num_threads)
+
+    return out

imops-0.8.8.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 NeuroML
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.