imops 0.8.1__cp310-cp310-win32.whl → 0.8.3__cp310-cp310-win32.whl

_build_utils.py

@@ -0,0 +1,87 @@
+import platform
+import shutil
+from pathlib import Path
+
+from setuptools import Extension
+from setuptools.command.build_py import build_py
+
+
+class NumpyImport(dict):
+    """Hacky way to return Numpy's `include` path with lazy import."""
+
+    # Must be json-serializable due to
+    # https://github.com/cython/cython/blob/6ad6ca0e9e7d030354b7fe7d7b56c3f6e6a4bc23/Cython/Compiler/ModuleNode.py#L773
+    def __init__(self):
+        return super().__init__(self, description=self.__doc__)
+
+    # Must be hashable due to
+    # https://github.com/cython/cython/blob/6ad6ca0e9e7d030354b7fe7d7b56c3f6e6a4bc23/Cython/Compiler/Main.py#L307
+    def __hash__(self):
+        return id(self)
+
+    def __repr__(self):
+        import numpy as np
+
+        return np.get_include()
+
+    __fspath__ = __repr__
+
+
+class NumpyLibImport(str):
+    """Hacky way to return Numpy's `lib` path with lazy import."""
+
+    # Exploit of https://github.com/pypa/setuptools/blob/1ef36f2d336e239bd8f83507cb9447e060b6ed60/setuptools/_distutils/
+    # unixccompiler.py#L276-L277
+    def __radd__(self, left):
+        import numpy as np
+
+        return left + str(Path(np.get_include()).parent / 'lib')
+
+    def __hash__(self):
+        return id(self)
+
+
+class PyprojectBuild(build_py):
+    def run(self):
+        self.run_command('build_ext')
+        return super().run()
+
+    def initialize_options(self):
+        super().initialize_options()
+
+        self.distribution.ext_modules = get_ext_modules()
+
+
+def get_ext_modules():
+    name = 'imops'
+    on_windows = platform.system() == 'Windows'
+    args = ['/openmp' if on_windows else '-fopenmp']
+
+    # Cython extension and .pyx source file names must be the same to compile
+    # https://stackoverflow.com/questions/8024805/cython-compiled-c-extension-importerror-dynamic-module-does-not-define-init-fu
+    modules = ['backprojection', 'measure', 'morphology', 'numeric', 'radon', 'zoom']
+    modules_to_link_against_numpy_core_math_lib = ['numeric']
+
+    for module in modules:
+        src_dir = Path(__file__).parent / name / 'src'
+        shutil.copyfile(src_dir / f'_{module}.pyx', src_dir / f'_fast_{module}.pyx')
+
+    return [
+        Extension(
+            f'{name}.src._{prefix}{module}',
+            [f'{name}/src/_{prefix}{module}.pyx'],
+            include_dirs=[NumpyImport()],
+            library_dirs=[NumpyLibImport()] if module in modules_to_link_against_numpy_core_math_lib else [],
+            libraries=['npymath'] + ['m'] * (not on_windows)
+            if module in modules_to_link_against_numpy_core_math_lib
+            else [],
+            extra_compile_args=args + additional_args,
+            extra_link_args=args + additional_args,
+            define_macros=[('NPY_NO_DEPRECATED_API', 'NPY_1_7_API_VERSION')],
+        )
+        for module in modules
+        # FIXME: import of `ffast-math` compiled modules changes global FPU state, so now `fast=True` will just
+        # fallback to standard `-O2` compiled versions until https://github.com/neuro-ml/imops/issues/37 is resolved
+        # for prefix, additional_args in zip(['', 'fast_'], [[], ['-ffast-math']])
+        for prefix, additional_args in zip(['', 'fast_'], [[], []])
+    ]

imops/__init__.py

@@ -4,6 +4,7 @@ from .crop import crop_to_box, crop_to_shape
 from .interp1d import interp1d
 from .measure import label
 from .morphology import binary_closing, binary_dilation, binary_erosion, binary_opening
+from .numeric import copy, fill_, full, pointwise_add
 from .pad import pad, pad_to_divisible, pad_to_shape, restore_crop
 from .radon import inverse_radon, radon
 from .zoom import _zoom, zoom, zoom_to_shape

imops/__version__.py

@@ -1 +1 @@
-__version__ = '0.8.1'
+__version__ = '0.8.3'

imops/backend.py

@@ -1,14 +1,15 @@
-import contextlib
+from contextlib import contextmanager
 from dataclasses import dataclass
 from typing import Dict, Type, Union
+from warnings import warn
 
 
 class Backend:
     def __init_subclass__(cls, **kwargs):
         name = cls.__name__
