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

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

@@ -1,371 +0,0 @@
-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/nabu/io/detector_distortion.py

@@ -1,305 +0,0 @@
-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"]