imops 0.8.2__cp38-cp38-win_amd64.whl → 0.8.3__cp38-cp38-win_amd64.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.2'
+__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/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,6 +89,7 @@ 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:
@@ -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)

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,7 +90,7 @@ 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
         )
@@ -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<=3. 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:
@@ -205,7 +205,7 @@ def center_of_mass(
             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
 

imops/morphology.py

@@ -28,12 +28,12 @@ def morphology_op_wrapper(
         num_threads: int = -1,
         backend: BackendLike = None,
     ) -> np.ndarray:
-        backend = resolve_backend(backend)
+        backend = resolve_backend(backend, warn_stacklevel=4)
         if backend.name not in {x.name for x in backend2src_op.keys()}:
             raise ValueError(f'Unsupported backend "{backend.name}".')
 
         ndim = image.ndim
-        num_threads = normalize_num_threads(num_threads, backend)
+        num_threads = normalize_num_threads(num_threads, backend, warn_stacklevel=4)
 
         if footprint is None:
             footprint = generate_binary_structure(ndim, 1)
@@ -60,7 +60,8 @@ def morphology_op_wrapper(
         if ndim > 3:
             warn(
                 f"Fast {' '.join(op_name.split('_'))} is only supported for ndim<=3. "
-                "Falling back to scipy's implementation."
+                "Falling back to scipy's implementation.",
+                stacklevel=3,
             )
             output = backend2src_op[Scipy()](image, footprint)
 
@@ -70,13 +71,13 @@ def morphology_op_wrapper(
             raise ValueError('Input image and footprint number of dimensions must be the same.')
 
         if not image.any():
-            warn(f'{op_name} is applied to the fully False mask (mask.any() == False).')
+            warn(f'{op_name} is applied to the fully False mask (mask.any() == False).', stacklevel=3)
             output.fill(False)
 
             return output
 
         if image.all():
-            warn(f'{op_name} is applied to the fully True mask (mask.all() == True).')
+            warn(f'{op_name} is applied to the fully True mask (mask.all() == True).', stacklevel=3)
             output.fill(True)
 
             return output