nabu 2023.2.1__py3-none-any.whl → 2024.1.0rc3__py3-none-any.whl

nabu/misc/processing_base.py

@@ -1,108 +1,4 @@
-import numpy as np
+from nabu.processing.processing_base import ProcessingBase
+from ..utils import deprecated_class
 
-
-class ProcessingBase:
-    _array_class = None
-
-    def __init__(self):
-        self._allocated = {}
-
-    def init_arrays_to_none(self, arrays_names):
-        """
-        Initialize arrays to None. After calling this method, the current instance will
-        have self.array_name = None, and self._old_array_name = None.
-
-        Parameters
-        ----------
-        arrays_names: list of str
-            List of arrays names.
-        """
-        for array_name in arrays_names:
-            setattr(self, array_name, None)
-            setattr(self, "_old_" + array_name, None)
-            self._allocated[array_name] = False
-
-    def recover_arrays_references(self, arrays_names):
-        """
-        Performs self._array_name = self._old_array_name,
-        for each array_name in arrays_names.
-
-        Parameters
-        ----------
-        arrays_names: list of str
-            List of array names
-        """
-        for array_name in arrays_names:
-            old_arr = getattr(self, "_old_" + array_name, None)
-            if old_arr is not None:
-                setattr(self, array_name, old_arr)
-
-    def _allocate_array_mem(self, shape, dtype):
-        raise ValueError("Base class")
-
-    def allocate_array(self, array_name, shape, dtype=np.float32):
-        """
-        Allocate a GPU array on the current context/stream/device,
-        and set 'self.array_name' to this array.
-
-        Parameters
-        ----------
-        array_name: str
-            Name of the array (for book-keeping)
-        shape: tuple of int
-            Array shape
-        dtype: numpy.dtype, optional
-            Data type. Default is float32.
-        """
-        if not self._allocated.get(array_name, False):
-            new_device_arr = self._allocate_array_mem(shape, dtype)
-            setattr(self, array_name, new_device_arr)
-            self._allocated[array_name] = True
-        return getattr(self, array_name)
-
-    def set_array(self, array_name, array_ref, dtype=np.float32):
-        """
-        Set the content of a device array.
-
-        Parameters
-        ----------
-        array_name: str
-            Array name. This method will look for self.array_name.
-        array_ref: array (numpy or GPU array)
-            Array containing the data to copy to 'array_name'.
-        dtype: numpy.dtype, optional
-            Data type. Default is float32.
-        """
-        if isinstance(array_ref, self._array_class):
-            current_arr = getattr(self, array_name, None)
-            setattr(self, "_old_" + array_name, current_arr)
-            setattr(self, array_name, array_ref)
-        elif isinstance(array_ref, np.ndarray):
-            self.allocate_array(array_name, array_ref.shape, dtype=dtype)
-            getattr(self, array_name).set(array_ref)
-        else:
-            raise ValueError("Expected numpy array or pycuda array")
-        return getattr(self, array_name)
-
-    def get_array(self, array_name):
-        return getattr(self, array_name, None)
-
-    # COMPAT.
-    _init_arrays_to_none = init_arrays_to_none
-    _recover_arrays_references = recover_arrays_references
-    _allocate_array = allocate_array
-    _set_array = set_array
-
-    def check_array(self, arr, expected_shape, expected_dtype="f", check_contiguous=True):
-        """
-        Check whether a given array is suitable for being processed (shape, dtype, contiguous)
-        """
-        if arr.shape != expected_shape:
-            raise ValueError("Expected shape %s but got %s" % (str(expected_shape), str(arr.shape)))
-        if arr.dtype != np.dtype(expected_dtype):
-            raise ValueError("Expected data type %s but got %s" % (str(expected_dtype), str(arr.dtype)))
-        if check_contiguous:
-            if isinstance(arr, np.ndarray) and not (arr.flags["C_CONTIGUOUS"]):
-                raise ValueError("Expected C-contiguous array")
-            if isinstance(arr, self._array_class) and not arr.flags.c_contiguous:
-                raise ValueError("Expected C-contiguous array")
+ProcessingBase = deprecated_class("ProcessingBase has been moved to nabu.processing", do_print=True)(ProcessingBase)

