nabu 2024.1.1__py3-none-any.whl → 2024.1.3__py3-none-any.whl

build/lib/build/lib/build/lib/nabu/preproc/double_flatfield.py

@@ -1,212 +0,0 @@
-from os import path
-import numpy as np
-from scipy.ndimage import gaussian_filter
-from silx.io.url import DataUrl
-from ..utils import check_supported, check_shape, get_2D_3D_shape
-from ..io.reader import Readers
-from ..io.writer import Writers
-from .ccd import Log
-
-
-class DoubleFlatField:
-    _default_h5_path = "/entry/double_flatfield/results"
-    _small = 1e-7
-
-    def __init__(
-        self,
-        shape,
-        result_url=None,
-        sub_region=None,
-        detector_corrector=None,
-        input_is_mlog=True,
-        output_is_mlog=False,
-        average_is_on_log=False,
-        sigma_filter=None,
-        filter_mode="reflect",
-        log_clip_min=None,
-        log_clip_max=None,
-    ):
-        """
-        Init double flat field by summing a series of urls and considering the same subregion of them.
-
-        Parameters
-        ----------
-        shape: tuple
-            Expected shape of radios chunk to process
-        result_url: url, optional
-            where the double-flatfield is stored after being computed, and
-            possibly read (instead of re-computed) before processing the images.
-        sub_region: tuple, optional
-            If provided, this must be a tuple in the form
-            (start_x, end_x, start_y, end_y). Each image will be cropped to this
-            region. This is used to specify a chunk of files.
-            Each of the parameters can be None, in this case the default start
-            and end are taken in each dimension.
-        input_is_mlog:  boolean, default True
-            the input is considred as minus logarithm of normalised radios
-        output_is_mlog:  boolean, default True
-            the output is considred as minus logarithm of normalised radios
-        average_is_on_log : boolean, False
-            the minus logarithm of the data is averaged
-            the clipping value that is applied prior to the logarithm
-        sigma_filter: optional
-            if given a high pass filter is applied by signal -gaussian_filter(signal,sigma,filter_mode)
-        filter_mode: optional, default 'reflect'
-            the padding scheme applied a the borders ( same as scipy.ndimage.filtrs.gaussian_filter)
-
-        """
-        self.radios_shape = get_2D_3D_shape(shape)
-        self.n_angles = self.radios_shape[0]
-        self.shape = self.radios_shape[1:]
-        self._log_clip_min = log_clip_min
-        self._log_clip_max = log_clip_max
-        self._init_filedump(result_url, sub_region, detector_corrector)
-        self._init_processing(input_is_mlog, output_is_mlog, average_is_on_log, sigma_filter, filter_mode)
-        self._computed = False
-
-    def _get_reader_writer_class(self):
-        ext = path.splitext(self.result_url.file_path())[-1].replace(".", "")
-        check_supported(ext, list(Writers.keys()), "file format")
-        self._writer_cls = Writers[ext]
-        self._reader_cls = Readers[ext]
-
-    def _load_dff_dump(self):
-        res = self.reader.get_data(self.result_url)
-        if self.detector_corrector is not None:
-            if res.ndim == 2:
-                res = self.detector_corrector.transform(res)
-            else:
-                for i in range(res.shape[0]):
-                    res[i] = self.detector_corrector.transform(res[i])
-
-        if res.ndim == 3 and res.shape[0] == 1:
-            res = res.reshape(res.shape[1], res.shape[2])
-        if res.shape != self.shape:
-            raise ValueError(
-                "Data in %s has shape %s, but expected %s"
-                % (self.result_url.file_path(), str(res.shape), str(self.shape))
-            )
-        return res
-
-    def _init_filedump(self, result_url, sub_region, detector_corrector=None):
-        if isinstance(result_url, str):
-            result_url = DataUrl(file_path=result_url, data_path=self._default_h5_path)
-        self.sub_region = sub_region
-        self.detector_corrector = detector_corrector
-        self.result_url = result_url
-        self.writer = None
-        self.reader = None
-        if self.result_url is None:
-            return
-        self._get_reader_writer_class()
-        if path.exists(result_url.file_path()):
-            if detector_corrector is None:
-                adapted_subregion = sub_region
-            else:
-                adapted_subregion = self.detector_corrector.get_adapted_subregion(sub_region)
-            self.reader = self._reader_cls(sub_region=adapted_subregion)
-        else:
-            self.writer = self._writer_cls(self.result_url.file_path())
-
-    def _init_processing(self, input_is_mlog, output_is_mlog, average_is_on_log, sigma_filter, filter_mode):
-        self.input_is_mlog = input_is_mlog
-        self.output_is_mlog = output_is_mlog
-        self.average_is_on_log = average_is_on_log
-        self.sigma_filter = sigma_filter
-        if self.sigma_filter is not None and abs(float(self.sigma_filter)) < 1e-4:
-            self.sigma_filter = None
-        self.filter_mode = filter_mode
-        proc = lambda x, o: np.copyto(o, x)
-        self._mlog = Log((1,) + self.shape, clip_min=self._log_clip_min, clip_max=self._log_clip_max)
-
-        if self.input_is_mlog:
-            if not self.average_is_on_log:
-                proc = lambda x, o: np.exp(-x, out=o)
-        else:
-            if self.average_is_on_log:
-                proc = self._proc_mlog
-
-        postproc = lambda x: x
-        if self.output_is_mlog:
-            if not self.average_is_on_log:
-                postproc = self._proc_mlog
-        else:
-            if self.average_is_on_log:
-                postproc = lambda x: np.exp(-x)
-
-        self.proc = proc
-        self.postproc = postproc
-
-    def _proc_mlog(self, x, o):
-        o[:] = x[:]
-        self._mlog.take_logarithm(o)
-        return o
-
-    def compute_double_flatfield(self, radios, recompute=False):
-        """
-        Read the radios and generate the "double flat field" by averaging
-        and possibly other processing.
-
-        Parameters
-        ----------
-        radios: array
-            Input radios chunk.
-        recompute: bool, optional
-            Whether to recompute the double flatfield if already computed.
-        """
-        if self._computed and not (recompute):
-            return self.doubleflatfield  # pylint: disable=E0203
-        acc = np.zeros(radios[0].shape, "f")
-        tmpdat = np.zeros(radios[0].shape, "f")
-        for ima in radios:
-            self.proc(ima, tmpdat)
-            acc += tmpdat
-
-        acc /= radios.shape[0]
-
-        if self.sigma_filter is not None:
-            acc = acc - gaussian_filter(acc, self.sigma_filter, mode=self.filter_mode)
-        self.doubleflatfield = self.postproc(acc)
-        # Handle small values to avoid issues when dividing
-        self.doubleflatfield[np.abs(self.doubleflatfield) < self._small] = 1.0
-        self.doubleflatfield = self.doubleflatfield.astype("f")
-
-        if self.writer is not None:
-            self.writer.write(self.doubleflatfield, "double_flatfield")
-        self._computed = True
-        return self.doubleflatfield
-
-    def get_double_flatfield(self, radios=None, compute=False):
-        """
-        Get the double flat field or a subregion of it.
-
-        Parameters
-        ----------
-        radios: array, optional
-            Input radios chunk
-        compute: bool, optional
-            Whether to compute the double flatfield anyway even if a dump file
-            exists.
-        """
-        if self.reader is None:
-            if radios is None:
-                raise ValueError("result_url was not provided. Please provide 'radios' to this function")
-            return self.compute_double_flatfield(radios)
-
-        if radios is not None and compute:
-            res = self.compute_double_flatfield(radios)
-        else:
-            res = self._load_dff_dump()
-            self._computed = True
-        return res
-
-    def apply_double_flatfield(self, radios):
-        """
-        Apply the "double flatfield" filter on a chunk of radios.
-        The processing is done in-place !
-        """
-        check_shape(radios.shape, self.radios_shape, "radios")
-        dff = self.get_double_flatfield(radios=radios)
-        for i in range(self.n_angles):
-            radios[i] /= dff
-        return radios

