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

build/lib/build/lib/nabu/app/validator.py

@@ -0,0 +1,110 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import argparse
+import sys
+import os
+import h5py
+import tomoscan.validator
+from tomoscan.esrf.scan.nxtomoscan import NXtomoScan
+from tomoscan.esrf.scan.edfscan import EDFTomoScan
+
+
+def get_scans(path, entries: str):
+    path = os.path.abspath(path)
+    res = []
+    if EDFTomoScan.is_tomoscan_dir(path):
+        res.append(EDFTomoScan(scan=path))
+    elif NXtomoScan.is_tomoscan_dir(path):
+        if entries == "__all__":
+            entries = NXtomoScan.get_valid_entries(path)
+        for entry in entries:
+            res.append(NXtomoScan(path, entry))
+    else:
+        raise TypeError(f"{path} does not looks like a folder containing .EDF or a valid nexus file ")
+    return res
+
+
+def main():
+    argv = sys.argv
+    parser = argparse.ArgumentParser(description="Check if provided scan(s) seems valid to be reconstructed.")
+    parser.add_argument("path", help="Data to validate (h5 file, edf folder)")
+    parser.add_argument("entries", help="Entries to be validated (in the case of a h5 file)", nargs="*")
+    parser.add_argument(
+        "--ignore-dark",
+        help="Do not check for dark",
+        default=True,
+        action="store_false",
+        dest="check_dark",
+    )
+    parser.add_argument(
+        "--ignore-flat",
+        help="Do not check for flat",
+        default=True,
+        action="store_false",
+        dest="check_flat",
+    )
+    parser.add_argument(
+        "--no-phase-retrieval",
+        help="Check scan energy, distance and pixel size",
+        dest="check_phase_retrieval",
+        default=True,
+        action="store_false",
+    )
+    parser.add_argument(
+        "--check-nan",
+        help="Check frames if contains any nan.",
+        dest="check_nan",
+        default=False,
+        action="store_true",
+    )
+    parser.add_argument(
+        "--skip-links-check",
+        "--no-link-check",
+        help="Check frames dataset if have some broken links.",
+        dest="check_vds",
+        default=True,
+        action="store_false",
+    )
+    parser.add_argument(
+        "--all-entries",
+        help="Check all entries of the files (for HDF5 only for now)",
+        default=False,
+        action="store_true",
+    )
+    parser.add_argument(
+        "--extend",
+        help="By default it only display items with issues. Extend will display them all",
+        dest="only_issues",
+        default=True,
+        action="store_false",
+    )
+
+    options = parser.parse_args(argv[1:])
+    if options.all_entries is True:
+        entries = "__all__"
+    else:
+        if len(options.entries) == 0 and h5py.is_hdf5(options.path):
+            entries = "__all__"
+        else:
+            entries = options.entries
+
+    scans = get_scans(path=options.path, entries=entries)
+    if len(scans) == 0:
+        raise ValueError(f"No scan found from file:{options.path}, entries:{options.entries}")
+    for scan in scans:
+        validator = tomoscan.validator.ReconstructionValidator(
+            scan=scan,
+            check_phase_retrieval=options.check_phase_retrieval,
+            check_values=options.check_nan,
+            check_vds=options.check_vds,
+            check_dark=options.check_dark,
+            check_flat=options.check_flat,
+        )
+        sys.stdout.write(validator.checkup(only_issues=options.only_issues))
+
+    return 0
+
+
+if __name__ == "__main__":
+    main()

build/lib/build/lib/nabu/cuda/convolution.py

@@ -0,0 +1,8 @@
+from ..processing.convolution_cuda import *
+from ..utils import deprecation_warning
+
+deprecation_warning(
+    "nabu.cuda.convolution has been moved to nabu.processing.convolution_cuda",
+    do_print=True,
+    func_name="convolution_cuda",
+)

build/lib/build/lib/nabu/cuda/fft.py

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

build/lib/build/lib/nabu/cuda/kernel.py