nabu/misc/rotation.py

@@ -1,63 +1,6 @@
-try:
-    from skimage.transform import rotate
+from ..processing.rotation import *
+from ..utils import deprecation_warning
 
-    __have__skimage__ = True
-except ImportError:
-    __have__skimage__ = False
-
-
-class Rotation:
-    supported_modes = {
-        "constant": "constant",
-        "zeros": "constant",
-        "edge": "edge",
-        "edges": "edge",
-        "symmetric": "symmetric",
-        "sym": "symmetric",
-        "reflect": "reflect",
-        "wrap": "wrap",
-        "periodic": "wrap",
-    }
-
-    def __init__(self, shape, angle, center=None, mode="edge", reshape=False, **sk_kwargs):
-        """
-        Initiate a Rotation object.
-
-        Parameters
-        ----------
-        shape: tuple of int
-            Shape of the images to process
-        angle: float
-            Rotation angle in DEGREES
-        center: tuple of float, optional
-            Coordinates of the center of rotation, in the format (X, Y) (mind the non-python
-            convention !).
-            Default is ((Nx - 1)/2.0, (Ny - 1)/2.0)
-        mode: str, optional
-            Padding mode. Default is "edge".
-        reshape: bool, optional
-
-
-        Other Parameters
-        -----------------
-        All the other parameters are passed directly to scikit image 'rotate' function:
-        order, cval, clip, preserve_range.
-        """
-        self.shape = shape
-        self.angle = angle
-        self.center = center
-        self.mode = mode
-        self.reshape = reshape
-        self.sk_kwargs = sk_kwargs
-
-    def rotate(self, img, output=None):
-        if not __have__skimage__:
-            raise ValueError("scikit-image is needed for using rotate()")
-        res = rotate(img, self.angle, resize=self.reshape, center=self.center, mode=self.mode, **self.sk_kwargs)
-        if output is not None:
-            output[:] = res[:]
-            return output
-        else:
-            return res
-
-    __call__ = rotate
+deprecation_warning(
+    "nabu.misc.rotation has been moved to nabu.processing.rotation", do_print=True, func_name="rotation"
+)

nabu/misc/rotation_cuda.py

@@ -1,66 +1,6 @@
-import numpy as np
-from .rotation import Rotation
-from ..utils import get_cuda_srcfile, updiv
-from ..cuda.utils import __has_pycuda__, copy_array
-from ..cuda.processing import CudaProcessing
+from ..processing.rotation_cuda import *
+from ..utils import deprecation_warning
 
-if __has_pycuda__:
-    from ..cuda.kernel import CudaKernel
-    import pycuda.driver as cuda
-
-
-class CudaRotation(Rotation):
-    def __init__(self, shape, angle, center=None, mode="edge", reshape=False, cuda_options=None, **sk_kwargs):
-        if center is None:
-            center = ((shape[1] - 1) / 2.0, (shape[0] - 1) / 2.0)
-        super().__init__(shape, angle, center=center, mode=mode, reshape=reshape, **sk_kwargs)
-        self._init_cuda_rotation(cuda_options)
-
-    def _init_cuda_rotation(self, cuda_options):
-        cuda_options = cuda_options or {}
-        self.cuda_processing = CudaProcessing(**cuda_options)
-        self._allocate_arrays()
-        self._init_rotation_kernel()
-
-    def _allocate_arrays(self):
-        self._d_image_cua = cuda.np_to_array(np.zeros(self.shape, "f"), "C")
-        self.cuda_processing.init_arrays_to_none(["d_output"])
-
-    def _init_rotation_kernel(self):
-        self.cuda_rotation_kernel = CudaKernel("rotate", get_cuda_srcfile("rotation.cu"))
-        self.texref_image = self.cuda_rotation_kernel.module.get_texref("tex_image")
-        self.texref_image.set_filter_mode(cuda.filter_mode.LINEAR)  # bilinear
-        self.texref_image.set_address_mode(0, cuda.address_mode.CLAMP)  # TODO tune
-        self.texref_image.set_address_mode(1, cuda.address_mode.CLAMP)  # TODO tune
-        self.cuda_rotation_kernel.prepare("Piiffff", [self.texref_image])
-        self.texref_image.set_array(self._d_image_cua)
-        self._cos_theta = np.cos(np.deg2rad(self.angle))
-        self._sin_theta = np.sin(np.deg2rad(self.angle))
-        self._Nx = np.int32(self.shape[1])
-        self._Ny = np.int32(self.shape[0])
-        self._center_x = np.float32(self.center[0])
-        self._center_y = np.float32(self.center[1])
-        self._block = (32, 32, 1)  # tune ?
-        self._grid = (updiv(self.shape[1], self._block[1]), updiv(self.shape[0], self._block[0]), 1)
-
-    def rotate(self, img, output=None, do_checks=True):
-        copy_array(self._d_image_cua, img, check=do_checks)
-        if output is not None:
-            d_out = output
-        else:
-            self.cuda_processing.allocate_array("d_output", self.shape, np.float32)
-            d_out = self.cuda_processing.d_output
-        self.cuda_rotation_kernel(
-            d_out,
-            self._Nx,
-            self._Ny,
-            self._cos_theta,
-            self._sin_theta,
-            self._center_x,
-            self._center_y,
-            grid=self._grid,
-            block=self._block,
-        )
-        return d_out
-
-    __call__ = rotate
+deprecation_warning(
+    "nabu.misc.rotation_cuda has been moved to nabu.processing.rotation_cuda", do_print=True, func_name="rotation_cuda"
+)

