imops 0.8.2__cp36-cp36m-win_amd64.whl → 0.8.3__cp36-cp36m-win_amd64.whl

imops/pad.py

@@ -2,6 +2,8 @@ from typing import Callable, Sequence, Union
 
 import numpy as np
 
+from .backend import BackendLike
+from .numeric import _NUMERIC_DEFAULT_NUM_THREADS, copy
 from .utils import AxesLike, AxesParams, axis_from_dim, broadcast_axis, broadcast_to_axis, fill_by_indices
 
 
@@ -10,6 +12,8 @@ def pad(
     padding: Union[AxesLike, Sequence[Sequence[int]]],
     axis: AxesLike = None,
     padding_values: Union[AxesParams, Callable] = 0,
+    num_threads: int = _NUMERIC_DEFAULT_NUM_THREADS,
+    backend: BackendLike = None,
 ) -> np.ndarray:
     """
     Pad `x` according to `padding` along the `axis`.
@@ -28,6 +32,11 @@ def pad(
     padding_values: Union[AxesParams, Callable]
         values to pad with, must be broadcastable to the resulting array.
         If Callable (e.g. `numpy.min`) - `padding_values(x)` will be used
+    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
     -------
@@ -52,10 +61,11 @@ def pad(
 
     new_shape = np.array(x.shape) + np.sum(padding, axis=1)
     new_x = np.array(padding_values, dtype=x.dtype)
-    new_x = np.broadcast_to(new_x, new_shape).copy()
+    new_x = copy(np.broadcast_to(new_x, new_shape), order='C', num_threads=num_threads, backend=backend)
 
     start = padding[:, 0]
     end = np.where(padding[:, 1] != 0, -padding[:, 1], None)
+    # TODO: how to parallelize this?
     new_x[tuple(map(slice, start, end))] = x
 
     return new_x
@@ -67,6 +77,8 @@ def pad_to_shape(
     axis: AxesLike = None,
     padding_values: Union[AxesParams, Callable] = 0,
     ratio: AxesParams = 0.5,
+    num_threads: int = _NUMERIC_DEFAULT_NUM_THREADS,
+    backend: BackendLike = None,
 ) -> np.ndarray:
     """
     Pad `x` to match `shape` along the `axis`.
