imops 0.8.8__cp38-cp38-manylinux_2_17_i686.manylinux2014_i686.whl

_build_utils.py

@@ -0,0 +1,113 @@
+import platform
+import shutil
+from pathlib import Path
+
+from setuptools import Extension
+from setuptools.command.build_py import build_py
+
+
+class LazyImport(dict):
+    """Hacky way to return any module'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, module_name):
+        self.module_name = module_name
+        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):
+        scope = {}
+        exec(f'import {self.module_name} as module', scope)
+
+        return scope['module'].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']
+    cpp_args = [
+        '/std:c++20' if on_windows else '-std=c++2a',
+        '/O3' if on_windows else '-O3',
+    ]  # FIXME: account for higher gcc versions
+
+    modules = ['backprojection', 'measure', 'morphology', 'numeric', 'radon', 'zoom']
+    modules_to_link_against_numpy_core_math_lib = ['numeric']
+
+    src_dir = Path(__file__).parent / name / 'src'
+    for module in modules:
+        # 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
+        shutil.copyfile(src_dir / f'_{module}.pyx', src_dir / f'_fast_{module}.pyx')
+
+    extensions = [
+        Extension(
+            f'{name}.cpp.cpp_modules',
+            [f'{name}/cpp/main.cpp'],
+            include_dirs=[LazyImport('pybind11')],
+            extra_compile_args=args + cpp_args,
+            extra_link_args=args + cpp_args,
+            language='c++',
+        )
+    ]
+    for module in modules:
+        libraries = []
+        library_dirs = []
+        include_dirs = [LazyImport('numpy')]
+
+        if module in modules_to_link_against_numpy_core_math_lib:
+            library_dirs.append(NumpyLibImport())
+            libraries.append('npymath')
+            if not on_windows:
+                libraries.append('m')
+
+        # 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_'], [[], []]):
+            extensions.append(
+                Extension(
+                    f'{name}.src._{prefix}{module}',
+                    [f'{name}/src/_{prefix}{module}.pyx'],
+                    include_dirs=include_dirs,
+                    library_dirs=library_dirs,
+                    libraries=libraries,
+                    extra_compile_args=args + additional_args,
+                    extra_link_args=args + additional_args,
+                    define_macros=[('NPY_NO_DEPRECATED_API', 'NPY_1_7_API_VERSION')],
+                )
+            )
+
+    return extensions

imops/__init__.py

@@ -0,0 +1,10 @@
+from .__version__ import __version__
+from .backend import Cython, Numba, Scipy, imops_backend, set_backend
+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

@@ -0,0 +1 @@
+__version__ = '0.8.8'

imops/_configs.py

@@ -0,0 +1,29 @@
+from itertools import product
+
+from .backend import Cython, Numba, Scipy
+
+
+scipy_configs = [Scipy()]
+radon_configs = [Cython(fast) for fast in [False, True]]
+numeric_configs = [
+    Scipy(),
+    *[Cython(fast) for fast in [False, True]],
+]
+measure_configs = [
+    Scipy(),
+    *[Cython(fast) for fast in [False, True]],
+]
+morphology_configs = [
+    Scipy(),
+    *[Cython(fast) for fast in [False, True]],
+]
+zoom_configs = [
+    Scipy(),
+    *[Cython(fast) for fast in [False, True]],
+    *[Numba(*flags) for flags in product([False, True], repeat=3)],
+]
+interp1d_configs = [
+    Scipy(),
+    *[Cython(fast) for fast in [False, True]],
+    *[Numba(*flags) for flags in product([False, True], repeat=3)],
+]

imops/backend.py

@@ -0,0 +1,95 @@
+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:
+            raise ValueError(f'The name "{name}" is already in use.')
+        _AVAILABLE_BACKENDS[name] = cls
+        if not hasattr(Backend, name):
+            setattr(Backend, name, cls)
+
+    @property
+    def name(self):
+        return type(self).__name__
+
+    Cython: 'Cython'
+    Numba: 'Numba'
+    Scipy: 'Scipy'
+
+
+BackendLike = Union[str, Backend, Type[Backend], None]
+_AVAILABLE_BACKENDS: Dict[str, Type[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)}.')
+
+        return _AVAILABLE_BACKENDS[value]()
+
+    if isinstance(value, type):
+        value = value()
+
+    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
+
+
+def set_backend(backend: BackendLike) -> Backend:
+    global DEFAULT_BACKEND
+    current = DEFAULT_BACKEND
+    DEFAULT_BACKEND = resolve_backend(backend)
+    return current
+
+
+@contextmanager
+def imops_backend(backend: BackendLike):
+    previous = set_backend(backend)
+    try:
+        yield
+    finally:
+        set_backend(previous)
+
+
+# implementations
+# TODO: Investigate whether it is safe to use -ffast-math in numba
+@dataclass(frozen=True)
+class Numba(Backend):
+    parallel: bool = True
+    nogil: bool = True
+    cache: bool = True
+
+    def __post_init__(self):
+        try:
+            import numba  # noqa: F401
+        except ModuleNotFoundError:  # pragma: no cover
+            raise ModuleNotFoundError('Install `numba` package (pip install numba) to use "numba" backend.')
+
+
+@dataclass(frozen=True)
+class Cython(Backend):
+    fast: bool = False
+
+
+@dataclass(frozen=True)
+class Scipy(Backend):
+    pass
+
+
+DEFAULT_BACKEND = Cython()
+
+BACKEND_NAME2ENV_NUM_THREADS_VAR_NAME = {Cython.__name__: 'OMP_NUM_THREADS', Numba.__name__: 'NUMBA_NUM_THREADS'}
+SINGLE_THREADED_BACKENDS = (Scipy.__name__,)

imops/box.py

@@ -0,0 +1,74 @@
+import itertools
+from copy import copy
+from functools import wraps
+from typing import Callable, Tuple
+
+import numpy as np
+
+# for backward compatibility
+from .utils import build_slices  # noqa: F401
+
+
+# Immutable numpy array
+Box = np.ndarray
+
+
+def make_box(iterable) -> Box:
+    """Returns a box, generated from copy of the `iterable`."""
+    box = np.asarray(copy(iterable))
+    box.setflags(write=False)
+
+    assert box.ndim == 2 and len(box) == 2, box.shape
+    assert np.all(box[0] <= box[1]), box
+
+    return box
+
+
+def returns_box(func: Callable) -> Callable:
+    """Returns function, decorated so that it returns a box."""
+
+    @wraps(func)
+    def func_returning_box(*args, **kwargs):
+        return make_box(func(*args, **kwargs))
+
+    func_returning_box.__annotations__['return'] = Box
+
+    return func_returning_box
+
+
+@returns_box
+def mask_to_box(mask: np.ndarray) -> Box:
+    """Find the smallest box that contains all true values of the `mask`."""
+    if not mask.any():
+        raise ValueError('The mask is empty.')
+
+    start, stop = [], []
+    for ax in itertools.combinations(range(mask.ndim), mask.ndim - 1):
+        nonzero = np.any(mask, axis=ax)
+        if np.any(nonzero):
+            left, right = np.where(nonzero)[0][[0, -1]]
+        else:
+            left, right = 0, 0
+        start.insert(0, left)
+        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/cpp/interp2d/delaunator/delaunator-header-only.hpp

@@ -0,0 +1,33 @@
+// MIT License
+
+// Copyright (c) 2018 Volodymyr Bilonenko
+
+// 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.
+
+
+
+#pragma once
+
+#define DELAUNATOR_HEADER_ONLY
+
+#include "delaunator.hpp"
+
+#include "delaunator.cpp"
+
+#undef DELAUNATOR_HEADER_ONLY