build/lib/build/lib/build/lib/nabu/preproc/double_flatfield_cuda.py

@@ -1,174 +0,0 @@
-from .double_flatfield import DoubleFlatField
-from ..utils import check_shape
-from ..cuda.utils import __has_pycuda__
-from ..cuda.processing import CudaProcessing
-from ..processing.unsharp_cuda import CudaUnsharpMask
-from .ccd_cuda import CudaLog
-
-if __has_pycuda__:
-    import pycuda.gpuarray as garray
-    import pycuda.cumath as cumath
-
-
-class CudaDoubleFlatField(DoubleFlatField):
-    def __init__(
-        self,
-        shape,
-        result_url=None,
-        sub_region=None,
-        detector_corrector=None,
-        input_is_mlog=True,
-        output_is_mlog=False,
-        average_is_on_log=False,
-        sigma_filter=None,
-        filter_mode="reflect",
-        log_clip_min=None,
-        log_clip_max=None,
-        cuda_options=None,
-    ):
-        """
-        Init double flat field with Cuda backend.
-        """
-        self.cuda_processing = CudaProcessing(**(cuda_options or {}))
-        super().__init__(
-            shape,
-            result_url=result_url,
-            sub_region=sub_region,
-            detector_corrector=detector_corrector,
-            input_is_mlog=input_is_mlog,
-            output_is_mlog=output_is_mlog,
-            average_is_on_log=average_is_on_log,
-            sigma_filter=sigma_filter,
-            filter_mode=filter_mode,
-            log_clip_min=log_clip_min,
-            log_clip_max=log_clip_max,
-        )
-        self._init_gaussian_filter()
-
-    def _init_gaussian_filter(self):
-        if self.sigma_filter is None:
-            return
-        self._unsharp_mask = CudaUnsharpMask(self.shape, self.sigma_filter, -1.0, mode=self.filter_mode, method="log")
-
-    @staticmethod
-    def _proc_copy(x, o):
-        o[:] = x[:]
-        return o
-
-    @staticmethod
-    def _proc_expm(x, o):
-        o[:] = x[:]
-        o[:] *= -1
-        cumath.exp(o, out=o)
-        return o
-
-    def _init_processing(self, input_is_mlog, output_is_mlog, average_is_on_log, sigma_filter, filter_mode):
-        self.input_is_mlog = input_is_mlog
-        self.output_is_mlog = output_is_mlog
-        self.average_is_on_log = average_is_on_log
-        self.sigma_filter = sigma_filter
-        if self.sigma_filter is not None and abs(float(self.sigma_filter)) < 1e-4:
-            self.sigma_filter = None
-        self.filter_mode = filter_mode
-        # proc = lambda x,o: np.copyto(o, x)
-        proc = self._proc_copy
-        self._mlog = CudaLog((1,) + self.shape, clip_min=self._log_clip_min, clip_max=self._log_clip_max)
-        if self.input_is_mlog:
-            if not self.average_is_on_log:
-                # proc = lambda x,o: np.exp(-x, out=o)
-                proc = self._proc_expm
-        else:
-            if self.average_is_on_log:
-                # proc = lambda x,o: -np.log(x, out=o)
-                proc = self._proc_mlog
-
-        # postproc = lambda x: x
-        postproc = self._proc_copy
-        if self.output_is_mlog:
-            if not self.average_is_on_log:
-                # postproc = lambda x: -np.log(x)
-                postproc = self._proc_mlog
-        else:
-            if self.average_is_on_log:
-                # postproc = lambda x: np.exp(-x)
-                postproc = self._proc_expm
-
-        self.proc = proc
-        self.postproc = postproc
-
-    def compute_double_flatfield(self, radios, recompute=False):
-        """
-        Read the radios and generate the "double flat field" by averaging
-        and possibly other processing.
-
-        Parameters
-        ----------
-        radios: array
-            Input radios chunk.
-        recompute: bool, optional
-            Whether to recompute the double flatfield if already computed.
-        """
-        if not (isinstance(radios, garray.GPUArray)):
-            raise ValueError("Expected pycuda.gpuarray.GPUArray for radios")
-        if self._computed and not (recompute):
-            return self.doubleflatfield
-        acc = garray.zeros(radios[0].shape, "f")
-        tmpdat = garray.zeros(radios[0].shape, "f")
-        for i in range(radios.shape[0]):
-            self.proc(radios[i], tmpdat)
-            acc += tmpdat
-
-        acc /= radios.shape[0]
-
-        if self.sigma_filter is not None:
-            # acc = acc - gaussian_filter(acc, self.sigma_filter, mode=self.filter_mode)
-            self._unsharp_mask.unsharp(acc, tmpdat)
-            acc[:] = tmpdat[:]
-        self.postproc(acc, tmpdat)
-        self.doubleflatfield = tmpdat
-        # Handle small values to avoid issues when dividing
-        # self.doubleflatfield[np.abs(self.doubleflatfield) < self._small] = 1.
-        cumath.fabs(self.doubleflatfield, out=acc)
-        acc -= self._small  # acc = abs(doubleflatfield) - _small
-        garray.if_positive(acc, self.doubleflatfield, garray.zeros_like(acc) + self._small, out=self.doubleflatfield)
-
-        if self.writer is not None:
-            self.writer.write(self.doubleflatfield.get(), "double_flatfield")
-        self._computed = True
-        return self.doubleflatfield
-
-    def get_double_flatfield(self, radios=None, compute=False):
-        """
-        Get the double flat field or a subregion of it.
-
-        Parameters
-        ----------
-        radios: array, optional
-            Input radios chunk
-        compute: bool, optional
-            Whether to compute the double flatfield anyway even if a dump file
-            exists.
-        """
-        if self.reader is None:
-            if radios is None:
-                raise ValueError("result_url was not provided. Please provide 'radios' to this function")
-            return self.compute_double_flatfield(radios)
-
-        if radios is not None and compute:
-            res = self.compute_double_flatfield(radios)
-        else:
-            res = self._load_dff_dump()
-            res = garray.to_gpu(res)
-            self._computed = True
-        return res
-
-    def apply_double_flatfield(self, radios):
-        """
-        Apply the "double flatfield" filter on a chunk of radios.
-        The processing is done in-place !
-        """
-        check_shape(radios.shape, self.radios_shape, "radios")
-        dff = self.get_double_flatfield(radios=radios)
-        for i in range(self.n_angles):
-            radios[i] /= dff
-        return radios