@@ -85,6 +97,11 @@ def pad_to_shape(
     ratio: AxesParams
         float or sequence of floats describing what proportion of padding to apply on the left sides of padding axes.
         Remaining ratio of padding will be applied on the right sides
+    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
     -------
@@ -108,7 +125,7 @@ def pad_to_shape(
     start = (delta * ratio).astype(int)
     padding = np.array((start, delta - start)).T.astype(int)
 
-    return pad(x, padding, axis, padding_values=padding_values)
+    return pad(x, padding, axis, padding_values=padding_values, num_threads=num_threads, backend=backend)
 
 
 def pad_to_divisible(
@@ -118,6 +135,8 @@ def pad_to_divisible(
     padding_values: Union[AxesParams, Callable] = 0,
     ratio: AxesParams = 0.5,
     remainder: AxesLike = 0,
+    num_threads: int = _NUMERIC_DEFAULT_NUM_THREADS,
+    backend: BackendLike = None,
 ) -> np.ndarray:
     """
     Pad `x` to be divisible by `divisor` along the `axis`.
@@ -137,6 +156,11 @@ def pad_to_divisible(
         Remaining ratio of padding will be applied on the right sides
     remainder: AxesLike
         `x` will be padded such that its shape gives the remainder `remainder` when divided by `divisor`
+    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
     -------
@@ -157,11 +181,18 @@ def pad_to_divisible(
     assert np.all(remainder >= 0)
     shape = np.maximum(np.array(x.shape)[list(axis)], remainder)
 
-    return pad_to_shape(x, shape + (remainder - shape) % divisor, axis, padding_values, ratio)
+    return pad_to_shape(
+        x, shape + (remainder - shape) % divisor, axis, padding_values, ratio, num_threads=num_threads, backend=backend
+    )
 
 
 def restore_crop(
-    x: np.ndarray, box: np.ndarray, shape: AxesLike, padding_values: Union[AxesParams, Callable] = 0
+    x: np.ndarray,
+    box: np.ndarray,
+    shape: AxesLike,
+    padding_values: Union[AxesParams, Callable] = 0,
+    num_threads: int = _NUMERIC_DEFAULT_NUM_THREADS,
+    backend: BackendLike = None,
 ) -> np.ndarray:
     """
     Pad `x` to match `shape`. The left padding is taken equal to `box`'s start.
@@ -176,6 +207,11 @@ def restore_crop(
         shape to restore crop to
     padding_values: Union[AxesParams, Callable]
         values to pad with. If Callable (e.g. `numpy.min`) - `padding_values(x)` will be used
+    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
     -------
@@ -203,7 +239,7 @@ def restore_crop(
         )
 
     padding = np.array([start, shape - stop], dtype=int).T
-    x = pad(x, padding, padding_values=padding_values)
+    x = pad(x, padding, padding_values=padding_values, num_threads=num_threads, backend=backend)
     assert all(np.array(x.shape) == shape)
 
     return x

imops/radon.py

@@ -4,6 +4,7 @@ import numpy as np
 from scipy.fftpack import fft, ifft
 
 from .backend import BackendLike, resolve_backend
+from .numeric import copy
 from .src._backprojection import backprojection3d
 from .src._fast_backprojection import backprojection3d as fast_backprojection3d
 from .src._fast_radon import radon3d as fast_radon3d
@@ -52,7 +53,7 @@ def radon(
     >>> sinogram, fill_value = radon(image, return_fill=True)  # 2d image with fill value
     >>> sinogram = radon(image, axes=(-2, -1))  # nd image
     """
-    backend = resolve_backend(backend)
+    backend = resolve_backend(backend, warn_stacklevel=3)
     if backend.name not in ('Cython',):
         raise ValueError(f'Unsupported backend "{backend.name}".')
 
@@ -78,13 +79,14 @@ def radon(
         )
 
     if min_ != 0 or max_ != 0:
-        image = image.copy()
+        # FIXME: how to accurately pass `num_threads` and `backend` arguments to `copy`?
+        image = copy(image, order='C')
         image[:, outside_circle] = 0
 
     # TODO: f(arange)?
     limits = ((squared[:, None] + squared[None, :]) > (radius + 2) ** 2).sum(0) // 2
 
-    num_threads = normalize_num_threads(num_threads, backend)
+    num_threads = normalize_num_threads(num_threads, backend, warn_stacklevel=3)
 
     radon3d_ = fast_radon3d if backend.fast else radon3d
 
@@ -141,7 +143,7 @@ def inverse_radon(
     >>> image = inverse_radon(sinogram, fill_value=-1000)  # 2d image with fill value
     >>> image = inverse_radon(sinogram, axes=(-2, -1))  # nd image
     """
-    backend = resolve_backend(backend)
+    backend = resolve_backend(backend, warn_stacklevel=3)
     if backend.name not in ('Cython',):
         raise ValueError(f'Unsupported backend "{backend.name}".')
 
@@ -183,7 +185,7 @@ def inverse_radon(
     filtered_sinogram = filtered_sinogram.astype(dtype, copy=False)
     theta, xs = np.deg2rad(theta, dtype=dtype), xs.astype(dtype, copy=False)
 
-    num_threads = normalize_num_threads(num_threads, backend)
+    num_threads = normalize_num_threads(num_threads, backend, warn_stacklevel=3)
 
     backprojection3d_ = fast_backprojection3d if backend.fast else backprojection3d
 

imops/src/_fast_numeric.pyx

@@ -8,10 +8,19 @@
 import numpy as np
 
 cimport numpy as np
+from libc.stdint cimport uint16_t
 
 from cython.parallel import prange
 
 
+# https://stackoverflow.com/questions/47421443/using-half-precision-numpy-floats-in-cython
+cdef extern from "numpy/halffloat.h":
+    ctypedef uint16_t npy_half
+
+    float npy_half_to_float(npy_half h) nogil
+    npy_half npy_float_to_half(float f) nogil
+
+
 ctypedef fused NUM:
     short
     int
@@ -20,45 +29,214 @@ ctypedef fused NUM:
     double
 
 
-def _parallel_sum(NUM[:] nums, Py_ssize_t num_threads) -> NUM:
-    cdef NUM res = 0
-    cdef Py_ssize_t i, len_nums = len(nums)
+ctypedef fused NUM_AND_NPY_HALF:
+    NUM
+    npy_half
 
-    for i in prange(len_nums, num_threads=num_threads, nogil=True):
-        res += nums[i]
 
-    return res
-
-
-def _parallel_pointwise_mul(
+# TODO: Generalize code below to n-d
+def _pointwise_add_array_3d(
     NUM[:, :, :] nums1,
     NUM[:, :, :] nums2,
-    Py_ssize_t[:] res_shape,
-    Py_ssize_t num_threads
+    NUM[:, :, :] out,
+    Py_ssize_t num_threads,
 ) -> np.ndarray:
-    cdef NUM[:, :, ::1] contiguous_nums1 = np.ascontiguousarray(nums1), contiguous_nums2 = np.ascontiguousarray(nums2)
-    cdef Py_ssize_t rows = res_shape[0], cols = res_shape[1], dims = res_shape[2]
+    cdef Py_ssize_t rows = out.shape[0], cols = out.shape[1], dims = out.shape[2]
+    cdef Py_ssize_t i, j, k
+
+    for i in prange(rows, nogil=True, num_threads=num_threads):
+        for j in prange(cols):
+            for k in prange(dims):
+                out[i, j, k] = nums1[i, j, k] + nums2[i, j, k]
+
+    return np.asarray(out)
 
-    cdef char[:] broadcast_mask1 = np.array([x == y for x, y in zip(res_shape, nums1.shape)], dtype=np.int8)
-    cdef char[:] broadcast_mask2 = np.array([x == y for x, y in zip(res_shape, nums2.shape)], dtype=np.int8)
 
-    cdef NUM[:, :, ::1] mul = np.empty_like(nums1, shape=res_shape)
+def _pointwise_add_array_4d(
+    NUM[:, :, :, :] nums1,
+    NUM[:, :, :, :] nums2,
+    NUM[:, :, :, :] out,
+    Py_ssize_t num_threads,
+) -> np.ndarray:
+    cdef Py_ssize_t dim1 = out.shape[0], dim2 = out.shape[1], dim3 = out.shape[2], dim4 = out.shape[3]
+    cdef Py_ssize_t i1, i2, i3, i4
+
+    for i1 in prange(dim1, nogil=True, num_threads=num_threads):
+        for i2 in prange(dim2):
+            for i3 in prange(dim3):
+                for i4 in prange(dim4):
+                    out[i1, i2, i3, i4] = nums1[i1, i2, i3, i4] + nums2[i1, i2, i3, i4]
+
+    return np.asarray(out)
+
+
+def _pointwise_add_value_3d(
+    NUM[:, :, :] nums,
+    NUM value,
+    NUM[:, :, :] out,
+    Py_ssize_t num_threads,
+) -> np.ndarray:
+    cdef Py_ssize_t rows = out.shape[0], cols = out.shape[1], dims = out.shape[2]
     cdef Py_ssize_t i, j, k
 
     for i in prange(rows, nogil=True, num_threads=num_threads):
         for j in prange(cols):
             for k in prange(dims):
-                mul[i, j, k] = (
-                    contiguous_nums1[
-                        i * broadcast_mask1[0],
-                        j * broadcast_mask1[1],
-                        k * broadcast_mask1[2]
-                    ] *
-                    contiguous_nums2[
-                        i * broadcast_mask2[0],
-                        j * broadcast_mask2[1],
-                        k * broadcast_mask2[2]
-                    ]
-                )
-
-    return np.asarray(mul)
+                out[i, j, k] = nums[i, j, k] + value
+
+    return np.asarray(out)
+
+
+def _pointwise_add_value_4d(
+    NUM[:, :, :, :] nums,
+    NUM value,
+    NUM[:, :, :, :] out,
+    Py_ssize_t num_threads,
+) -> np.ndarray:
+    cdef Py_ssize_t dim1 = out.shape[0], dim2 = out.shape[1], dim3 = out.shape[2], dim4 = out.shape[3]
+    cdef Py_ssize_t i1, i2, i3, i4
+
+    for i1 in prange(dim1, nogil=True, num_threads=num_threads):
+        for i2 in prange(dim2):
+            for i3 in prange(dim3):
+                for i4 in prange(dim4):
+                    out[i1, i2, i3, i4] = nums[i1, i2, i3, i4] + value
+
+    return np.asarray(out)
+
+
+def _pointwise_add_array_3d_fp16(
+    npy_half[:, :, :] nums1,
+    npy_half[:, :, :] nums2,
+    npy_half[:, :, :] out,
+    Py_ssize_t num_threads,
+) -> np.ndarray:
+    cdef Py_ssize_t rows = out.shape[0], cols = out.shape[1], dims = out.shape[2]
+    cdef Py_ssize_t i, j, k
+
+    for i in prange(rows, nogil=True, num_threads=num_threads):
+        for j in prange(cols):
+            for k in prange(dims):
+                out[i, j, k] = (npy_float_to_half(npy_half_to_float(nums1[i, j, k]) +
+                                npy_half_to_float(nums2[i, j, k])))
+
+    return np.asarray(out)
+
+
+def _pointwise_add_array_4d_fp16(
+    npy_half[:, :, :, :] nums1,
+    npy_half[:, :, :, :] nums2,
+    npy_half[:, :, :, :] out,
+    Py_ssize_t num_threads,
+) -> np.ndarray:
+    cdef Py_ssize_t dim1 = out.shape[0], dim2 = out.shape[1], dim3 = out.shape[2], dim4 = out.shape[3]
+    cdef Py_ssize_t i1, i2, i3, i4
+
+    for i1 in prange(dim1, nogil=True, num_threads=num_threads):
+        for i2 in prange(dim2):
+            for i3 in prange(dim3):
+                for i4 in prange(dim4):
+                    out[i1, i2, i3, i4] = (npy_float_to_half(npy_half_to_float(nums1[i1, i2, i3, i4]) +
+                                           npy_half_to_float(nums2[i1, i2, i3, i4])))
+
+    return np.asarray(out)
+
+
+def _pointwise_add_value_3d_fp16(
+    npy_half[:, :, :] nums,
+    npy_half value,
+    npy_half[:, :, :] out,
+    Py_ssize_t num_threads,
+) -> np.ndarray:
+    cdef Py_ssize_t rows = out.shape[0], cols = out.shape[1], dims = out.shape[2]
+    cdef Py_ssize_t i, j, k
+
+    for i in prange(rows, nogil=True, num_threads=num_threads):
+        for j in prange(cols):
+            for k in prange(dims):
+                out[i, j, k] = npy_float_to_half(npy_half_to_float(nums[i, j, k]) + npy_half_to_float(value))
+
+    return np.asarray(out)
+
+
+def _pointwise_add_value_4d_fp16(
+    npy_half[:, :, :, :] nums,
+    npy_half value,
+    npy_half[:, :, :, :] out,
+    Py_ssize_t num_threads,
+) -> np.ndarray:
+    cdef Py_ssize_t dim1 = out.shape[0], dim2 = out.shape[1], dim3 = out.shape[2], dim4 = out.shape[3]
+    cdef Py_ssize_t i1, i2, i3, i4
+
+    for i1 in prange(dim1, nogil=True, num_threads=num_threads):
+        for i2 in prange(dim2):
+            for i3 in prange(dim3):
+                for i4 in prange(dim4):
+                    out[i1, i2, i3, i4] = (npy_float_to_half(npy_half_to_float(nums[i1, i2, i3, i4]) +
+                                           npy_half_to_float(value)))
+
+    return np.asarray(out)
+
+
+def _fill_3d(NUM_AND_NPY_HALF[:, :, :] nums, NUM_AND_NPY_HALF value, Py_ssize_t num_threads) -> None:
+    cdef Py_ssize_t rows = nums.shape[0], cols = nums.shape[1], dims = nums.shape[2]
+    cdef Py_ssize_t i, j, k
+
+    for i in prange(rows, nogil=True, num_threads=num_threads):
+        for j in prange(cols):
+            for k in prange(dims):
+                nums[i, j, k] = value
+
+
+def _fill_4d(NUM_AND_NPY_HALF[:, :, :, :] nums, NUM_AND_NPY_HALF value, Py_ssize_t num_threads) -> None:
+    cdef Py_ssize_t dim1 = nums.shape[0], dim2 = nums.shape[1], dim3 = nums.shape[2], dim4 = nums.shape[3]
+    cdef Py_ssize_t i1, i2, i3, i4
+
+    for i1 in prange(dim1, nogil=True, num_threads=num_threads):
+        for i2 in prange(dim2):
+            for i3 in prange(dim3):
+                for i4 in prange(dim4):
+                    nums[i1, i2, i3, i4] = value
+
+
+# FIXME: somehow `const NUM_AND_NPY_HALF` is not working
+cpdef void _copy_3d(const NUM[:, :, :] nums1, NUM[:, :, :] nums2, Py_ssize_t num_threads):
+    cdef Py_ssize_t rows = nums1.shape[0], cols = nums1.shape[1], dims = nums1.shape[2]
+    cdef Py_ssize_t i, j, k
+
+    for i in prange(rows, nogil=True, num_threads=num_threads):
+        for j in prange(cols):
+            for k in prange(dims):
+                nums2[i, j, k] = nums1[i, j, k]
+
+
+cpdef void _copy_4d(const NUM[:, :, :, :] nums1, NUM[:, :, :, :] nums2, Py_ssize_t num_threads):
+    cdef Py_ssize_t dim1 = nums1.shape[0], dim2 = nums1.shape[1], dim3 = nums1.shape[2], dim4 = nums1.shape[3]
+    cdef Py_ssize_t i1, i2, i3, i4
+
+    for i1 in prange(dim1, nogil=True, num_threads=num_threads):
+        for i2 in prange(dim2):
+            for i3 in prange(dim3):
+                for i4 in prange(dim4):
+                    nums2[i1, i2, i3, i4] = nums1[i1, i2, i3, i4]
+
+
+cpdef void _copy_3d_fp16(const npy_half[:, :, :] nums1, npy_half[:, :, :] nums2, Py_ssize_t num_threads):
+    cdef Py_ssize_t rows = nums1.shape[0], cols = nums1.shape[1], dims = nums1.shape[2]
+    cdef Py_ssize_t i, j, k
+
+    for i in prange(rows, nogil=True, num_threads=num_threads):
+        for j in prange(cols):
+            for k in prange(dims):
+                nums2[i, j, k] = nums1[i, j, k]
+
+
+cpdef void _copy_4d_fp16(const npy_half[:, :, :, :] nums1, npy_half[:, :, :, :] nums2, Py_ssize_t num_threads):
+    cdef Py_ssize_t dim1 = nums1.shape[0], dim2 = nums1.shape[1], dim3 = nums1.shape[2], dim4 = nums1.shape[3]
+    cdef Py_ssize_t i1, i2, i3, i4
+
+    for i1 in prange(dim1, nogil=True, num_threads=num_threads):
+        for i2 in prange(dim2):
+            for i3 in prange(dim3):
+                for i4 in prange(dim4):
+                    nums2[i1, i2, i3, i4] = nums1[i1, i2, i3, i4]