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

build/lib/build/lib/build/lib/nabu/io/cast_volume.py

@@ -0,0 +1,371 @@
+import os
+from nabu.misc.utils import rescale_data
+from nabu.pipeline.params import files_formats
+from tomoscan.volumebase import VolumeBase
+from tomoscan.scanbase import TomoScanBase
+from tomoscan.esrf.volume import (
+    EDFVolume,
+    HDF5Volume,
+    JP2KVolume,
+    MultiTIFFVolume,
+    TIFFVolume,
+)
+from tomoscan.io import HDF5File
+from silx.io.utils import get_data
+from silx.utils.enum import Enum as _Enum
+import numpy
+from silx.io.url import DataUrl
+from typing import Optional
+import logging
+
+_logger = logging.getLogger(__name__)
+
+
+__all__ = ["get_default_output_volume", "cast_volume"]
+
+_DEFAULT_OUTPUT_DIR = "vol_cast"
+
+
+RESCALE_MIN_PERCENTILE = 10
+RESCALE_MAX_PERCENTILE = 90
+
+
+def get_default_output_volume(
+    input_volume: VolumeBase, output_type: str, output_dir: str = _DEFAULT_OUTPUT_DIR
+) -> VolumeBase:
+    """
+    For a given input volume and output type return output volume as an instance of VolumeBase
+
+    :param VolumeBase intput_volume: volume for which we want to get the resulting output volume for a cast
+    :param str output_type: output_type of the volume (edf, tiff, hdf5...)
+    :param str output_dir: output dir to save the cast volume
+    """
+    if not isinstance(input_volume, VolumeBase):
+        raise TypeError(f"input_volume is expected to be an instance of {VolumeBase}")
+    valid_file_formats = set(files_formats.values())
+    if not output_type in valid_file_formats:
+        raise ValueError(f"output_type is not a valid value ({output_type}). Valid values are {valid_file_formats}")
+
+    if isinstance(input_volume, (EDFVolume, TIFFVolume, JP2KVolume)):
+        if output_type == "hdf5":
+            file_path = os.path.join(
+                input_volume.data_url.file_path(),
+                output_dir,
+                input_volume.get_volume_basename() + ".hdf5",
+            )
+            volume = HDF5Volume(
+                file_path=file_path,
+                data_path="/volume",
+            )
+            assert volume.get_identifier() is not None, "volume should be able to create an identifier"
+            return volume
+        elif output_type in ("tiff", "edf", "jp2"):
+            if output_type == "tiff":
+                Constructor = TIFFVolume
+            elif output_type == "edf":
+                Constructor = EDFVolume
+            elif output_type == "jp2":
+                Constructor = JP2KVolume
+            return Constructor(
+                folder=os.path.join(
+                    os.path.dirname(input_volume.data_url.file_path()),
+                    output_dir,
+                ),
+                volume_basename=input_volume.get_volume_basename(),
+            )
+        else:
+            raise NotImplementedError
+    elif isinstance(input_volume, (HDF5Volume, MultiTIFFVolume)):
+        if output_type == "hdf5":
+            data_file_parent_path, data_file_name = os.path.split(input_volume.data_url.file_path())
+            # replace extension:
+            data_file_name = ".".join(
+                [
+                    os.path.splitext(data_file_name)[0],
+                    "hdf5",
+                ]
+            )
+            if isinstance(input_volume, HDF5Volume):
+                data_data_path = input_volume.data_url.data_path()
+                metadata_data_path = input_volume.metadata_url.data_path()
+                try:
+                    data_path = os.path.commonprefix([data_data_path, metadata_data_path])
+                except Exception:
+                    data_path = "volume"
+            else:
+                data_data_path = HDF5Volume.DATA_DATASET_NAME
+                metadata_data_path = HDF5Volume.METADATA_GROUP_NAME
+                file_path = data_file_name
+                data_path = "volume"
+
+            volume = HDF5Volume(
+                file_path=os.path.join(data_file_parent_path, output_dir, data_file_name),
+                data_path=data_path,
+            )
+            assert volume.get_identifier() is not None, "volume should be able to create an identifier"
+            return volume
+        elif output_type in ("tiff", "edf", "jp2"):
+            if output_type == "tiff":
+                Constructor = TIFFVolume
+            elif output_type == "edf":
+                Constructor = EDFVolume
+            elif output_type == "jp2":
+                Constructor = JP2KVolume
+            file_parent_path, file_name = os.path.split(input_volume.data_url.file_path())
+            file_name = os.path.splitext(file_name)[0]
+            return Constructor(
+                folder=os.path.join(
+                    file_parent_path,
+                    output_dir,
+                    os.path.basename(file_name),
+                )
+            )
+        else:
+            raise NotImplementedError
+    else:
+        raise NotImplementedError
+
+
+def cast_volume(
+    input_volume: VolumeBase,
+    output_volume: VolumeBase,
+    output_data_type: numpy.dtype,
+    data_min=None,
+    data_max=None,
+    scan: Optional[TomoScanBase] = None,
+    rescale_min_percentile=RESCALE_MIN_PERCENTILE,
+    rescale_max_percentile=RESCALE_MAX_PERCENTILE,
+    save=True,
+    store=False,
+) -> VolumeBase:
+    """
+    cast givent volume to output_volume of 'output_data_type' type
+
+    :param VolumeBase input_volume:
+    :param VolumeBase output_volume:
+    :param numpy.dtype output_data_type: output data type
+    :param number data_min: `data` min value to clamp to new_min. Any lower value will also be clamp to new_min.
+    :param number data_max: `data` max value to clamp to new_max. Any hight value will also be clamp to new_max.
+    :param TomoScanBase scan: source scan that produced input_volume. Can be used to find histogram for example.
+    :param rescale_min_percentile: if `data_min` is None will set data_min to 'rescale_min_percentile'
+    :param rescale_max_percentile: if `data_max` is None will set data_min to 'rescale_max_percentile'
+    :param bool save: if True dump the slice on disk (one by one)
+    :param bool store: if True once the volume is cast then set `output_volume.data`
+    :return: output_volume with data and metadata set
+
+    .. warning::
+        the created will volume will not be saved in this processing. If you want
+        to save the cast volume you must do it yourself.
+
+    .. note::
+        if you want to tune compression ratios (for jp2k) then please update the `cratios` attributes of the output volume
+
+    """
+    if not isinstance(input_volume, VolumeBase):
+        raise TypeError(f"input_volume is expected to be a {VolumeBase}. {type(input_volume)} provided")
+
+    if not isinstance(output_volume, VolumeBase):
+        raise TypeError(f"output_volume is expected to be a {VolumeBase}. {type(output_volume)} provided")
+
+    try:
+        output_data_type = numpy.dtype(
+            output_data_type
+        )  # User friendly API in case user provides np.uint16 e.g. (see issue #482)
+    except Exception:
+        pass
+    if not isinstance(output_data_type, numpy.dtype):
+        raise TypeError(f"output_data_type is expected to be a {numpy.dtype}. {type(output_data_type)} provided")
+
+    # start processing
+    #  check for data_min and data_max
+    if data_min is None or data_max is None:
+        found_data_min, found_data_max = _try_to_find_min_max_from_histo(
+            input_volume=input_volume,
+            scan=scan,
+            rescale_min_percentile=rescale_min_percentile,
+            rescale_max_percentile=rescale_max_percentile,
+        )
+        if found_data_min is None or found_data_max is None:
+            _logger.warning("couldn't find histogram, recompute volume min and max values")
+            data_min, data_max = input_volume.get_min_max()
+            _logger.info(f"min and max found ({data_min} ; {data_max})")
+
+        data_min = data_min if data_min is not None else found_data_min
+        data_max = data_max if data_max is not None else found_data_max
+
+    data = []
+    for input_slice, frame_dumper in zip(
+        input_volume.browse_slices(),
+        output_volume.data_file_saver_generator(
+            input_volume.get_volume_shape()[0],
+            data_url=output_volume.data_url,
+            overwrite=output_volume.overwrite,
+        ),
+    ):
+        if numpy.issubdtype(output_data_type, numpy.integer):
+            new_min = numpy.iinfo(output_data_type).min
+            new_max = numpy.iinfo(output_data_type).max
+            output_slice = clamp_and_rescale_data(
+                data=input_slice,
+                new_min=new_min,
+                new_max=new_max,
+                data_min=data_min,
+                data_max=data_max,
+                rescale_min_percentile=rescale_min_percentile,
+                rescale_max_percentile=rescale_max_percentile,
+            ).astype(output_data_type)
+        else:
+            output_slice = input_slice.astype(output_data_type)
+        if save:
+            frame_dumper[:] = output_slice
+        if store:
+            # only keep data in cache if not dump to disk
+            data.append(output_slice)
+
+    if store:
+        output_volume.data = numpy.asarray(data)
+
+    # try also to append some metadata to it
+    try:
+        output_volume.metadata = input_volume.metadata or input_volume.load_metadata()
+    except (OSError, KeyError):
+        # if no metadata provided and or saved in disk or if some key are missing
+        pass
+    return output_volume
+
+
+def clamp_and_rescale_data(
+    data: numpy.ndarray,
+    new_min,
+    new_max,
+    data_min=None,
+    data_max=None,
+    rescale_min_percentile=RESCALE_MIN_PERCENTILE,
+    rescale_max_percentile=RESCALE_MAX_PERCENTILE,
+):
+    """
+    rescale data to 'new_min', 'new_max'
+
+    :param numpy.ndarray data: data to be rescaled
+    :param dtype output_dtype: output dtype
+    :param new_min: rescaled data new min (clamp min value)
+    :param new_max: rescaled data new max (clamp max value)
+    :param data_min: `data` min value to clamp to new_min. Any lower value will also be clamp to new_min.
+    :param data_max: `data` max value to clamp to new_max. Any hight value will also be clamp to new_max.
+    :param rescale_min_percentile: if `data_min` is None will set data_min to 'rescale_min_percentile'
+    :param rescale_max_percentile: if `data_max` is None will set data_min to 'rescale_max_percentile'
+    """
+    if data_min is None:
+        data_min = numpy.percentile(data, rescale_min_percentile)
+    if data_max is None:
+        data_max = numpy.percentile(data, rescale_max_percentile)
+    # rescale data
+    rescaled_data = rescale_data(data, new_min=new_min, new_max=new_max, data_min=data_min, data_max=data_max)
+    # clamp data
+    rescaled_data[rescaled_data < new_min] = new_min
+    rescaled_data[rescaled_data > new_max] = new_max
+    return rescaled_data
+
+
+def find_histogram(volume: VolumeBase, scan: Optional[TomoScanBase] = None) -> Optional[DataUrl]:
+    """
+    Look for histogram of the provided url. If found one return the DataUrl of the nabu histogram
+    """
+    if not isinstance(volume, VolumeBase):
+        raise TypeError(f"volume is expected to be an instance of {VolumeBase} not {type(volume)}")
+    elif isinstance(volume, HDF5Volume):
+        histogram_file = volume.data_url.file_path()
+        if volume.url is not None:
+            data_path = volume.url.data_path()
+            if data_path.endswith("reconstruction"):
+                data_path = "/".join(
+                    [
+                        *data_path.split("/")[:-1],
+                        "histogram/results/data",
+                    ]
+                )
+            else:
+                data_path = "/".join((volume.url.data_path(), "histogram/results/data"))
+        else:
+            # TODO: FIXME: in some case (if the users provides the full data_url and if the 'DATA_DATASET_NAME' is not used we
+            # will endup with an invalid data_path. Hope this case will not happen. Anyway this is a case that we can't handle.)
+            # if trouble: check if data_path exists. If not raise an error saying this we can't find an histogram for this volume
+            data_path = volume.data_url.data_path().replace(HDF5Volume.DATA_DATASET_NAME, "histogram/results/data")
+    elif isinstance(volume, (EDFVolume, JP2KVolume, TIFFVolume, MultiTIFFVolume)):
+        if isinstance(volume, (EDFVolume, JP2KVolume, TIFFVolume)):
+            # TODO: check with pierre what is the policy of histogram files names
+            histogram_file = os.path.join(
+                volume.data_url.file_path(),
+                volume.get_volume_basename() + "histogram.hdf5",
+            )
+        else:
+            # TODO: check with pierre what is the policy of histogram files names
+            file_path, _ = os.path.splitext(volume.data_url.file_path())
+            histogram_file = os.path.join(file_path + "histogram.hdf5")
+
+        if scan is not None:
+            data_path = getattr(scan, "entry", "entry")
+        else:
+            # TODO: FIXME: how to get the entry name in every case ?
+            # possible solutions are:
+            #     * look at the different entries and check for histogram: will work if only one histogram in the file
+            #     * Add a histogram request so the user can provide it (can be done at tomoscan level or nabu if we think this is specific to nabu)
+            _logger.info("histogram file found but unable to find relevant histogram")
+            return None
+    else:
+        raise NotImplementedError(f"volume {type(volume)} not handled")
+
+    if not os.path.exists(histogram_file):
+        _logger.info(f"{histogram_file} not found")
+        return None
+
+    with HDF5File(histogram_file, mode="r") as h5f:
+        if not data_path in h5f:
+            _logger.info(f"{data_path} in {histogram_file} not found")
+            return None
+        else:
+            _logger.info(f"Found histogram {histogram_file}::/{data_path}")
+            return DataUrl(
+                file_path=histogram_file,
+                data_path=data_path,
+                scheme="silx",
+            )
+
+
+def _get_hst_saturations(hist, bins, rescale_min_percentile: numpy.float32, rescale_max_percentile: numpy.float32):
+    hist_cum = numpy.cumsum(hist)
+    bin_index_min = numpy.searchsorted(hist_cum, numpy.percentile(hist_cum, rescale_min_percentile))
+    bin_index_max = numpy.searchsorted(hist_cum, numpy.percentile(hist_cum, rescale_max_percentile))
+    return bins[bin_index_min], bins[bin_index_max]
+
+
+def _try_to_find_min_max_from_histo(
+    input_volume: VolumeBase, rescale_min_percentile, rescale_max_percentile, scan=None
+) -> tuple:
+    """
+    util to interpret nabu histogram and deduce data_min and data_max to be used for
+    rescaling a volume
+    """
+    histogram_res_url = find_histogram(input_volume, scan=scan)
+    if histogram_res_url is not None:
+        return _min_max_from_histo(
+            url=histogram_res_url,
+            rescale_min_percentile=rescale_min_percentile,
+            rescale_max_percentile=rescale_max_percentile,
+        )
+    else:
+        return None, None
+
+
+def _min_max_from_histo(url: DataUrl, rescale_min_percentile: int, rescale_max_percentile: int) -> tuple:
+    try:
+        histogram = get_data(url)
+    except Exception as e:
+        _logger.error(f"Fail to load histogram from {url.path()}. Reason is {e}")
+        return None, None
+    else:
+        bins = histogram[1]
+        hist = histogram[0]
+        return _get_hst_saturations(
+            hist, bins, numpy.float32(rescale_min_percentile), numpy.float32(rescale_max_percentile)
+        )

