imops 0.8.1__tar.gz → 0.8.3__tar.gz

{imops-0.8.1 → imops-0.8.3}/MANIFEST.in

@@ -1,5 +1,5 @@
 include *.md
 include requirements.txt
 include pyproject.toml
-include _pyproject_build.py
+include _build_utils.py
 recursive-include imops *.py

{imops-0.8.1/imops.egg-info → imops-0.8.3}/PKG-INFO

@@ -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
@@ -30,7 +30,9 @@ License-File: LICENSE
 
 # 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
 
@@ -39,15 +41,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
@@ -58,20 +78,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
@@ -84,7 +104,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
@@ -96,7 +116,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
@@ -106,7 +126,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
 
@@ -127,10 +147,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; |
@@ -138,6 +157,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
 

{imops-0.8.1 → imops-0.8.3}/README.md

@@ -5,7 +5,9 @@
 
 # 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
 
@@ -14,15 +16,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
@@ -33,20 +53,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
@@ -59,7 +79,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
@@ -71,7 +91,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
@@ -81,7 +101,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
 
@@ -102,10 +122,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; |
@@ -113,6 +132,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
 

imops-0.8.3/_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-0.8.1 → imops-0.8.3}/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-0.8.3/imops/__version__.py

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

{imops-0.8.1 → imops-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-0.8.1 → imops-0.8.3}/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-0.8.1 → imops-0.8.3}/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-0.8.1 → imops-0.8.3}/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]