nabu/misc/transpose.py

@@ -0,0 +1,6 @@
+from ..processing.transpose import *
+from ..utils import deprecation_warning
+
+deprecation_warning(
+    "nabu.misc.transpose has been moved to nabu.processing.transpose", do_print=True, func_name="transpose"
+)

nabu/misc/unsharp.py

@@ -1,79 +1,4 @@
-import numpy as np
-from scipy.ndimage import convolve1d
-from silx.image.utils import gaussian_kernel
+from ..processing.unsharp import *
+from ..utils import deprecation_warning
 
-
-class UnsharpMask:
-    """
-    A helper class for unsharp masking.
-    """
-
-    avail_methods = ["gaussian", "log", "imagej"]
-
-    def __init__(self, shape, sigma, coeff, mode="reflect", method="gaussian"):
-        """
-        Initialize a Unsharp mask.
-        `UnsharpedImage =  (1 + coeff)*Image - coeff * ConvolutedImage`
-
-        If method == "log":
-        `UnsharpedImage = Image + coeff*ConvolutedImage`
-
-        Parameters
-        -----------
-        shape: tuple
-            Shape of the image.
-        sigma: float
-            Standard deviation of the Gaussian kernel
-        coeff: float
-            Coefficient in the linear combination of unsharp mask
-        mode: str, optional
-            Convolution mode. Default is "reflect"
-        method: str, optional
-            Method of unsharp mask. Can be "gaussian" (default) or "log" (Laplacian of Gaussian),
-            or "imagej".
-
-
-        Notes
-        -----
-        The computation is the following depending on the method:
-
-           - For method="gaussian": output = (1 + coeff) * image - coeff * image_blurred
-           - For method="log": output = image + coeff * image_blurred
-           - For method="imagej": output = (image - coeff*image_blurred)/(1-coeff)
-        """
-        self.shape = shape
-        self.ndim = len(self.shape)
-        self.sigma = sigma
-        self.coeff = coeff
-        self._set_method(method)
-        self.mode = mode
-        self._compute_gaussian_kernel()
-
-    def _set_method(self, method):
-        if method not in self.avail_methods:
-            raise ValueError("Unknown unsharp method '%s'. Available are %s" % (method, str(self.avail_methods)))
-        self.method = method
-
-    def _compute_gaussian_kernel(self):
-        self._gaussian_kernel = np.ascontiguousarray(gaussian_kernel(self.sigma), dtype=np.float32)
-
-    def _blur2d(self, image):
-        res1 = convolve1d(image, self._gaussian_kernel, axis=1, mode=self.mode)
-        res = convolve1d(res1, self._gaussian_kernel, axis=0, mode=self.mode)
-        return res
-
-    def unsharp(self, image, output=None):
-        """
-        Reference unsharp mask implementation.
-        """
-        image_b = self._blur2d(image)
-        if self.method == "gaussian":
-            res = (1 + self.coeff) * image - self.coeff * image_b
-        elif self.method == "log":
-            res = image + self.coeff * image_b
-        else:  # "imagej":
-            res = (image - self.coeff * image_b) / (1 - self.coeff)
-        if output is not None:
-            output[:] = res[:]
-            return output
-        return res
+deprecation_warning("nabu.misc.unsharp has been moved to nabu.processing.unsharp", do_print=True, func_name="unsharp")