build/lib/build/lib/build/lib/nabu/preproc/double_flatfield_variable_region.py

@@ -1,68 +0,0 @@
-from .double_flatfield import (
-    DoubleFlatField,
-    DoubleFlatField,
-    check_shape,
-    get_2D_3D_shape,
-)
-from ..misc.binning import get_binning_function
-
-
-class DoubleFlatFieldVariableRegion(DoubleFlatField):
-    def __init__(
-        self,
-        shape,
-        result_url=None,
-        binning_x=None,
-        binning_z=None,
-        detector_corrector=None,
-    ):
-        """This class provides the division by the double flat field.
-        At variance with the standard class, it store as member the
-        whole field, and performs the division by the proper region
-        according to the positionings of the processed radios
-        which is passed by the argument array sub_regions_per_radio to
-        the method apply_double_flatfield_for_sub_regions
-        """
-
-        self.radios_shape = get_2D_3D_shape(shape)
-        self.n_angles = self.radios_shape[0]
-        self.shape = self.radios_shape[1:]
-        self._init_filedump(result_url, None, detector_corrector)
-
-        data = self._load_dff_full_dump()
-
-        if (binning_z, binning_x) != (1, 1):
-            print(" (binning_z, binning_x) ", (binning_z, binning_x))
-            binning_function = get_binning_function((binning_z, binning_x))
-            if binning_function is None:
-                raise NotImplementedError(f"Binning factor for {(binning_z, binning_x)} is not implemented yet")
-
-            self.data = binning_function(data)
-
-        else:
-            self.data = data
-
-    def _load_dff_full_dump(self):
-        res = self.reader.get_data(self.result_url)
-        if self.detector_corrector is not None:
-            self.detector_corrector.set_full_transformation()
-            res = self.detector_corrector.transform(res, do_full=True)
-
-        return res
-
-    def apply_double_flatfield_for_sub_regions(self, radios, sub_regions_per_radio):
-        """
-        Apply the "double flatfield" filter on a chunk of radios.
-        The processing is done in-place !
-        """
-        my_double_ff = self.data
-
-        for i in range(radios.shape[0]):
-            s_x, e_x, s_y, e_y = sub_regions_per_radio[i]
-
-            dff = my_double_ff[s_y:e_y, s_x:e_x]
-
-            check_shape(radios[i].shape, dff.shape, "radios")
-
-            radios[i] /= dff
-        return radios