@@ -0,0 +1,97 @@
+import pycuda.gpuarray as garray
+from pycuda.compiler import SourceModule
+from ..processing.kernel_base import KernelBase
+
+
+class CudaKernel(KernelBase):
+    """
+    Helper class that wraps CUDA kernel through pycuda SourceModule.
+
+    Parameters
+    -----------
+    kernel_name: str
+        Name of the CUDA kernel.
+    filename: str, optional
+        Path to the file name containing kernels definitions
+    src: str, optional
+        Source code of kernels definitions
+    signature: str, optional
+        Signature of kernel function. If provided, pycuda will not guess the types
+        of kernel arguments, making the calls slightly faster.
+        For example, a function acting on two pointers, an integer and a float32
+        has the signature "PPif".
+    texrefs: list, optional
+        List of texture references, if any
+    automation_params: dict, optional
+        Automation parameters, see below
+    sourcemodule_kwargs: optional
+        Extra arguments to provide to pycuda.compiler.SourceModule(),
+
+    """
+
+    def __init__(
+        self,
+        kernel_name,
+        filename=None,
+        src=None,
+        signature=None,
+        texrefs=None,
+        automation_params=None,
+        **sourcemodule_kwargs,
+    ):
+        super().__init__(kernel_name, filename=filename, src=src, automation_params=automation_params)
+        self.compile_kernel_source(kernel_name, sourcemodule_kwargs)
+        self.prepare(signature, texrefs)
+
+    def compile_kernel_source(self, kernel_name, sourcemodule_kwargs):
+        self.sourcemodule_kwargs = sourcemodule_kwargs
+        self.kernel_name = kernel_name
+        self.module = SourceModule(self.src, **self.sourcemodule_kwargs)
+        self.func = self.module.get_function(kernel_name)
+
+    def prepare(self, kernel_signature, texrefs):
+        self.prepared = False
+        self.kernel_signature = kernel_signature
+        self.texrefs = texrefs or []
+        if kernel_signature is not None:
+            self.func.prepare(self.kernel_signature, texrefs=self.texrefs)
+            self.prepared = True
+
+    def follow_device_arr(self, args):
+        args = list(args)
+        # Replace GPUArray with GPUArray.gpudata
+        for i, arg in enumerate(args):
+            if isinstance(arg, garray.GPUArray):
+                args[i] = arg.gpudata
+        return tuple(args)
+
+    def get_last_kernel_time(self):
+        """
+        Return the execution time (in seconds) of the last called kernel.
+        The last called kernel should have been called with time_kernel=True.
+        """
+        if self.last_kernel_time is not None:
+            return self.last_kernel_time()
+        else:
+            return None
+
+    def call(self, *args, **kwargs):
+        grid, block, args, kwargs = self._prepare_call(*args, **kwargs)
+
+        if self.prepared:
+            func_call = self.func.prepared_call
+            if "time_kernel" in kwargs:
+                func_call = self.func.prepared_timed_call
+                kwargs.pop("time_kernel")
+            if "block" in kwargs:
+                kwargs.pop("block")
+            if "grid" in kwargs:
+                kwargs.pop("grid")
+            t = func_call(grid, block, *args, **kwargs)
+        else:
+            kwargs["block"] = block
+            kwargs["grid"] = grid
+            t = self.func(*args, **kwargs)
+        self.last_kernel_time = t  # list ?
+
+    __call__ = call

build/lib/build/lib/nabu/cuda/medfilt.py

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

build/lib/build/lib/nabu/cuda/padding.py

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

build/lib/build/lib/nabu/cuda/processing.py

@@ -0,0 +1,75 @@
+from ..utils import MissingComponentError
+from ..processing.processing_base import ProcessingBase
+from .utils import get_cuda_context, __has_pycuda__
+
+if __has_pycuda__:
+    import pycuda.driver as cuda
+    import pycuda.gpuarray as garray
+    from ..cuda.kernel import CudaKernel
+
+    dev_attrs = cuda.device_attribute
+    GPUArray = garray.GPUArray
+    from pycuda.tools import dtype_to_ctype
+else:
+    GPUArray = MissingComponentError("pycuda")
+    dtype_to_ctype = MissingComponentError("pycuda")
+
+
+# NB: we must detach from a context before creating another context
+class CudaProcessing(ProcessingBase):
+    array_class = GPUArray if __has_pycuda__ else None
+    dtype_to_ctype = dtype_to_ctype
+
+    def __init__(self, device_id=None, ctx=None, stream=None, cleanup_at_exit=True):
+        """
+        Initialie a CudaProcessing instance.
+
+        CudaProcessing is a base class for all CUDA-based processings.
+        This class provides utilities for context/device management, and
+        arrays allocation.
+
+        Parameters
+        ----------
+        device_id: int, optional
+            ID of the cuda device to use (those of the `nvidia-smi` command).
+            Ignored if ctx is not None.
+        ctx: pycuda.driver.Context, optional
+            Existing context to use. If provided, do not create a new context.
+        stream: pycudacuda.driver.Stream, optional
+            Cuda stream. If not provided, will use the default stream
+        cleanup_at_exit: bool, optional
+            Whether to clean-up the context at exit.
+            Ignored if ctx is not None.
+        """
+        super().__init__()
+        if ctx is None:
+            self.ctx = get_cuda_context(device_id=device_id, cleanup_at_exit=cleanup_at_exit)
+        else:
+            self.ctx = ctx
+        self.stream = stream
+        self.device = self.ctx.get_device()
+        self.device_name = self.device.name()
+        self.device_id = self.device.get_attribute(dev_attrs.MULTI_GPU_BOARD_GROUP_ID)
+
+    def push_context(self):
+        self.ctx.push()
+        return self.ctx
+
+    def pop_context(self):
+        self.ctx.pop()
+
+    def _allocate_array_mem(self, shape, dtype):
+        return garray.zeros(shape, dtype)
+
+    def kernel(
+        self, kernel_name, filename=None, src=None, signature=None, texrefs=None, automation_params=None, **build_kwargs
+    ):
+        return CudaKernel(
+            kernel_name,
+            filename=filename,
+            src=src,
+            signature=signature,
+            texrefs=texrefs,
+            automation_params=automation_params,
+            **build_kwargs,
+        )