nabu/misc/unsharp_cuda.py

@@ -1,53 +1,6 @@
-from ..cuda.utils import __has_pycuda__
-from ..cuda.convolution import Convolution
-from ..cuda.processing import CudaProcessing
-from .unsharp import UnsharpMask
+from ..processing.unsharp_cuda import *
+from ..utils import deprecation_warning
 
-if __has_pycuda__:
-    from pycuda.elementwise import ElementwiseKernel
-
-
-class CudaUnsharpMask(UnsharpMask):
-    def __init__(self, shape, sigma, coeff, mode="reflect", method="gaussian", cuda_options=None):
-        """
-        Unsharp Mask, cuda backend.
-        """
-        super().__init__(shape, sigma, coeff, mode=mode, method=method)
-        self.cuda_processing = CudaProcessing(**(cuda_options or {}))
-        self._init_convolution()
-        self._init_mad_kernel()
-        self.cuda_processing.init_arrays_to_none(["_d_out"])
-
-    def _init_convolution(self):
-        self.convolution = Convolution(
-            self.shape,
-            self._gaussian_kernel,
-            mode=self.mode,
-            extra_options={  # Use the lowest amount of memory
-                "allocate_input_array": False,
-                "allocate_output_array": False,
-                "allocate_tmp_array": True,
-            },
-        )
-
-    def _init_mad_kernel(self):
-        # garray.GPUArray.mul_add is out of place...
-        self.mad_kernel = ElementwiseKernel(
-            "float* array, float fac, float* other, float otherfac",
-            "array[i] = fac * array[i] + otherfac * other[i]",
-            name="mul_add",
-        )
-
-    def unsharp(self, image, output=None):
-        if output is None:
-            output = self.cuda_processing.allocate_array("_d_out", self.shape, "f")
-        self.convolution(image, output=output)
-        if self.method == "gaussian":
-            self.mad_kernel(output, -self.coeff, image, 1.0 + self.coeff)
-        elif self.method == "log":
-            # output = output * coeff + image   where output was image_blurred
-            self.mad_kernel(output, self.coeff, image, 1.0)
-        else:  # "imagej":
-            # output = (image - coeff*image_blurred)/(1-coeff)  where output was image_blurred
-            self.mad_kernel(output, -self.coeff / (1 - self.coeff), image, 1.0 / (1 - self.coeff))
-        return output
+deprecation_warning(
+    "nabu.misc.unsharp_cuda has been moved to nabu.processing.unsharp_cuda", do_print=True, func_name="unsharp_cuda"
+)

nabu/misc/unsharp_opencl.py

