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

build/lib/nabu/preproc/flatfield.py

@@ -0,0 +1,448 @@
+from multiprocessing.pool import ThreadPool
+from bisect import bisect_left
+import numpy as np
+from ..io.reader import load_images_from_dataurl_dict
+from ..utils import check_supported, get_num_threads
+
+
+class FlatFieldArrays:
+    """
+    A class for flat-field normalization
+    """
+
+    # the variable below will be True for the derived class
+    # which is taylored for to helical case
+    _full_shape = False
+
+    _supported_interpolations = ["linear", "nearest"]
+
+    def __init__(
+        self,
+        radios_shape: tuple,
+        flats,
+        darks,
+        radios_indices=None,
+        interpolation: str = "linear",
+        distortion_correction=None,
+        nan_value=1.0,
+        radios_srcurrent=None,
+        flats_srcurrent=None,
+        n_threads=None,
+    ):
+        """
+        Initialize a flat-field normalization process.
+
+        Parameters
+        ----------
+        radios_shape: tuple
+            A tuple describing the shape of the radios stack, in the form
+            `(n_radios, n_z, n_x)`.
+        flats: dict
+            Dictionary where each key is the flat index, and the value is a
+            numpy.ndarray of the flat image.
+        darks: dict
+            Dictionary where each key is the dark index, and the value is a
+            numpy.ndarray of the dark image.
+        radios_indices: array of int, optional
+            Array containing the radios indices in the scan. `radios_indices[0]` is the index
+            of the first radio, and so on.
+        interpolation: str, optional
+            Interpolation method for flat-field. See below for more details.
+        distortion_correction: DistortionCorrection, optional
+            A DistortionCorrection object. If provided, it is used to correct flat distortions based on each radio.
+        nan_value: float, optional
+            Which float value is used to replace nan/inf after flat-field.
+        radios_srcurrent: array, optional
+            Array with the same shape as radios_indices. Each item contains the synchrotron electric current.
+            If not None, normalization with current is applied.
+            Please refer to "Notes" for more information on this normalization.
+        flats_srcurrent: array, optional
+            Array with the same length as "flats". Each item is a measurement of the synchrotron electric current
+            for the corresponding flat. The items must be ordered in the same order as the flats indices (`flats.keys()`).
+            This parameter must be used along with 'radios_srcurrent'.
+            Please refer to "Notes" for more information on this normalization.
+        n_threads: int or None, optional
+            Number of threads to use for flat-field correction. Default is to use half the threads.
+
+        Important
+        ----------
+        `flats` and `darks` are expected to be a dictionary with integer keys (the flats/darks indices)
+        and numpy array values.
+        You can use the following helper functions: `nabu.io.reader.load_images_from_dataurl_dict`
+        and `nabu.io.utils.create_dict_of_indices`
+
+
+        Notes
+        ------
+        Usually, when doing a scan, only one or a few darks/flats are acquired.
+        However, the flat-field normalization has to be performed on each radio,
+        although incoming beam can fluctuate between projections.
+        The usual way to overcome this is to interpolate between flats.
+        If interpolation="nearest", the first flat is used for the first
+        radios subset, the second flat is used for the second radios subset,
+        and so on.
+        If interpolation="linear", the normalization is done as a linear
+        function of the radio index.
+
+        The normalization with synchrotron electric current is done as follows.
+        Let s = sr/sr_max denote the ratio between current and maximum current,
+        D be the dark-current frame, and X' be the normalized frame. Then:
+          srcurrent_normalization(X) = X' = (X - D)/s + D
+          flatfield_normalization(X') = (X' - D)/(F' - D) = (X - D) / (F - D) * sF/sX
+        So current normalization boils down to a scalar multiplication after flat-field.
+        """
+        if self._full_shape:
+            # this is never going to happen in this base class. But in the derived class for helical
+            # which needs to keep the full shape
+            if radios_indices is not None:
+                radios_shape = (len(radios_indices),) + radios_shape[1:]
+
+        self._set_parameters(radios_shape, radios_indices, interpolation, nan_value)
+        self._set_flats_and_darks(flats, darks)
+        self._precompute_flats_indices_weights()
+        self._configure_srcurrent_normalization(radios_srcurrent, flats_srcurrent)
+        self.distortion_correction = distortion_correction
+        self.n_threads = min(1, get_num_threads(n_threads) // 2)
+
+    def _set_parameters(self, radios_shape, radios_indices, interpolation, nan_value):
+        self._set_radios_shape(radios_shape)
+        if radios_indices is None:
+            radios_indices = np.arange(0, self.n_radios, dtype=np.int32)
+        else:
+            radios_indices = np.array(radios_indices, dtype=np.int32)
+            self._check_radios_and_indices_congruence(radios_indices)
+
+        self.radios_indices = radios_indices
+        self.interpolation = interpolation
+        check_supported(interpolation, self._supported_interpolations, "Interpolation mode")
+        self.nan_value = nan_value
+        self._radios_idx_to_pos = dict(zip(self.radios_indices, np.arange(self.radios_indices.size)))
+
+    def _set_radios_shape(self, radios_shape):
+        if len(radios_shape) == 2:
+            self.radios_shape = (1,) + radios_shape
+        elif len(radios_shape) == 3:
+            self.radios_shape = radios_shape
+        else:
+            raise ValueError("Expected radios to have 2 or 3 dimensions")
+        n_radios, n_z, n_x = self.radios_shape
+        self.n_radios = n_radios
+        self.n_angles = n_radios
+        self.shape = (n_z, n_x)
+
+    def _set_flats_and_darks(self, flats, darks):
+        self._check_frames(flats, "flats", 1, 9999)
+        self.n_flats = len(flats)
+        self.flats = flats
+        self._sorted_flat_indices = sorted(self.flats.keys())
+
+        if self._full_shape:
+            # this is never going to happen in this base class. But in the derived class for helical
+            # which needs to keep the full shape
+            self.shape = flats[self._sorted_flat_indices[0]].shape
+
+        self._flat2arrayidx = dict(zip(self._sorted_flat_indices, np.arange(self.n_flats)))
+        self.flats_arr = np.zeros((self.n_flats,) + self.shape, "f")
+        for i, idx in enumerate(self._sorted_flat_indices):
+            self.flats_arr[i] = self.flats[idx]
+
+        self._check_frames(darks, "darks", 1, 1)
+        self.darks = darks
+        self.n_darks = len(darks)
+        self._sorted_dark_indices = sorted(self.darks.keys())
+        self._dark = None
+
+    def _check_frames(self, frames, frames_type, min_frames_required, max_frames_supported):
+        n_frames = len(frames)
+        if n_frames < min_frames_required:
+            raise ValueError("Need at least %d %s" % (min_frames_required, frames_type))
+        if n_frames > max_frames_supported:
+            raise ValueError(
+                "Flat-fielding with more than %d %s is not supported" % (max_frames_supported, frames_type)
+            )
+        self._check_frame_shape(frames, frames_type)
+
+    def _check_frame_shape(self, frames, frames_type):
+        for frame_idx, frame in frames.items():
+            if frame.shape != self.shape:
+                raise ValueError(
+                    "Invalid shape for %s %s: expected %s, but got %s"
+                    % (frames_type, frame_idx, str(self.shape), str(frame.shape))
+                )
+
+    def _check_radios_and_indices_congruence(self, radios_indices):
+        if radios_indices.size != self.n_radios:
+            raise ValueError(
+                "Expected radios_indices to have length %s = n_radios, but got length %d"
+                % (self.n_radios, radios_indices.size)
+            )
+
+    def _precompute_flats_indices_weights(self):
+        """
+        Build two arrays: "indices" and "weights".
+        These arrays contain pre-computed information so that the interpolated flat is obtained with
+
+           flat_interpolated = weight_prev * flat_prev  + weight_next * flat_next
+
+        where
+           weight_prev, weight_next = weights[2*i], weights[2*i+1]
+           idx_prev, idx_next = indices[2*i], indices[2*i+1]
+           flat_prev, flat_next = flats[idx_prev], flats[idx_next]
+
+        In words:
+          - If a projection has an index between two flats, the equivalent flat is a linear interpolation
+            between "previous flat" and "next flat".
+          - If a projection has the same index as a flat, only this flat is used for normalization
+            (this case normally never occurs, but it's handled in the code)
+        """
+
+        def _interp_linear(idx, prev_next):
+            if len(prev_next) == 1:  # current index corresponds to an acquired flat
+                weights = (1, 0)
+                f_idx = (self._flat2arrayidx[prev_next[0]], -1)
+            else:
+                prev_idx, next_idx = prev_next
+                delta = next_idx - prev_idx
+                w1 = 1 - (idx - prev_idx) / delta
+                w2 = 1 - (next_idx - idx) / delta
+                weights = (w1, w2)
+                f_idx = (self._flat2arrayidx[prev_idx], self._flat2arrayidx[next_idx])
+            return f_idx, weights
+
+        def _interp_nearest(idx, prev_next):
+            if len(prev_next) == 1:  # current index corresponds to an acquired flat
+                weights = (1, 0)
+                f_idx = (self._flat2arrayidx[prev_next[0]], -1)
+            else:
+                prev_idx, next_idx = prev_next
+                idx_to_take = prev_idx if abs(idx - prev_idx) < abs(idx - next_idx) else next_idx
+                weights = (1, 0)
+                f_idx = (self._flat2arrayidx[idx_to_take], -1)
+            return f_idx, weights
+
+        self.flats_idx = np.zeros((self.n_radios, 2), dtype=np.int32)
+        self.flats_weights = np.zeros((self.n_radios, 2), dtype=np.float32)
+        for i, idx in enumerate(self.radios_indices):
+            prev_next = self.get_previous_next_indices(self._sorted_flat_indices, idx)
+            if self.interpolation == "nearest":
+                f_idx, weights = _interp_nearest(idx, prev_next)
+            elif self.interpolation == "linear":
+                f_idx, weights = _interp_linear(idx, prev_next)
+            self.flats_idx[i] = f_idx
+            self.flats_weights[i] = weights
+
+    # pylint: disable=E1307
+    def _configure_srcurrent_normalization(self, radios_srcurrent, flats_srcurrent):
+        self.normalize_srcurrent = False
+        if radios_srcurrent is None or flats_srcurrent is None:
+            return
+        radios_srcurrent = np.array(radios_srcurrent)
+        if radios_srcurrent.size != self.n_radios:
+            raise ValueError(
+                "Expected 'radios_srcurrent' to have %d elements but got %d" % (self.n_radios, radios_srcurrent.size)
+            )
+        flats_srcurrent = np.array(flats_srcurrent)
+        if flats_srcurrent.size != self.n_flats:
+            raise ValueError(
+                "Expected 'flats_srcurrent' to have %d elements but got %d" % (self.n_flats, flats_srcurrent.size)
+            )
+        self.normalize_srcurrent = True
+        self.radios_srcurrent = radios_srcurrent
+        self.flats_srcurrent = flats_srcurrent
+        self.srcurrent_ratios = np.zeros(self.n_radios, "f")
+        # Flats SRCurrent is obtained with "nearest" interp, to emulate an already-done flats SR current normalization
+        for i, radio_idx in enumerate(self.radios_indices):
+            flat_idx = self.get_nearest_index(self._sorted_flat_indices, radio_idx)
+            flat_srcurrent = self.flats_srcurrent[self._flat2arrayidx[flat_idx]]
+            self.srcurrent_ratios[i] = flat_srcurrent / self.radios_srcurrent[i]
+
+    @staticmethod
+    def get_previous_next_indices(arr, idx):
+        pos = bisect_left(arr, idx)
+        if pos == len(arr):  # outside range
+            return (arr[-1],)
+        if arr[pos] == idx:
+            return (idx,)
+        if pos == 0:
+            return (arr[0],)
+        return arr[pos - 1], arr[pos]
+
+    @staticmethod
+    def get_nearest_index(arr, idx):
+        pos = bisect_left(arr, idx)
+        if pos == len(arr) or arr[pos] == idx:
+            return arr[-1]
+        return arr[pos - 1] if idx - arr[pos - 1] < arr[pos] - idx else arr[pos]
+
+    @staticmethod
+    def interp(pos, indices, weights, array, slice_y=slice(None, None), slice_x=slice(None, None)):
+        """
+        Interpolate between two values. The interpolator consists in pre-computed arrays such that
+
+           prev, next = indices[pos]
+           w1, w2 = weights[pos]
+           interpolated_value = w1 * array[prev] + w2 * array[next]
+        """
+        prev_idx = indices[pos, 0]
+        next_idx = indices[pos, 1]
+
+        if slice_y != slice(None, None) or slice_x != slice(None, None):
+            w1 = weights[pos, 0][slice_y, slice_x]
+            w2 = weights[pos, 1][slice_y, slice_x]
+        else:
+            w1 = weights[pos, 0]
+            w2 = weights[pos, 1]
+
+        if next_idx == -1:
+            val = array[prev_idx]
+        else:
+            val = w1 * array[prev_idx] + w2 * array[next_idx]
+        return val
+
+    def get_flat(self, pos, dtype=np.float32, slice_y=slice(None, None), slice_x=slice(None, None)):
+        flat = self.interp(pos, self.flats_idx, self.flats_weights, self.flats_arr, slice_y=slice_y, slice_x=slice_x)
+        if flat.dtype != dtype:
+            flat = np.ascontiguousarray(flat, dtype=dtype)
+        return flat
+
+    def get_dark(self):
+        if self._dark is None:
+            first_dark_idx = self._sorted_dark_indices[0]
+            dark = np.ascontiguousarray(self.darks[first_dark_idx], dtype=np.float32)
+            self._dark = dark
+        return self._dark
+
+    def remove_invalid_values(self, img):
+        if self.nan_value is None:
+            return
+        invalid_mask = np.logical_not(np.isfinite(img))
+        img[invalid_mask] = self.nan_value
+
+    def normalize_radios(self, radios):
+        """
+        Apply a flat-field normalization, with the current parameters, to a stack
+        of radios.
+        The processing is done in-place, meaning that the radios content is overwritten.
+
+        Parameters
+        -----------
+        radios: numpy.ndarray
+            Radios chunk
+        """
+        do_flats_distortion_correction = self.distortion_correction is not None
+        dark = self.get_dark()
+
+        def apply_flatfield(i):
+            radio_data = radios[i]
+            radio_data -= dark
+            flat = self.get_flat(i)
+            flat = flat - dark
+            if do_flats_distortion_correction:
+                flat = self.distortion_correction.estimate_and_correct(flat, radio_data)
+            np.divide(radio_data, flat, out=radio_data)
+            self.remove_invalid_values(radio_data)
+
+        if self.n_threads > 2:
+            with ThreadPool(self.n_threads) as tp:
+                tp.map(apply_flatfield, range(self.n_radios))
+        else:
+            for i in range(self.n_radios):
+                apply_flatfield(i)
+
+        if self.normalize_srcurrent:
+            radios *= self.srcurrent_ratios[:, np.newaxis, np.newaxis]
+        return radios
+
+    def normalize_single_radio(
+        self, radio, radio_idx, dtype=np.float32, slice_y=slice(None, None), slice_x=slice(None, None)
+    ):
+        """
+        Apply a flat-field normalization to a single projection image.
+        """
+        dark = self.get_dark()[slice_y, slice_x]
+        radio -= dark
+        radio_pos = self._radios_idx_to_pos[radio_idx]
+        flat = self.get_flat(radio_pos, dtype=dtype, slice_y=slice_y, slice_x=slice_x)
+        flat = flat - dark
+        if self.distortion_correction is not None:
+            flat = self.distortion_correction.estimate_and_correct(flat, radio)
+        radio /= flat
+        if self.normalize_srcurrent:
+            radio *= self.srcurrent_ratios[radio_pos]
+        self.remove_invalid_values(radio)
+        return radio
+
+
+FlatField = FlatFieldArrays
+
+
+class FlatFieldDataUrls(FlatField):
+    def __init__(
+        self,
+        radios_shape: tuple,
+        flats: dict,
+        darks: dict,
+        radios_indices=None,
+        interpolation: str = "linear",
+        distortion_correction=None,
+        nan_value=1.0,
+        radios_srcurrent=None,
+        flats_srcurrent=None,
+        **chunk_reader_kwargs,
+    ):
+        """
+        Initialize a flat-field normalization process with DataUrls.
+
+        Parameters
+        ----------
+        radios_shape: tuple
+            A tuple describing the shape of the radios stack, in the form
+            `(n_radios, n_z, n_x)`.
+        flats: dict
+            Dictionary where the key is the flat index, and the value is a
+            silx.io.DataUrl pointing to the flat.
+        darks: dict
+            Dictionary where the key is the dark index, and the value is a
+            silx.io.DataUrl pointing to the dark.
+        radios_indices: array, optional
+            Array containing the radios indices. `radios_indices[0]` is the index
+            of the first radio, and so on.
+        interpolation: str, optional
+            Interpolation method for flat-field. See below for more details.
+        distortion_correction: DistortionCorrection, optional
+            A DistortionCorrection object. If provided, it is used to correct flat distortions based on each radio.
+        nan_value: float, optional
+            Which float value is used to replace nan/inf after flat-field.
+
+
+        Other Parameters
+        ----------------
+        The other named parameters are passed to ChunkReader(). Please read its
+        documentation for more information.
+
+        Notes
+        ------
+        Usually, when doing a scan, only one or a few darks/flats are acquired.
+        However, the flat-field normalization has to be performed on each radio,
+        although incoming beam can fluctuate between projections.
+        The usual way to overcome this is to interpolate between flats.
+        If interpolation="nearest", the first flat is used for the first
+        radios subset, the second flat is used for the second radios subset,
+        and so on.
+        If interpolation="linear", the normalization is done as a linear
+        function of the radio index.
+        """
+
+        flats_arrays_dict = load_images_from_dataurl_dict(flats, **chunk_reader_kwargs)
+        darks_arrays_dict = load_images_from_dataurl_dict(darks, **chunk_reader_kwargs)
+        super().__init__(
+            radios_shape,
+            flats_arrays_dict,
+            darks_arrays_dict,
+            radios_indices=radios_indices,
+            interpolation=interpolation,
+            distortion_correction=distortion_correction,
+            nan_value=nan_value,
+            radios_srcurrent=radios_srcurrent,
+            flats_srcurrent=flats_srcurrent,
+        )

build/lib/nabu/preproc/flatfield_cuda.py

@@ -0,0 +1,144 @@
+import numpy as np
+
+from nabu.cuda.processing import CudaProcessing
+from ..preproc.flatfield import FlatFieldArrays
+from ..utils import get_cuda_srcfile
+from ..io.reader import load_images_from_dataurl_dict
+from ..cuda.utils import __has_pycuda__
+
+
+class CudaFlatFieldArrays(FlatFieldArrays):
+    def __init__(
+        self,
+        radios_shape,
+        flats,
+        darks,
+        radios_indices=None,
+        interpolation="linear",
+        distortion_correction=None,
+        nan_value=1.0,
+        radios_srcurrent=None,
+        flats_srcurrent=None,
+        cuda_options=None,
+    ):
+        """
+        Initialize a flat-field normalization CUDA process.
+        Please read the documentation of nabu.preproc.flatfield.FlatField for help
+        on the parameters.
+        """
+        #
+        if distortion_correction is not None:
+            raise NotImplementedError("Flats distortion correction is not implemented with the Cuda backend")
+        #
+        super().__init__(
+            radios_shape,
+            flats,
+            darks,
+            radios_indices=radios_indices,
+            interpolation=interpolation,
+            distortion_correction=distortion_correction,
+            radios_srcurrent=radios_srcurrent,
+            flats_srcurrent=flats_srcurrent,
+            nan_value=nan_value,
+        )
+        self.cuda_processing = CudaProcessing(**(cuda_options or {}))
+        self._init_cuda_kernels()
+        self._load_flats_and_darks_on_gpu()
+
+    def _init_cuda_kernels(self):
+        # TODO
+        if self.interpolation != "linear":
+            raise ValueError("Interpolation other than linar is not yet implemented in the cuda back-end")
+        #
+        self._cuda_fname = get_cuda_srcfile("flatfield.cu")
+        options = [
+            "-DN_FLATS=%d" % self.n_flats,
+            "-DN_DARKS=%d" % self.n_darks,
+        ]
+        if self.nan_value is not None:
+            options.append("-DNAN_VALUE=%f" % self.nan_value)
+        self.cuda_kernel = self.cuda_processing.kernel(
+            "flatfield_normalization", self._cuda_fname, signature="PPPiiiPP", options=options
+        )
+        self._nx = np.int32(self.shape[1])
+        self._ny = np.int32(self.shape[0])
+
+    def _load_flats_and_darks_on_gpu(self):
+        # Flats
+        self.d_flats = self.cuda_processing.allocate_array("d_flats", (self.n_flats,) + self.shape, np.float32)
+        for i, flat_idx in enumerate(self._sorted_flat_indices):
+            self.d_flats[i].set(np.ascontiguousarray(self.flats[flat_idx], dtype=np.float32))
+        # Darks
+        self.d_darks = self.cuda_processing.allocate_array("d_darks", (self.n_darks,) + self.shape, np.float32)
+        for i, dark_idx in enumerate(self._sorted_dark_indices):
+            self.d_darks[i].set(np.ascontiguousarray(self.darks[dark_idx], dtype=np.float32))
+        self.d_darks_indices = self.cuda_processing.to_device(
+            "d_darks_indices", np.array(self._sorted_dark_indices, dtype=np.int32)
+        )
+        # Indices
+        self.d_flats_indices = self.cuda_processing.to_device("d_flats_indices", self.flats_idx)
+        self.d_flats_weights = self.cuda_processing.to_device("d_flats_weights", self.flats_weights)
+
+    def normalize_radios(self, radios):
+        """
+        Apply a flat-field correction, with the current parameters, to a stack
+        of radios.
+
+        Parameters
+        -----------
+        radios_shape: `pycuda.gpuarray.GPUArray`
+            Radios chunk.
+        """
+        if not (isinstance(radios, self.cuda_processing.array_class)):
+            raise ValueError("Expected a pycuda.gpuarray (got %s)" % str(type(radios)))
+        if radios.dtype != np.float32:
+            raise ValueError("radios must be in float32 dtype (got %s)" % str(radios.dtype))
+        if radios.shape != self.radios_shape:
+            raise ValueError("Expected radios shape = %s but got %s" % (str(self.radios_shape), str(radios.shape)))
+        self.cuda_kernel(
+            radios,
+            self.d_flats,
+            self.d_darks,
+            self._nx,
+            self._ny,
+            np.int32(self.n_radios),
+            self.d_flats_indices,
+            self.d_flats_weights,
+        )
+        if self.normalize_srcurrent:
+            for i in range(self.n_radios):
+                radios[i] *= self.srcurrent_ratios[i]
+        return radios
+
+
+CudaFlatField = CudaFlatFieldArrays
+
+
+class CudaFlatFieldDataUrls(CudaFlatField):
+    def __init__(
+        self,
+        radios_shape,
+        flats,
+        darks,
+        radios_indices=None,
+        interpolation="linear",
+        distortion_correction=None,
+        nan_value=1.0,
+        radios_srcurrent=None,
+        flats_srcurrent=None,
+        cuda_options=None,
+        **chunk_reader_kwargs,
+    ):
+        flats_arrays_dict = load_images_from_dataurl_dict(flats, **chunk_reader_kwargs)
+        darks_arrays_dict = load_images_from_dataurl_dict(darks, **chunk_reader_kwargs)
+        super().__init__(
+            radios_shape,
+            flats_arrays_dict,
+            darks_arrays_dict,
+            radios_indices=radios_indices,
+            interpolation=interpolation,
+            distortion_correction=distortion_correction,
+            radios_srcurrent=radios_srcurrent,
+            flats_srcurrent=flats_srcurrent,
+            cuda_options=cuda_options,
+        )

build/lib/nabu/preproc/flatfield_variable_region.py

@@ -0,0 +1,79 @@
+import numpy as np
+from .flatfield import FlatFieldArrays, load_images_from_dataurl_dict, check_supported
+
+
+class FlatFieldArraysVariableRegion(FlatFieldArrays):
+    _full_shape = True
+
+    def _check_frame_shape(self, frames, frames_type):
+        # in helical the flat is the whole one and its shape does not necesseraly match the smaller frames.
+        # Therefore no check is done to allow this.
+        pass
+
+    def _check_radios_and_indices_congruence(self, radios_indices):
+        """At variance with parent class, preprocesing is done with on a fraction of the radios,
+        whose length may vary. So we dont enforce here that the lenght is always the same
+        """
+        pass
+
+    def _normalize_radios(self, radios, sub_indexes, sub_regions_per_radio):
+        """
+        Apply a flat-field normalization, with the current parameters, to a stack
+        of radios.
+        The processing is done in-place, meaning that the radios content is overwritten.
+        """
+        if len(sub_regions_per_radio) != len(sub_indexes):
+            message = f""" The length of sub_regions_per_radio,which is {len(sub_regions_per_radio)} , 
+            does not correspond to the length of sub_indexes which is {len(sub_indexes)}
+            """
+            raise ValueError(message)
+        do_flats_distortion_correction = self.distortion_correction is not None
+
+        whole_dark = self.get_dark()
+        for i, (idx, sub_r) in enumerate(zip(sub_indexes, sub_regions_per_radio)):
+            start_x, end_x, start_y, end_y = sub_r
+            slice_x = slice(start_x, end_x)
+            slice_y = slice(start_y, end_y)
+
+            self.normalize_single_radio(radios[i], idx, dtype=np.float32, slice_y=slice_y, slice_x=slice_x)
+
+        return radios
+
+
+class FlatFieldDataVariableRegionUrls(FlatFieldArraysVariableRegion):
+    def __init__(
+        self,
+        radios_shape: tuple,
+        flats: dict,
+        darks: dict,
+        radios_indices=None,
+        interpolation: str = "linear",
+        distortion_correction=None,
+        nan_value=1.0,
+        radios_srcurrent=None,
+        flats_srcurrent=None,
+        **chunk_reader_kwargs,
+    ):
+        flats_arrays_dict = load_images_from_dataurl_dict(flats, **chunk_reader_kwargs)
+        darks_arrays_dict = load_images_from_dataurl_dict(darks, **chunk_reader_kwargs)
+
+        _flats_indexes = list(flats_arrays_dict.keys())
+        _flats_indexes.sort()
+
+        self.flats_indexes = np.array(_flats_indexes)
+        self.flats_stack = np.array([flats_arrays_dict[i] for i in self.flats_indexes], "f")
+
+        flats_arrays_dict = dict([[indx, flat] for indx, flat in zip(self.flats_indexes, self.flats_stack)])
+
+        super().__init__(
+            radios_shape,
+            flats_arrays_dict,
+            darks_arrays_dict,
+            radios_indices=radios_indices,
+            interpolation=interpolation,
+            distortion_correction=distortion_correction,
+            nan_value=nan_value,
+            radios_srcurrent=radios_srcurrent,
+            flats_srcurrent=flats_srcurrent,
+        )
+        self._sorted_flat_indices = np.array(self._sorted_flat_indices, "i")