imops 0.8.1__cp38-cp38-win_amd64.whl → 0.8.3__cp38-cp38-win_amd64.whl

imops/src/_zoom.pyx

@@ -17,6 +17,7 @@ from libc.math cimport floor, sqrt
 
 ctypedef cython.floating FLOAT
 ctypedef fused NUM:
+    np.uint8_t
     short
     int
     long long

imops/utils.py

@@ -1,39 +1,92 @@
 import os
+from contextlib import contextmanager
 from itertools import permutations
-from typing import Callable, Optional, Sequence, Union
+from typing import Callable, Optional, Sequence, Tuple, Union
 from warnings import warn
 
 import numpy as np
 
-from .backend import BACKEND2NUM_THREADS_VAR_NAME, SINGLE_THREADED_BACKENDS, Backend
+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 normalize_num_threads(num_threads: int, backend: Backend):
+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.')
+            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.'
+                'Use `NUMBA_NUM_THREADS` environment variable.',
+                stacklevel=warn_stacklevel,
             )
-        return num_threads
-
-    num_threads_var_name = BACKEND2NUM_THREADS_VAR_NAME[backend.name]
-    # here we also handle the case `num_threads_var`=" " gracefully
-    env_num_threads = os.environ.get(num_threads_var_name, '').strip()
-    max_threads = int(env_num_threads) if env_num_threads else len(os.sched_getaffinity(0))
-
-    return max_threads + num_threads + 1
+            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]:
@@ -104,3 +157,50 @@ def composition_args(f: Callable, g: Callable) -> Callable:
         return f(g(*args), *args[1:])
 
     return inner
+
+
+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
+    --------
+    >>> 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))}')

imops/zoom.py