@@ -1,85 +1,8 @@
-try:
-    from silx.opencl.processing import OpenclProcessing
-    from silx.opencl.convolution import Convolution as CLConvolution
-    import pyopencl.array as parray
-    from pyopencl.elementwise import ElementwiseKernel
-
-    __have_opencl__ = True
-except ImportError:
-    __have_opencl__ = False
-from .unsharp import UnsharpMask
-
-
-class OpenclUnsharpMask(UnsharpMask, OpenclProcessing):
-    def __init__(
-        self,
-        shape,
-        sigma,
-        coeff,
-        mode="reflect",
-        method="gaussian",
-        ctx=None,
-        devicetype="all",
-        platformid=None,
-        deviceid=None,
-        block_size=None,
-        memory=None,
-        profile=False,
-    ):
-        """
-        NB: For now, this class is designed to use the lowest amount of GPU memory
-        as possible. Therefore, the input and output image/volumes are assumed
-        to be already on device.
-        """
-        if not (__have_opencl__):
-            raise ImportError("Need silx and pyopencl")
-        OpenclProcessing.__init__(
-            self,
-            ctx=ctx,
-            devicetype=devicetype,
-            platformid=platformid,
-            deviceid=deviceid,
-            block_size=block_size,
-            memory=memory,
-            profile=profile,
-        )
-        UnsharpMask.__init__(self, shape, sigma, coeff, mode=mode, method=method)
-        self._init_convolution()
-        self._init_mad_kernel()
-
-    def _init_convolution(self):
-        self.convolution = CLConvolution(
-            self.shape,
-            self._gaussian_kernel,
-            mode=self.mode,
-            ctx=self.ctx,
-            profile=self.profile,
-            extra_options={  # Use the lowest amount of memory
-                "allocate_input_array": False,
-                "allocate_output_array": False,
-                "allocate_tmp_array": True,
-                "dont_use_textures": True,
-            },
-        )
-
-    def _init_mad_kernel(self):
-        # parray.Array.mul_add is out of place...
-        self.mad_kernel = ElementwiseKernel(
-            self.ctx,
-            "float* array, float fac, float* other, float otherfac",
-            "array[i] = fac * array[i] + otherfac * other[i]",
-            name="mul_add",
-        )
-
-    def unsharp(self, image, output):
-        # For now image and output are assumed to be already allocated on device
-        assert isinstance(image, parray.Array)
-        assert isinstance(output, parray.Array)
-        self.convolution(image, output=output)
-        if self.method == "gaussian":
-            self.mad_kernel(output, -self.coeff, image, 1.0 + self.coeff)
-        elif self.method == "log":
-            self.mad_kernel(output, self.coeff, image, 1.0)
-        else:  # "imagej":
-            self.mad_kernel(output, -self.coeff / (1 - self.coeff), image, 1.0 / (1 - self.coeff))
-        return output
+from ..processing.unsharp_opencl import *
+from ..utils import deprecation_warning
+
+deprecation_warning(
+    "nabu.misc.unsharp_opencl has been moved to nabu.processing.unsharp_opencl",
+    do_print=True,
+    func_name="unsharp_opencl",
+)

nabu/opencl/fft.py

@@ -0,0 +1,6 @@
+from ..processing.fft_opencl import *
+from ..utils import deprecation_warning
+
+deprecation_warning(
+    "nabu.opencl.fft has been moved to nabu.processing.fft_opencl", do_print=True, func_name="fft_opencl"
+)

nabu/opencl/kernel.py

@@ -1,7 +1,7 @@
 import pyopencl.array as parray
 from pyopencl import Program, CommandQueue, kernel_work_group_info
-from ..utils import updiv, deprecation_warning
-from ..misc.kernel_base import KernelBase
+from ..utils import deprecation_warning
+from ..processing.kernel_base import KernelBase
 
 
 class OpenCLKernel(KernelBase):
@@ -14,6 +14,8 @@ class OpenCLKernel(KernelBase):
         Name of the OpenCL kernel.
     ctx: pyopencl.Context
         OpenCL context to use.
+    queue: pyopencl.CommandQueue
+        OpenCL queue to use. If provided, will use this queue's context instead of 'ctx'
     filename: str, optional
         Path to the file name containing kernels definitions
     src: str, optional
@@ -28,13 +30,19 @@ class OpenCLKernel(KernelBase):
         self,
         kernel_name,
         ctx,
+        queue=None,
         filename=None,
         src=None,
         automation_params=None,
         **build_kwargs,
     ):
         super().__init__(kernel_name, filename=filename, src=src, automation_params=automation_params)
-        self.ctx = ctx
+        if queue is not None:
+            self.ctx = queue.context
+            self.queue = queue
+        else:
+            self.ctx = ctx
+            self.queue = None
         self.compile_kernel_source(kernel_name, build_kwargs)
         self.get_kernel()
 
@@ -105,9 +113,16 @@ class OpenCLKernel(KernelBase):
                 args[i] = arg.data
         return tuple(args)
 