build/lib/build/lib/build/lib/nabu/io/detector_distortion.py

@@ -0,0 +1,305 @@
+import numpy as np
+from scipy import sparse
+
+
+class DetectorDistortionBase:
+    """ """
+
+    def __init__(self, detector_full_shape_vh=(0, 0)):
+        """This is the basis class.
+        A simple identity transformation which has the only merit to show
+        how it works.Reimplement this function to have more parameters for other
+        transformations
+        """
+        self._build_full_transformation(detector_full_shape_vh)
+
+    def transform(self, source_data, do_full=False):
+        """performs the transformation"""
+
+        if do_full:
+            result = self.transformation_matrix_full @ source_data.flat
+            result.shape = source_data.shape
+        else:
+            result = self.transformation_matrix @ source_data.flat
+            result.shape = self.target_shape
+
+        return result
+
+    def _build_full_transformation(self, detector_full_shape_vh):
+        """A simple identity.
+        Reimplement this function to have more parameters for other
+        transformations
+        """
+
+        self.detector_full_shape_vh = detector_full_shape_vh
+
+        sz, sx = detector_full_shape_vh
+
+        # A simple identity matrix in sparse coordinates format
+
+        self.total_detector_npixs = detector_full_shape_vh[0] * detector_full_shape_vh[1]
+        I_tmp = np.arange(self.total_detector_npixs)
+        J_tmp = np.arange(self.total_detector_npixs)
+        V_tmp = np.ones([self.total_detector_npixs], "f")
+
+        coo_tmp = sparse.coo_matrix((V_tmp, (I_tmp, J_tmp)), shape=(sz * sx, sz * sx))
+
+        csr_tmp = coo_tmp.tocsr()
+
+        ## The following arrays  are kept for future usage
+        ## when, according to the "sub_region" parameter of the moment,
+        ## they will be used to extract a "slice" of them
+        ## which will map an appropriate data region corresponding to "sub_region_source"
+        ## to the target "sub_region" of the moment
+        self.full_csr_data = csr_tmp.data
+        self.full_csr_indices = csr_tmp.indices
+        self.full_csr_indptr = csr_tmp.indptr
+
+        ## This will be used to save time if the same sub_region argument is requested several time in a row
+        self._status = None
+
+    def get_adapted_subregion(self, sub_region_xz):
+        if sub_region_xz is not None:
+            start_x, end_x, start_z, end_z = sub_region_xz
+        else:
+            start_x = 0
+            end_x = None
+            start_z = 0
+            end_z = None
+
+        (start_x, end_x, start_z, end_z) = self.set_sub_region_transformation((start_x, end_x, start_z, end_z))
+        return (start_x, end_x, start_z, end_z)
+
+    def set_sub_region_transformation(self, target_sub_region=None):
+        """must return a source sub_region. It sets internally  an object (a practical implementation
+        would be a sparse matrice) which can be reused in further applications of "transform" method
+        for transforming the source sub_region data into the target sub_region
+        """
+        if target_sub_region is None:
+            target_sub_region = (None, None, 0, None)
+
+        if self._status is not None and self._status["target_sub_region"] == target_sub_region:
+            return self._status["source_sub_region"]
+        else:
+            self._status = None
+            return self._set_sub_region_transformation(target_sub_region)
+
+    def set_full_transformation(self):
+        self._set_sub_region_transformation(do_full=True)
+
+    def get_actual_shapes_source_target(self):
+        if self._status is None:
+            return None, None
+        else:
+            return self._status["source_sub_region"], self._status["target_sub_region"]
+
+    def _set_sub_region_transformation(self, target_sub_region=None, do_full=False):
+        """to be reimplemented in the derived classes"""
+        if target_sub_region is None or do_full:
+            target_sub_region = (None, None, 0, None)
+
+        (x_start, x_end, z_start, z_end) = target_sub_region
+
+        if z_start is None:
+            z_start = 0
+        if z_end is None:
+            z_end = self.detector_full_shape_vh[0]
+
+        if (x_start, x_end) not in [(None, None), (0, None), (0, self.detector_full_shape_vh[1])]:
+            message = f""" In the base class DetectorDistortionBase only vertical slicing is accepted.
+            The sub_region contained (x_start, x_end)={(x_start, x_end)} which would slice the 
+            full horizontal size which is {self.detector_full_shape_vh[1]}
+            """
+            raise ValueError()
+
+        x_start, x_end = 0, self.detector_full_shape_vh[1]
+
+        row_ptr_start = z_start * self.detector_full_shape_vh[1]
+        row_ptr_end = z_end * self.detector_full_shape_vh[1]
+
+        indices_start = self.full_csr_indptr[row_ptr_start]
+        indices_end = self.full_csr_indptr[row_ptr_end]
+
+        indices_offset = self.full_csr_indptr[row_ptr_start]
+
+        source_offset = target_sub_region[2] * self.detector_full_shape_vh[1]
+
+        data_tmp = self.full_csr_data[indices_start:indices_end]
+        indices_tmp = self.full_csr_indices[indices_start:indices_end] - source_offset
+        indptr_tmp = self.full_csr_indptr[row_ptr_start : row_ptr_end + 1] - indices_offset
+
+        target_size = (z_end - z_start) * self.detector_full_shape_vh[1]
+        source_size = (z_end - z_start) * self.detector_full_shape_vh[1]
+
+        tmp_transformation_matrix = sparse.csr_matrix(
+            (data_tmp, indices_tmp, indptr_tmp), shape=(target_size, source_size)
+        )
+
+        if do_full:
+            self.transformation_matrix_full = tmp_transformation_matrix
+            return None
+        else:
+            self.transformation_matrix = tmp_transformation_matrix
+
+        self.target_shape = ((z_end - z_start), self.detector_full_shape_vh[1])
+
+        ## For the identity matrix the source and the target have the same size.
+        ## The two following lines are trivial.
+        ## For this identity transformation only the slicing of the appropriate part
+        ## of the identity sparse matrix is slightly laborious.
+        ## Practical case will be more complicated and source_sub_region
+        ## will be in general larger than the target_sub_region
+        self._status = {
+            "target_sub_region": ((x_start, x_end, z_start, z_end)),
+            "source_sub_region": ((x_start, x_end, z_start, z_end)),
+        }
+
+        return self._status["source_sub_region"]
+
+
+class DetectorDistortionMapsXZ(DetectorDistortionBase):
+    def __init__(self, map_x, map_z):
+        """
+        This class implements the distortion correction from the knowledge of
+        two arrays, map_x and map_z.
+        Pixel (i,j) of the corrected image is obtained by interpolating the raw data at position
+        ( map_z(i,j), map_x(i,j) ).
+
+        Parameters:
+            map_x : float 2D array
+            map_z : float 2D array
+        """
+
+        self._build_full_transformation(map_x, map_z)
+
+    def _build_full_transformation(self, map_x, map_z):
+        """ """
+        detector_full_shape_vh = map_x.shape
+        if detector_full_shape_vh != map_z.shape:
+            message = f"""  map_x and map_z must have the same shape
+            but the dimensions were {map_x.shape} and {map_z.shape}
+            """
+            raise ValueError(message)
+
+        coordinates = np.array([map_z, map_x])
+
+        # padding
+        sz, sx = detector_full_shape_vh
+        total_detector_npixs = sz * sx
+        xs = np.clip(np.array(coordinates[1].flat), [[0]], [[sx - 1]])
+        zs = np.clip(np.array(coordinates[0].flat), [[0]], [[sz - 1]])
+
+        ix0s = np.floor(xs)
+        ix1s = np.ceil(xs)
+        fx = xs - ix0s
+
+        iz0s = np.floor(zs)
+        iz1s = np.ceil(zs)
+        fz = zs - iz0s
+
+        I_tmp = np.empty([4 * sz * sx], np.int64)
+        J_tmp = np.empty([4 * sz * sx], np.int64)
+        V_tmp = np.ones([4 * sz * sx], "f")
+
+        I_tmp[:] = np.arange(sz * sx * 4) // 4
+
+        J_tmp[0::4] = iz0s * sx + ix0s
+        J_tmp[1::4] = iz0s * sx + ix1s
+        J_tmp[2::4] = iz1s * sx + ix0s
+        J_tmp[3::4] = iz1s * sx + ix1s
+
+        V_tmp[0::4] = (1 - fz) * (1 - fx)
+        V_tmp[1::4] = (1 - fz) * fx
+        V_tmp[2::4] = fz * (1 - fx)
+        V_tmp[3::4] = fz * fx
+
+        self.detector_full_shape_vh = detector_full_shape_vh
+
+        coo_tmp = sparse.coo_matrix((V_tmp.astype("f"), (I_tmp, J_tmp)), shape=(sz * sx, sz * sx))
+
+        csr_tmp = coo_tmp.tocsr()
+
+        self.full_csr_data = csr_tmp.data
+        self.full_csr_indices = csr_tmp.indices
+        self.full_csr_indptr = csr_tmp.indptr
+
+        ## This will be used to save time if the same sub_region argument is requested several time in a row
+        self._status = None
+
+    def _set_sub_region_transformation(
+        self,
+        target_sub_region=(
+            (
+                None,
+                None,
+                0,
+                0,
+            ),
+        ),
+        do_full=False,
+    ):
+        if target_sub_region is None or do_full:
+            target_sub_region = (None, None, 0, None)
+
+        (x_start, x_end, z_start, z_end) = target_sub_region
+
+        if z_start is None:
+            z_start = 0
+        if z_end is None:
+            z_end = self.detector_full_shape_vh[0]
+
+        if (x_start, x_end) not in [(None, None), (0, None), (0, self.detector_full_shape_vh[1])]:
+            message = f""" In the base class DetectorDistortionRotation only vertical slicing is accepted.
+            The sub_region contained (x_start, x_end)={(x_start, x_end)} which would slice the 
+            full horizontal size which is {self.detector_full_shape_vh[1]}
+            """
+            raise ValueError()
+
+        x_start, x_end = 0, self.detector_full_shape_vh[1]
+
+        row_ptr_start = z_start * self.detector_full_shape_vh[1]
+        row_ptr_end = z_end * self.detector_full_shape_vh[1]
+
+        indices_start = self.full_csr_indptr[row_ptr_start]
+        indices_end = self.full_csr_indptr[row_ptr_end]
+
+        data_tmp = self.full_csr_data[indices_start:indices_end]
+
+        target_offset = self.full_csr_indptr[row_ptr_start]
+        indptr_tmp = self.full_csr_indptr[row_ptr_start : row_ptr_end + 1] - target_offset
+
+        indices_tmp = self.full_csr_indices[indices_start:indices_end]
+
+        iz_source = (indices_tmp) // self.detector_full_shape_vh[1]
+
+        z_start_source = iz_source.min()
+        z_end_source = iz_source.max() + 1
+        source_offset = z_start_source * self.detector_full_shape_vh[1]
+        indices_tmp = indices_tmp - source_offset
+
+        target_size = (z_end - z_start) * self.detector_full_shape_vh[1]
+        source_size = (z_end_source - z_start_source) * self.detector_full_shape_vh[1]
+
+        tmp_transformation_matrix = sparse.csr_matrix(
+            (data_tmp, indices_tmp, indptr_tmp), shape=(target_size, source_size)
+        )
+
+        if do_full:
+            self.transformation_matrix_full = tmp_transformation_matrix
+            return None
+        else:
+            self.transformation_matrix = tmp_transformation_matrix
+
+        self.target_shape = ((z_end - z_start), self.detector_full_shape_vh[1])
+
+        ## For the identity matrix the source and the target have the same size.
+        ## The two following lines are trivial.
+        ## For this identity transformation only the slicing of the appropriate part
+        ## of the identity sparse matrix is slightly laborious.
+        ## Practical case will be more complicated and source_sub_region
+        ## will be in general larger than the target_sub_region
+        self._status = {
+            "target_sub_region": ((x_start, x_end, z_start, z_end)),
+            "source_sub_region": ((x_start, x_end, z_start_source, z_end_source)),
+        }
+        return self._status["source_sub_region"]