@@ -81,7 +81,7 @@ def zoom(
     """
     Rescale `x` according to `scale_factor` along the `axis`.
 
-    Uses a fast parallelizable implementation for fp32 / fp64 (and int16-32-64 if order == 0) inputs,
+    Uses a fast parallelizable implementation for fp32 / fp64 (and bool-int16-32-64 if order == 0) inputs,
     ndim <= 4 and order = 0 or 1.
 
     Parameters
@@ -120,6 +120,7 @@ def zoom(
     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)
 
 
@@ -135,7 +136,7 @@ def zoom_to_shape(
     """
     Rescale `x` to match `shape` along the `axis`.
 
-    Uses a fast parallelizable implementation for fp32 / fp64 (and int16-32-64 if order == 0) inputs,
+    Uses a fast parallelizable implementation for fp32 / fp64 (and bool-int16-32-64 if order == 0) inputs,
     ndim <= 4 and order = 0 or 1.
 
     Parameters
@@ -197,7 +198,7 @@ def _zoom(
     backend: BackendLike = None,
 ) -> np.ndarray:
     """
-    Faster parallelizable version of `scipy.ndimage.zoom` for fp32 / fp64 (and int16-32-64 if order == 0) inputs.
+    Faster parallelizable version of `scipy.ndimage.zoom` for fp32 / fp64 (and bool-int16-32-64 if order == 0) inputs.
 
     Works faster only for ndim <= 4. Shares interface with `scipy.ndimage.zoom`
     except for
@@ -207,7 +208,7 @@ def _zoom(
 
     See `https://docs.scipy.org/doc/scipy/reference/generated/scipy.ndimage.zoom.html`
     """
-    backend = resolve_backend(backend)
+    backend = resolve_backend(backend, warn_stacklevel=4)
     if backend.name not in ('Scipy', 'Numba', 'Cython'):
         raise ValueError(f'Unsupported backend "{backend.name}".')
 
@@ -215,7 +216,7 @@ def _zoom(
     dtype = input.dtype
     cval = np.dtype(dtype).type(cval)
     zoom = fill_by_indices(np.ones(input.ndim, 'float64'), zoom, range(input.ndim))
-    num_threads = normalize_num_threads(num_threads, backend)
+    num_threads = normalize_num_threads(num_threads, backend, warn_stacklevel=4)
 
     if backend.name == 'Scipy':
         return scipy_zoom(
@@ -227,7 +228,7 @@ def _zoom(
         or (
             dtype not in (np.float32, np.float64)
             if order == 1
-            else dtype not in (np.float32, np.float64, np.int16, np.int32, np.int64)
+            else dtype not in (bool, np.float32, np.float64, np.int16, np.int32, np.int64)
         )
         or ndim > 4
         or output is not None
@@ -235,10 +236,9 @@ def _zoom(
         or grid_mode
     ):
         warn(
-            'Fast zoom is only supported for ndim<=4, dtype=fp32 or fp64 (and int16-32-64 if order == 0), output=None, '
-            "order=0 or 1, mode='constant', grid_mode=False. Falling back to scipy's implementation.",
+            'Fast zoom is only supported for ndim<=4, dtype=fp32 or fp64 (and bool-int16-32-64 if order == 0), '
+            "output=None, order=0 or 1, mode='constant', grid_mode=False. Falling back to scipy's implementation.",
         )
-
         return scipy_zoom(
             input, zoom, output=output, order=order, mode=mode, cval=cval, prefilter=prefilter, grid_mode=grid_mode
         )

{imops-0.8.1.dist-info → imops-0.8.3.dist-info}/METADATA

@@ -1,9 +1,9 @@
 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
-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
 Author: maxme1, vovaf709, talgat
 Author-email: maxme1 <maxs987@gmail.com>, vovaf709 <vovaf709@yandex.ru>, talgat <saparov2130@gmail.com>
 License: MIT License
@@ -44,12 +44,13 @@ Classifier: Programming Language :: Python :: 3.11
 Requires-Python: >=3.6
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: scipy (<2.0.0,>=1.0)
+Requires-Dist: scipy <2.0.0,>=1.0
+Requires-Dist: scikit-image
 Requires-Dist: connected-components-3d
 Requires-Dist: fastremap
 Requires-Dist: dataclasses ; python_version < "3.7"
-Requires-Dist: numpy (<2.0.0,>=1.7) ; python_version < "3.8"
-Requires-Dist: numpy (<2.0.0,>=1.22) ; python_version >= "3.8"
+Requires-Dist: numpy <2.0.0,>=1.7 ; python_version < "3.8"
+Requires-Dist: numpy <2.0.0,>=1.22 ; python_version >= "3.8"
 Provides-Extra: all
 Requires-Dist: numba ; extra == 'all'
 Provides-Extra: numba
@@ -62,7 +63,9 @@ Requires-Dist: numba ; extra == 'numba'
 
 # 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
 
@@ -71,15 +74,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
@@ -90,20 +111,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
@@ -116,7 +137,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
@@ -128,7 +149,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
@@ -138,7 +159,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
 
@@ -159,10 +180,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; |
@@ -170,6 +190,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.dist-info/RECORD

@@ -0,0 +1,60 @@
+_build_utils.py,sha256=bxDoFEVfZgjl-yxMv5a-A7jncCD362m4RTpn5SyRgB4,3262
+imops/__init__.py,sha256=QAqK6FnQnOjdDwSXzhnJNB2ur3cGUNbP3ZdLc_VoIEY,514
+imops/__version__.py,sha256=lPOlZg8rjdgN8DyBl7I1rkzxiXOhafW_7RzlMGnvNo8,23
+imops/_configs.py,sha256=6hBY2O4YSaQC_avvqI-dmhZkPMl4p39KQIPtqx5MAh0,734
+imops/backend.py,sha256=8x6Zq9hetOt9_RDcytNNBJZBLNXgQd7ob2dh4WQuuqM,2598
+imops/box.py,sha256=NbYsPKQ8fCGxSm5up0TyqERJ-5iWmnzHLo4Smv9eesk,1865
+imops/crop.py,sha256=hCgwxDgNdIo9m0gleMB3oOUNA7tQurhYNhE5S39tMlE,4055
+imops/interp1d.py,sha256=CSPJ77isqGOJTN-_C--iyz-3qJhpL4dE9i5VdJgSFDE,8400
+imops/measure.py,sha256=YJ5hBDH6iW1hgqm6fi6FIURBKmeZjVfr7LSINOHgFrM,8657
+imops/morphology.py,sha256=KG3RCCicsX7WHsBj4mH6iaJ0dy6tW9cGJJvD4fDisBQ,12723
+imops/numeric.py,sha256=yiSjPTUD2w177LOBD_39_BHh9n8uKbSsHJDchNVsKRY,13650
+imops/pad.py,sha256=OXy_r4X7hOPBU4NSH3B-8ZpxfcY1t6FFMgMSopULpv8,9314
+imops/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+imops/radon.py,sha256=TWsgZvWRapBbU7MVr1fRdpVXCvi6-kt8fxroyQc44ek,9211
+imops/testing.py,sha256=Qiy_Qn7bd7MIXoaZr4T_6r0jQWVRJFwR2z12c_Zwt30,1708
+imops/utils.py,sha256=nfrMUU0OhPgK5UapD9GNC1StPxX3cKbob54kiuf4_qs,6890
+imops/zoom.py,sha256=wl8wt7yoX5V4Mn7sMefV1Fy9KEetqMEdRHLdhT90o6o,9955
+imops/src/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+imops/src/_backprojection.c,sha256=pq-WMMTwAzP0sRV-nlq_kw3u-1153p7XOHNcJCeE7Ak,1025929
+imops/src/_backprojection.cp38-win_amd64.pyd,sha256=BBCtObthgwgS3pz1IFRpA85poqrAlExEKduoYoEbWkk,167424
+imops/src/_backprojection.pyx,sha256=xngEJtJ6czjoBRBKL6tu5S7nt6ZgcsE82xDGdCIfagE,2724
+imops/src/_fast_backprojection.c,sha256=7ZUD2XghoMmsWlmLq4jdInzY6KJB44sq1suf-HbX-cM,1036419
+imops/src/_fast_backprojection.cp38-win_amd64.pyd,sha256=Lpp9szhOl47XcLGYMIHt5GAPhZI4BkWTzHJAhUENSDo,168448
+imops/src/_fast_backprojection.pyx,sha256=xngEJtJ6czjoBRBKL6tu5S7nt6ZgcsE82xDGdCIfagE,2724
+imops/src/_fast_measure.c,sha256=m0P3agPPDh8-CmPe15skOkAvK3c-jLLBC0mv7J4QpFE,1336697
+imops/src/_fast_measure.cp38-win_amd64.pyd,sha256=rKLhKAIZ8cYw9KbNfN9aMfgZps8JpROyLdtNfJ15l9I,247808
+imops/src/_fast_measure.pyx,sha256=JzZ26PptkVT08OemSFaJakc4jf7xYocPqV8jfrYi_wA,2737
+imops/src/_fast_morphology.c,sha256=MhxKB1_SOQjVnbUrj9SEzP55bSo9LqLSsi3yk3AzaOI,971940
+imops/src/_fast_morphology.cp38-win_amd64.pyd,sha256=40uz8eRvkV1hrgH_vSvWjizF2XZHnxHImtIAY4xGVTw,138752
+imops/src/_fast_morphology.pyx,sha256=QwFrPQ6M-bJDVQNCCtKK7FR3KOr5cZSx_CBvxh9THXM,9538
+imops/src/_fast_numeric.c,sha256=WaEYKryduT3Si92q1T--oOQLnofGIYdbsC5vL71OKm0,2107476
+imops/src/_fast_numeric.cp38-win_amd64.pyd,sha256=1IGaTJSj5z_iuS4zH0fYWlpOKB0jC1rwsykBwKc2KxE,372224
+imops/src/_fast_numeric.pyx,sha256=c8q3KlL8mDe0wsz72ooeqhffk1iqvA0Org7NWW5RbYo,8221
+imops/src/_fast_radon.c,sha256=aeoMDfPqYG6xyeTLH-q7YPuiF7stGCj5v__gIRgmuZY,1190410
+imops/src/_fast_radon.cp38-win_amd64.pyd,sha256=XrqXqMdPUpsq3cMKNBaRqqon2FobNlytALmEISdKsNs,218624
+imops/src/_fast_radon.pyx,sha256=pu8EZplCjIDz9HqBcAit8nj2lDgXpmdhU61_4CfdGWI,2987
+imops/src/_fast_zoom.c,sha256=2nb0GTWAHsrvUPdlf1CRhznPapPMsISPB3WJrLXgUOk,2145404
+imops/src/_fast_zoom.cp38-win_amd64.pyd,sha256=AJx2tNryILkyAbmYqeTTumLv-ptfA-4Ct6MvAg54gfE,384000
+imops/src/_fast_zoom.pyx,sha256=Dd5MDelALAh4-3QhnzfzKTB5Gmi2lVERrbyYj-q8kVQ,23091
+imops/src/_measure.c,sha256=u3o9ozqfWnrn0PxRrY5l7LEvZEEzkfj4JMuTn0MKcSw,1324916
+imops/src/_measure.cp38-win_amd64.pyd,sha256=7NE6k_uIkxrOG54-6s1pr0nJ14XchF67npcLOED8UPk,247296
+imops/src/_measure.pyx,sha256=JzZ26PptkVT08OemSFaJakc4jf7xYocPqV8jfrYi_wA,2737
+imops/src/_morphology.c,sha256=ntlYexi4kFK85mMvUkWSlKMf-Fwix05M18NvVEVyYAQ,960908
+imops/src/_morphology.cp38-win_amd64.pyd,sha256=FrunwBtfVZOXFgwuTAbGDZN2h-xHWpSAuJA3E8VSp_g,138240
+imops/src/_morphology.pyx,sha256=QwFrPQ6M-bJDVQNCCtKK7FR3KOr5cZSx_CBvxh9THXM,9538
+imops/src/_numba_zoom.py,sha256=OmMj7mCFkV2P0FaWVXFuYpfzMBQ3Ks60YiHQURes5wQ,16857
+imops/src/_numeric.c,sha256=pxoAtM5-ZGaBVyWd8HBARI7_LnX6_n7kNt6vS1p_JmI,2091727
+imops/src/_numeric.cp38-win_amd64.pyd,sha256=LQSCiIQMRUUNxvfkAkK6Su5jHp5HHbx8r4X-JHnCyeo,371712
+imops/src/_numeric.pyx,sha256=c8q3KlL8mDe0wsz72ooeqhffk1iqvA0Org7NWW5RbYo,8221
+imops/src/_radon.c,sha256=TdmwLBra4NsH9qtX--0OC6XaTfzN8ApZxDovOC3J9kU,1178982
+imops/src/_radon.cp38-win_amd64.pyd,sha256=M53brb_kxuy2FabVYGDpEYUTfFms9pbv49foklPCfHc,218112
+imops/src/_radon.pyx,sha256=pu8EZplCjIDz9HqBcAit8nj2lDgXpmdhU61_4CfdGWI,2987
+imops/src/_zoom.c,sha256=Yli60QHVVNFUJ2ycnbEW_Hbnz15-tRcG_J_xg_rCL4U,2126517
+imops/src/_zoom.cp38-win_amd64.pyd,sha256=WTUdgTaqX60pZgX-b81SPNNHtcKmhx2uM4Yny7Dv_F8,383488
+imops/src/_zoom.pyx,sha256=Dd5MDelALAh4-3QhnzfzKTB5Gmi2lVERrbyYj-q8kVQ,23091
+imops-0.8.3.dist-info/LICENSE,sha256=x7oyYZPKDTt8KoTitcNJLBWhueke5YEOopdr0XjyvBc,1085
+imops-0.8.3.dist-info/METADATA,sha256=tDl7xwD4lJ6Yx_X7wYRKFuv-_QmBlXMHivDQCOnT_K8,9048
+imops-0.8.3.dist-info/WHEEL,sha256=KplWMgwSZbeAOumvxNxIrVbNPnn_LVzfBH7l38jDCVM,100
+imops-0.8.3.dist-info/top_level.txt,sha256=jd2uO-zsYvKeqkZbjEjtkGqCca0IEXEiEuoyr3nsHB0,19
+imops-0.8.3.dist-info/RECORD,,

{imops-0.8.1.dist-info → imops-0.8.3.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.40.0)
+Generator: bdist_wheel (0.41.2)
 Root-Is-Purelib: false
 Tag: cp38-cp38-win_amd64
 

imops-0.8.3.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+_build_utils
+imops

_pyproject_build.py

@@ -1,49 +0,0 @@
-import shutil
-from pathlib import Path
-
-from setuptools import Extension
-from setuptools.command.build_py import build_py
-
-
-class NumpyImport:
-    def __repr__(self):
-        import numpy as np
-
-        return np.get_include()
-
-    __fspath__ = __repr__
-
-
-class PyprojectBuild(build_py):
-    def run(self):
-        self.run_command('build_ext')
-        return super().run()
-
-    def initialize_options(self):
-        super().initialize_options()
-
-        name = 'imops'
-        args = ['-fopenmp']
-
-        if self.distribution.ext_modules is None:
-            self.distribution.ext_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
-        modules = ['backprojection', 'measure', 'morphology', 'numeric', 'radon', 'zoom']
-        for module in modules:
-            src_dir = Path(__file__).parent / name / 'src'
-            shutil.copyfile(src_dir / f'_{module}.pyx', src_dir / f'_fast_{module}.pyx')
-
-        for module in modules:
-            for prefix, additional_args in zip(['', 'fast_'], [[], ['-ffast-math']]):
-                self.distribution.ext_modules.append(
-                    Extension(
-                        f'{name}.src._{prefix}{module}',
-                        [f'{name}/src/_{prefix}{module}.pyx'],
-                        include_dirs=[NumpyImport()],
-                        extra_compile_args=args + additional_args,
-                        extra_link_args=args + additional_args,
-                        define_macros=[('NPY_NO_DEPRECATED_API', 'NPY_1_7_API_VERSION')],
-                    )
-                )

imops/_numeric.py

@@ -1,124 +0,0 @@
-from warnings import warn
-
-import numpy as np
-
-from .backend import BackendLike, resolve_backend
-from .src._fast_numeric import (
-    _parallel_pointwise_mul as cython_fast_parallel_pointwise_mul,
-    _parallel_sum as cython_fast_parallel_sum,
-)
-from .src._numeric import _parallel_pointwise_mul as cython_parallel_pointwise_mul, _parallel_sum as cython_parallel_sum
-from .utils import normalize_num_threads
-
-
-def _sum(nums: np.ndarray, num_threads: int = -1, backend: BackendLike = None) -> float:
-    """
-    Parallel sum of flat numpy array
-
-    Parameters
-    ----------
-    nums: np.ndarray
-        1-dimensional array
-    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. `cython` and `scipy` (primarly for benchmarking) are available,
-        `cython` is used by default
-
-    Returns
-    -------
-    sum: float
-
-    Examples
-    --------
-    >>> s = _sum(x, num_threads=1)
-    >>> s = _sum(x, num_threads=8, backend=Cython(fast=True))  # ffast-math compiled version
-    """
-    ndim = nums.ndim
-
-    if ndim != 1:
-        raise ValueError(f'Input must be 1-dimensional instead of {ndim}-dimensional.')
-
-    backend = resolve_backend(backend)
-    if backend.name not in ('Cython', 'Scipy'):
-        raise ValueError(f'Unsupported backend "{backend.name}"')
-
-    num_threads = normalize_num_threads(num_threads, backend)
-
-    if backend.name == 'Scipy':
-        return nums.sum()
-
-    if backend.name == 'Cython':
-        src_parallel_sum = cython_fast_parallel_sum if backend.fast else cython_parallel_sum
-
-    return src_parallel_sum(nums, num_threads)
-
-
-def _mul(nums1: np.ndarray, nums2: np.ndarray, num_threads: int = -1, backend: BackendLike = None) -> np.ndarray:
-    """
-    Parallel pointwise multiplication of 2 numpy arrays (aka x * y). Works faster only for ndim <= 3.
-
-    Parameters
-    ----------
-    nums1: np.ndarray
-    nums2: np.ndarray
-    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. `cython` and `scipy` (primarly for benchmarking) are available,
-        `cython` is used by default
-
-    Returns
-    -------
-    multiplied: np.ndarray
-        result of nums1 * nums2
-
-    Examples
-    --------
-    >>> mul = _mul(nums1, nums2, num_threads=8)
-    >>> mul = _mul(np.ones((2, 3)), np.ones((1, 3)))  # broadcasting, mul.shape == (2, 3)
-    >>> mul = _mul(nums1, nums2, backend=Cython(fast=True))  # ffast-math compiled version
-    """
-    if not nums1.size and not nums2.size:
-        return np.array([], dtype=nums1.dtype)
-    if bool(nums1.size) ^ bool(nums2.size):
-        raise ValueError('One of the arrays is empty, hence pointwise multiplication cannot be performed.')
-    if len(nums1.shape) != len(nums2.shape):
-        raise ValueError('Both arrays must have the same number of dimensions for pointwise multiplication.')
-    for dim1, dim2 in zip(nums1.shape, nums2.shape):
-        if dim1 != dim2 and dim1 != 1 and dim2 != 1:
-            raise ValueError(f'Arrays of shapes {nums1.shape} and {nums2.shape} are not broadcastable.')
-
-    if nums1.ndim > 3:
-        warn('Parallel pointwise multiplication is only supported for ndim<=3. Falling back to naive x * y.')
-
-        return nums1 * nums2
-
-    backend = resolve_backend(backend)
-    if backend.name not in ('Cython', 'Scipy'):
-        raise ValueError(f'Unsupported backend "{backend.name}"')
-
-    num_threads = normalize_num_threads(num_threads, backend)
-
-    if backend.name == 'Scipy':
-        return nums1 * nums2
-
-    if backend.name == 'Cython':
-        src_parallel_pointwise_mul = (
-            cython_fast_parallel_pointwise_mul if backend.fast else cython_parallel_pointwise_mul
-        )
-
-    n_dummy = 3 - nums1.ndim
-
-    if n_dummy:
-        nums1 = nums1[(None,) * n_dummy]
-        nums2 = nums2[(None,) * n_dummy]
-
-    out = src_parallel_pointwise_mul(nums1, nums2, np.maximum(nums1.shape, nums2.shape), num_threads)
-
-    if n_dummy:
-        out = out[(0,) * n_dummy]
-
-    return out