-    def call(self, queue, *args, **kwargs):
-        if not isinstance(queue, CommandQueue):
-            raise ValueError("First argument must be a pyopencl queue")
+    def call(self, *args, **kwargs):
+        if not isinstance(args[0], CommandQueue):
+            queue = self.queue
+            if queue is None:
+                raise ValueError(
+                    "First argument must be a pyopencl queue - otherwise provide OpenCLKernel(..., queue=queue)"
+                )
+        else:
+            queue = args[0]
+            args = args[1:]
         global_size, local_size, args, kwargs = self._prepare_call(*args, **kwargs)
 
         kwargs.pop("global_size", None)

nabu/opencl/padding.py

@@ -1,73 +1,6 @@
-import numpy as np
-from ..utils import get_opencl_srcfile, updiv, check_supported
-from .kernel import OpenCLKernel
-from .processing import OpenCLProcessing
-from .memcpy import OpenCLMemcpy2D
-import pyopencl.array as parray
-from ..misc.padding_base import PaddingBase
+from ..processing.padding_opencl import *
+from ..utils import deprecation_warning
 
-
-class OpenCLPadding(PaddingBase):
-    """
-    A class for performing padding on GPU using Cuda
-    """
-
-    # TODO docstring from base class
-    def __init__(self, shape, pad_width, mode="constant", opencl_options=None, **kwargs):
-        super().__init__(shape, pad_width, mode=mode, **kwargs)
-        self.opencl_processing = OpenCLProcessing(**(opencl_options or {}))
-        self.queue = self.opencl_processing.queue
-        self._init_opencl_coordinate_transform()
-
-    def _init_opencl_coordinate_transform(self):
-        if self.mode == "constant":
-            self.d_padded_array_constant = parray.to_device(self.queue, self.padded_array_constant)
-            self.memcpy2D = OpenCLMemcpy2D(ctx=self.opencl_processing.ctx, queue=self.queue)
-            return
-        self._coords_transform_kernel = OpenCLKernel(
-            "coordinate_transform",
-            self.opencl_processing.ctx,
-            filename=get_opencl_srcfile("padding.cl"),
-        )
-        self._coords_transform_global_size = self.padded_shape[::-1]
-        self.d_coords_rows = parray.to_device(self.queue, self.coords_rows)
-        self.d_coords_cols = parray.to_device(self.queue, self.coords_cols)
-
-    def _pad_constant(self, image, output):
-        pad_y, pad_x = self.pad_width
-        # the following line is not implemented in pyopencl
-        # self.d_padded_array_constant[pad_y[0] : pad_y[0] + self.shape[0], pad_x[0] : pad_x[0] + self.shape[1]] = image[:]
-        # cl.enqueue_copy is too cumbersome to use for Buffer <-> Buffer.
-        # Use a dedicated kernel instead.
-        # This is not optimal (two copies) - TODO write a constant padding kernel
-        self.memcpy2D(self.d_padded_array_constant, image, image.shape[::-1], dst_offset_xy=(pad_x[0], pad_y[0]))
-        output[:] = self.d_padded_array_constant[:]
-        return output
-
-    def pad(self, image, output=None):
-        """
-        Pad an array.
-
-        Parameters
-        ----------
-        image: pycuda.gpuarray.GPUArray
-            Image to pad
-        output: pycuda.gpuarray.GPUArray, optional
-            Output image. If provided, must be in the expected shape.
-        """
-        if output is None:
-            output = self.opencl_processing.allocate_array("d_output", self.padded_shape)
-        if self.mode == "constant":
-            return self._pad_constant(image, output)
-        self._coords_transform_kernel(
-            self.queue,
-            image,
-            output,
-            self.d_coords_cols,
-            self.d_coords_rows,
-            np.int32(self.shape[1]),
-            np.int32(self.padded_shape[1]),
-            np.int32(self.padded_shape[0]),
-            global_size=self._coords_transform_global_size,
-        )
-        return output
+deprecation_warning(
+    "nabu.opencl.padding has been moved to nabu.processing.padding_opencl", do_print=True, func_name="padding_opencl"
+)