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

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

@@ -0,0 +1,212 @@
+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/build/lib/build/lib/build/lib/build/lib/build/lib/nabu/preproc/double_flatfield_cuda.py

@@ -0,0 +1,174 @@
+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/build/lib/build/lib/build/lib/build/lib/build/lib/nabu/preproc/double_flatfield_variable_region.py

@@ -0,0 +1,68 @@
+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