-        if name in AVAILABLE_BACKENDS:
+        if name in _AVAILABLE_BACKENDS:
             raise ValueError(f'The name "{name}" is already in use.')
-        AVAILABLE_BACKENDS[name] = cls
+        _AVAILABLE_BACKENDS[name] = cls
         if not hasattr(Backend, name):
             setattr(Backend, name, cls)
 
@@ -22,18 +23,18 @@ class Backend:
 
 
 BackendLike = Union[str, Backend, Type[Backend], None]
-AVAILABLE_BACKENDS: Dict[str, Type[Backend]] = {}
+_AVAILABLE_BACKENDS: Dict[str, Type[Backend]] = {}
 
 
-def resolve_backend(value: BackendLike) -> Backend:
+def resolve_backend(value: BackendLike, warn_stacklevel: int = 1) -> Backend:
     if value is None:
         return DEFAULT_BACKEND
 
     if isinstance(value, str):
-        if value not in AVAILABLE_BACKENDS:
-            raise ValueError(f'"{value}" is not in the list of available backends: {tuple(AVAILABLE_BACKENDS)}.')
+        if value not in _AVAILABLE_BACKENDS:
+            raise ValueError(f'"{value}" is not in the list of available backends: {tuple(_AVAILABLE_BACKENDS)}.')
 
-        return AVAILABLE_BACKENDS[value]()
+        return _AVAILABLE_BACKENDS[value]()
 
     if isinstance(value, type):
         value = value()
@@ -41,6 +42,9 @@ def resolve_backend(value: BackendLike) -> Backend:
     if not isinstance(value, Backend):
         raise ValueError(f'Expected a `Backend` instance, got {value}.')
 
+    if isinstance(value, Cython) and value.fast:
+        warn('`fast=True` has no effect for `Cython` backend for now.', stacklevel=warn_stacklevel)
+
     return value
 
 
@@ -51,7 +55,7 @@ def set_backend(backend: BackendLike) -> Backend:
     return current
 
 
-@contextlib.contextmanager
+@contextmanager
 def imops_backend(backend: BackendLike):
     previous = set_backend(backend)
     try:
@@ -87,5 +91,5 @@ class Scipy(Backend):
 
 DEFAULT_BACKEND = Cython()
 
-BACKEND2NUM_THREADS_VAR_NAME = {Cython.__name__: 'OMP_NUM_THREADS', Numba.__name__: 'NUMBA_NUM_THREADS'}
+BACKEND_NAME2ENV_NUM_THREADS_VAR_NAME = {Cython.__name__: 'OMP_NUM_THREADS', Numba.__name__: 'NUMBA_NUM_THREADS'}
 SINGLE_THREADED_BACKENDS = (Scipy.__name__,)

imops/box.py

@@ -1,7 +1,7 @@
 import itertools
 from copy import copy
 from functools import wraps
-from typing import Callable, Sequence, Tuple
+from typing import Callable, Tuple
 
 import numpy as np
 
@@ -10,34 +10,6 @@ import numpy as np
 Box = np.ndarray
 
 
-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 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]))
-    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 make_box(iterable) -> Box:
     """Returns a box, generated from copy of the `iterable`."""
     box = np.asarray(copy(iterable))
@@ -78,3 +50,22 @@ def mask_to_box(mask: np.ndarray) -> Box:
         stop.insert(0, right + 1)
 
     return start, stop
+
+
+@returns_box
+def shape_to_box(shape: Tuple) -> Box:
+    return make_box([(0,) * len(shape), shape])  # fmt: skip
+
+
+def box_to_shape(box: Box) -> Tuple:
+    return tuple(box[1] - box[0])
+
+
+@returns_box
+def add_margin(box: Box, margin) -> Box:
+    """
+    Returns a box with size increased by the ``margin`` (need to be broadcastable to the box)
+    compared to the input ``box``.
+    """
+    margin = np.broadcast_to(margin, box.shape)
+    return box[0] - margin[0], box[1] + margin[1]

imops/crop.py

@@ -1,5 +1,7 @@
 import numpy as np
 
+from .backend import BackendLike
+from .numeric import _NUMERIC_DEFAULT_NUM_THREADS
 from .pad import pad
 from .utils import AxesLike, AxesParams, broadcast_axis, fill_by_indices
 