build/lib/build/lib/nabu/cuda/tests/__init__.py

@@ -0,0 +1 @@
+

build/lib/build/lib/nabu/cuda/utils.py

@@ -0,0 +1,331 @@
+import atexit
+from math import ceil
+import numpy as np
+from ..resources.gpu import GPUDescription
+
+try:
+    import pycuda
+    import pycuda.driver as cuda
+    from pycuda import gpuarray as garray
+    from pycuda.tools import clear_context_caches
+    from pycuda.compiler import get_nvcc_version as pycuda_get_nvcc_version
+
+    __has_pycuda__ = True
+    __pycuda_error_msg__ = None
+    if pycuda.VERSION[0] < 2020:
+        print("Error: need pycuda >= 2020.1")
+        __has_pycuda__ = False
+except ImportError as err:
+    __has_pycuda__ = False
+    __pycuda_error_msg__ = str(err)
+try:
+    import skcuda
+
+    __has_cufft__ = True
+except ImportError:
+    __has_cufft__ = False
+
+try:
+    import cupy
+
+    __has_cupy__ = True
+except ImportError:
+    __has_cupy__ = False
+
+
+def get_cuda_context(device_id=None, cleanup_at_exit=True):
+    """
+    Create or get a CUDA context.
+    """
+    current_ctx = cuda.Context.get_current()
+    # If a context already exists, use this one
+    # TODO what if the device used is different from device_id ?
+    if current_ctx is not None:
+        return current_ctx
+    # Otherwise create a new context
+    cuda.init()
+
+    if device_id is None:
+        device_id = 0
+    # Use the Context obtained by retaining the device's primary context,
+    # which is the one used by the CUDA runtime API (ex. scikit-cuda).
+    # Unlike Context.make_context(), the newly-created context is not made current.
+    context = cuda.Device(device_id).retain_primary_context()
+    context.push()
+
+    # Register a clean-up function at exit
+    def _finish_up(context):
+        if context is not None:
+            context.pop()
+            context = None
+        clear_context_caches()
+
+    if cleanup_at_exit:
+        atexit.register(_finish_up, context)
+    return context
+
+
+def count_cuda_devices():
+    if cuda.Context.get_current() is None:
+        cuda.init()
+    return cuda.Device.count()
+
+
+def get_gpu_memory(device_id):
+    """
+    Return the total memory (in GigaBytes) of a device.
+    """
+    cuda.init()
+    return cuda.Device(device_id).total_memory() / 1e9
+
+
+def is_gpu_usable():
+    """
+    Test whether at least one Nvidia GPU is available.
+    """
+    try:
+        n_gpus = count_cuda_devices()
+    except Exception as exc:
+        # Fragile
+        if exc.__str__() != "cuInit failed: no CUDA-capable device is detected":
+            raise
+        n_gpus = 0
+    res = n_gpus > 0
+    return res
+
+
+def detect_cuda_gpus():
+    """
+    Detect the available Nvidia CUDA GPUs on the current host.
+
+    Returns
+    --------
+    gpus: dict
+        Dictionary where the key is the GPU ID, and the value is a `pycuda.driver.Device` object.
+    error_msg: str
+        In the case where there is an error, the message is returned in this item.
+        Otherwise, it is a None object.
+    """
+    gpus = {}
+    error_msg = None
+    if not (__has_pycuda__):
+        return {}, __pycuda_error_msg__
+    try:
+        cuda.init()
+    except Exception as exc:
+        error_msg = str(exc)
+    if error_msg is not None:
+        return {}, error_msg
+    try:
+        n_gpus = cuda.Device.count()
+    except Exception as exc:
+        error_msg = str(exc)
+    if error_msg is not None:
+        return {}, error_msg
+    for i in range(n_gpus):
+        gpus[i] = cuda.Device(i)
+    return gpus, None
+
+
+def collect_cuda_gpus():
+    """
+    Return a dictionary of GPU ids and brief description of each CUDA-compatible
+    GPU with a few fields.
+    """
+    gpus, error_msg = detect_cuda_gpus()
+    if error_msg is not None:
+        return None
+    cuda_gpus = {}
+    for gpu_id, gpu in gpus.items():
+        cuda_gpus[gpu_id] = GPUDescription(gpu).get_dict()
+    return cuda_gpus
+
+
+def get_nvcc_version(nvcc_cmd="nvcc"):
+    try:
+        ver = "".join(pycuda_get_nvcc_version(nvcc_cmd)).split("release")[1].strip().split(" ")[0].strip(",")
+    except:
+        ver = None
+    return ver
+
+
+def check_textures_availability():
+    """
+    Check whether Cuda textures can be used.
+    The only limitation is pycuda which does not support texture objects.
+    Textures references were deprecated, and removed from Cuda 12.
+    """
+    nvcc_ver = get_nvcc_version()
+    if nvcc_ver is None:
+        return False  # unknown - can't parse NVCC version for some reason
+    nvcc_major = int(nvcc_ver.split(".")[0])
+    return nvcc_major < 12
+
+
+"""
+pycuda/driver.py
+    np.complex64: SIGNED_INT32, num_channels = 2
+    np.float64:  SIGNED_INT32, num_channels = 2
+    np.complex128: array_format.SIGNED_INT32, num_channels = 4
+
+double precision: pycuda-helpers.hpp:
+  typedef float fp_tex_float;   // --> float32
+  typedef int2 fp_tex_double;   // --> float64
+  typedef uint2 fp_tex_cfloat;  // --> complex64
+  typedef int4 fp_tex_cdouble;  // --> complex128
+"""
+
+
+def cuarray_format_to_dtype(cuarr_fmt):
+    # reverse of cuda.dtype_to_array_format
+    fmt = cuda.array_format
+    mapping = {
+        fmt.UNSIGNED_INT8: np.uint8,
+        fmt.UNSIGNED_INT16: np.uint16,
+        fmt.UNSIGNED_INT32: np.uint32,
+        fmt.SIGNED_INT8: np.int8,
+        fmt.SIGNED_INT16: np.int16,
+        fmt.SIGNED_INT32: np.int32,
+        fmt.FLOAT: np.float32,
+    }
+    if cuarr_fmt not in mapping:
+        raise TypeError("Unknown format %s" % cuarr_fmt)
+    return mapping[cuarr_fmt]
+
+
+def cuarray_shape_dtype(cuarray):
+    desc = cuarray.get_descriptor_3d()
+    shape = (desc.height, desc.width)
+    if desc.depth > 0:
+        shape = (desc.depth,) + shape
+    dtype = cuarray_format_to_dtype(desc.format)
+    return shape, dtype
+
+
+def get_shape_dtype(arr):
+    if isinstance(arr, garray.GPUArray) or isinstance(arr, np.ndarray):
+        return arr.shape, arr.dtype
+    elif isinstance(arr, cuda.Array):
+        return cuarray_shape_dtype(arr)
+    else:
+        raise ValueError("Unknown array type %s" % str(type(arr)))
+
+
+def copy_array(dst, src, check=False, src_dtype=None, dst_x_in_bytes=0, dst_y=0):
+    """
+    Copy a source array to a destination array.
+    Source and destination can be either numpy.ndarray, pycuda.Driver.Array,
+    or pycuda.gpuarray.GPUArray.
+
+    Parameters
+    -----------
+    dst: pycuda.driver.Array or pycuda.gpuarray.GPUArray or numpy.ndarray
+        Destination array. Its content will be overwritten by copy.
+    src: pycuda.driver.Array or pycuda.gpuarray.GPUArray or numpy.ndarray
+        Source array.
+    check: bool, optional
+        Whether to check src and dst shape and data type.
+    """
+
+    shape_src, dtype_src = get_shape_dtype(src)
+    shape_dst, dtype_dst = get_shape_dtype(dst)
+    dtype_src = src_dtype or dtype_src
+    if check:
+        if shape_src != shape_dst:
+            raise ValueError("shape_src != shape_dst : have %s and %s" % (str(shape_src), str(shape_dst)))
+        if dtype_src != dtype_dst:
+            raise ValueError("dtype_src != dtype_dst : have %s and %s" % (str(dtype_src), str(dtype_dst)))
+    if len(shape_src) == 2:
+        copy = cuda.Memcpy2D()
+        h, w = shape_src
+    elif len(shape_src) == 3:
+        copy = cuda.Memcpy3D()
+        d, h, w = shape_src
+        copy.depth = d
+    else:
+        raise ValueError("Expected arrays with 2 or 3 dimensions")
+
+    if isinstance(src, cuda.Array):
+        copy.set_src_array(src)
+    elif isinstance(src, garray.GPUArray):
+        copy.set_src_device(src.gpudata)
+    else:  # numpy
+        copy.set_src_host(src)
+
+    if isinstance(dst, cuda.Array):
+        copy.set_dst_array(dst)
+        # Support offset (x, y) in target (for copying to texture)
+        copy.dst_x_in_bytes = dst_x_in_bytes
+        copy.dst_y = dst_y
+    elif isinstance(dst, garray.GPUArray):
+        copy.set_dst_device(dst.gpudata)
+    else:  # numpy
+        copy.set_dst_host(dst)
+
+    copy.width_in_bytes = copy.dst_pitch = w * np.dtype(dtype_src).itemsize
+    copy.dst_height = copy.height = h
+    # ??
+    if len(shape_src) == 2:
+        copy(True)
+    else:
+        copy()
+    ###
+
+
+def copy_big_gpuarray(dst, src, itemsize=4, checks=False):
+    """
+    Copy a big `pycuda.gpuarray.GPUArray` into another.
+    Transactions of more than 2**32 -1 octets fail, so are doing several
+    partial copies of smaller arrays.
+    """
+    d2h = isinstance(dst, np.ndarray)
+    if checks:
+        assert dst.dtype == src.dtype
+        assert dst.shape == src.shape
+    limit = 2**32 - 1
+    if np.prod(dst.shape) * itemsize < limit:
+        if d2h:
+            src.get(ary=dst)
+        else:
+            dst[:] = src[:]
+        return
+
+    def get_shape2(shape):
+        shape2 = list(shape)
+        while np.prod(shape2) * 4 > limit:
+            shape2[0] //= 2
+        return tuple(shape2)
+
+    shape2 = get_shape2(dst.shape)
+    nz0 = dst.shape[0]
+    nz = shape2[0]
+    n_transfers = ceil(nz0 / nz)
+    for i in range(n_transfers):
+        zmax = min((i + 1) * nz, nz0)
+        if d2h:
+            src[i * nz : zmax].get(ary=dst[i * nz : zmax])
+        else:
+            dst[i * nz : zmax] = src[i * nz : zmax]
+
+
+def replace_array_memory(arr, new_shape):
+    """
+    Replace the underlying buffer data of a  `pycuda.gpuarray.GPUArray`.
+    This function is dangerous !
+    It should merely be used to clear memory, the array should not be used afterwise.
+    """
+    arr.gpudata.free()
+    arr.gpudata = arr.allocator(int(np.prod(new_shape) * arr.dtype.itemsize))
+    arr.shape = new_shape
+    # TODO re-compute strides
+    return arr
+
+
+def pycuda_to_cupy(arr_pycuda):
+    arr_cupy_mem = cupy.cuda.UnownedMemory(arr_pycuda.ptr, arr_pycuda.size, arr_pycuda)
+    arr_cupy_memptr = cupy.cuda.MemoryPointer(arr_cupy_mem, offset=0)
+    return cupy.ndarray(arr_pycuda.shape, dtype=arr_pycuda.dtype, memptr=arr_cupy_memptr)  # pylint: disable=E1123
+
+
+def cupy_to_pycuda(arr_cupy):
+    return garray.empty(arr_cupy.shape, arr_cupy.dtype, gpudata=arr_cupy.data.ptr)

build/lib/build/lib/nabu/estimation/__init__.py

@@ -0,0 +1,12 @@
+from .alignment import AlignmentBase
+from .cor import (
+    CenterOfRotation,
+    CenterOfRotationSlidingWindow,
+    CenterOfRotationGrowingWindow,
+    CenterOfRotationAdaptiveSearch,
+)
+from .cor_sino import SinoCor
+from .distortion import estimate_flat_distortion
+from .focus import CameraFocus
+from .tilt import CameraTilt
+from .translation import DetectorTranslationAlongBeam