@@ -43,10 +45,18 @@ def crop_to_shape(x: np.ndarray, shape: AxesLike, axis: AxesLike = None, ratio:
     ratio = fill_by_indices(np.zeros(ndim), ratio, axis)
     start = ((old_shape - new_shape) * ratio).astype(int)
 
+    # TODO: Create contiguous array?
     return x[tuple(map(slice, start, start + new_shape))]
 
 
-def crop_to_box(x: np.ndarray, box: np.ndarray, axis: AxesLike = None, padding_values: AxesParams = None) -> np.ndarray:
+def crop_to_box(
+    x: np.ndarray,
+    box: np.ndarray,
+    axis: AxesLike = None,
+    padding_values: AxesParams = None,
+    num_threads: int = _NUMERIC_DEFAULT_NUM_THREADS,
+    backend: BackendLike = None,
+) -> np.ndarray:
     """
     Crop `x` according to `box` along `axis`.
 
@@ -60,6 +70,11 @@ def crop_to_box(x: np.ndarray, box: np.ndarray, axis: AxesLike = None, padding_v
         axis along which `x` will be cropped
     padding_values: AxesParams
         values to pad with if box exceeds the input's limits
+    num_threads: int
+        the number of threads to use for computation. Default = 4. If negative value passed
+        cpu count + num_threads + 1 threads will be used
+    backend: BackendLike
+        which backend to use. `cython` and `scipy` are available, `cython` is used by default
 
     Returns
     -------
@@ -86,9 +101,10 @@ def crop_to_box(x: np.ndarray, box: np.ndarray, axis: AxesLike = None, padding_v
 
     slice_start = fill_by_indices(np.zeros(x.ndim, int), slice_start, axis)
     slice_stop = fill_by_indices(x.shape, slice_stop, axis)
+    # TODO: Create contiguous array?
     x = x[tuple(map(slice, slice_start, slice_stop))]
 
     if padding_values is not None and padding.any():
-        x = pad(x, padding, axis, padding_values)
+        x = pad(x, padding, axis, padding_values, num_threads=num_threads, backend=backend)
 
     return x

imops/interp1d.py

@@ -5,6 +5,7 @@ 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
@@ -74,7 +75,7 @@ class interp1d:
         num_threads: int = -1,
         backend: BackendLike = None,
     ) -> None:
-        backend = resolve_backend(backend)
+        backend = resolve_backend(backend, warn_stacklevel=3)
         if backend.name not in ('Scipy', 'Numba', 'Cython'):
             raise ValueError(f'Unsupported backend "{backend.name}".')
 
@@ -88,13 +89,19 @@ class interp1d:
             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 len(y) < 2:
+            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':
@@ -102,11 +109,6 @@ class interp1d:
             else:
                 self.bounds_error = True if bounds_error is None else bounds_error
 
-            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]}.'
-                )
-
             self.axis = axis
 
             if axis not in (-1, y.ndim - 1):
@@ -114,12 +116,13 @@ class interp1d:
 
             self.fill_value = fill_value
             self.scipy_interp1d = None
-            self.x = np.copy(x) if copy else x
+            # 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 = np.copy(self.y)
+                self.y = _copy(self.y, order='C')
 
             self.assume_sorted = assume_sorted
 
@@ -149,7 +152,7 @@ class interp1d:
             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)
+        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)
@@ -165,8 +168,8 @@ class interp1d:
         # 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),
-            x_new.astype(np.float64),
+            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,
@@ -177,7 +180,7 @@ class interp1d:
         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))
+        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]

imops/measure.py

@@ -19,7 +19,7 @@ from .utils import normalize_num_threads
 
 
 # (ndim, skimage_connectivity) -> cc3d_connectivity
-skimage2cc3d = {
+_SKIMAGE2CC3D = {
     (1, 1): 4,
     (2, 1): 4,
     (2, 2): 8,
@@ -90,12 +90,12 @@ def label(
         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.")
+        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)
+            labeled_image = labeled_image.astype(dtype, copy=False)
     else:
         if ndim == 1:
             label_image = label_image[None]
@@ -110,7 +110,7 @@ def label(
 
         labeled_image, num_components = connected_components(
             label_image,
-            connectivity=skimage2cc3d[(ndim, connectivity)],
+            connectivity=_SKIMAGE2CC3D[(ndim, connectivity)],
             return_N=True,
             **{'out_dtype': dtype} if python_version()[:3] != '3.6' else {},
         )
@@ -174,19 +174,19 @@ def center_of_mass(
     if (labels is None) ^ (index is None):
         raise ValueError('`labels` and `index` should be both specified or both not specified.')
 
-    backend = resolve_backend(backend)
+    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)
+    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<=4. Falling back to scipy's implementation.")
+        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:
@@ -195,14 +195,17 @@ def center_of_mass(
         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))):
+        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.')
+            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