nabu 2024.2.13__py3-none-any.whl → 2025.1.0__py3-none-any.whl

nabu/io/cast_volume.py

@@ -1,10 +1,12 @@
 import os
-
-from tomoscan.esrf.volume.singleframebase import VolumeSingleFrameBase
-from nabu.misc.utils import rescale_data
-from nabu.pipeline.params import files_formats
+import logging
+from glob import glob
+from shutil import rmtree
+import numpy
+from silx.io.utils import get_data
+from silx.io.url import DataUrl
 from tomoscan.volumebase import VolumeBase
-from tomoscan.scanbase import TomoScanBase
+from tomoscan.esrf.volume.singleframebase import VolumeSingleFrameBase
 from tomoscan.esrf.volume import (
     EDFVolume,
     HDF5Volume,
@@ -13,17 +15,15 @@ from tomoscan.esrf.volume import (
     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
+from ..utils import first_generator_item
+from ..misc.utils import rescale_data
+from ..pipeline.params import files_formats
+from .reader import get_hdf5_file_all_virtual_sources, list_hdf5_entries
 
 _logger = logging.getLogger(__name__)
 
 
-__all__ = ["get_default_output_volume", "cast_volume"]
+__all__ = ["cast_volume", "get_default_output_volume"]
 
 _DEFAULT_OUTPUT_DIR = "vol_cast"
 
@@ -45,7 +45,7 @@ def get_default_output_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:
+    if output_type not 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)):
@@ -134,11 +134,12 @@ def cast_volume(
     output_data_type: numpy.dtype,
     data_min=None,
     data_max=None,
-    scan: Optional[TomoScanBase] = None,
+    scan=None,
     rescale_min_percentile=RESCALE_MIN_PERCENTILE,
     rescale_max_percentile=RESCALE_MAX_PERCENTILE,
     save=True,
     store=False,
+    remove_input_volume: bool = False,
 ) -> VolumeBase:
     """
     cast givent volume to output_volume of 'output_data_type' type
@@ -169,6 +170,7 @@ def cast_volume(
     if not isinstance(output_volume, VolumeBase):
         raise TypeError(f"output_volume is expected to be a {VolumeBase}. {type(output_volume)} provided")
 
+    # ruff: noqa: SIM105, S110
     try:
         output_data_type = numpy.dtype(
             output_data_type
@@ -247,6 +249,14 @@ def cast_volume(
     except (OSError, KeyError):
         # if no metadata provided and or saved in disk or if some key are missing
         pass
+
+    if save and output_volume.metadata is not None:
+        output_volume.save_metadata()
+
+    if remove_input_volume:
+        _logger.info(f"Removing {input_volume.data_url.file_path()}")
+        remove_volume(input_volume, check=True)
+
     return output_volume
 
 
@@ -283,7 +293,7 @@ def clamp_and_rescale_data(
     return rescaled_data
 
 
-def find_histogram(volume: VolumeBase, scan: Optional[TomoScanBase] = None) -> Optional[DataUrl]:
+def find_histogram(volume: VolumeBase, scan=None):
     """
     Look for histogram of the provided url. If found one return the DataUrl of the nabu histogram
     """
@@ -301,7 +311,7 @@ def find_histogram(volume: VolumeBase, scan: Optional[TomoScanBase] = None) -> O
                     ]
                 )
             else:
-                data_path = "/".join((volume.url.data_path(), "histogram/results/data"))
+                data_path = f"{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.)
@@ -330,7 +340,7 @@ def find_histogram(volume: VolumeBase, scan: Optional[TomoScanBase] = None) -> O
             data_path = getattr(scan, "entry/histogram/results/data", "entry/histogram/results/data")
         else:
 
-            def get_file_entries(file_path: str) -> Optional[tuple]:
+            def get_file_entries(file_path: str):
                 if os.path.exists(file_path):
                     with HDF5File(file_path, mode="r") as h5s:
                         return tuple(h5s.keys())
@@ -359,7 +369,7 @@ def find_histogram(volume: VolumeBase, scan: Optional[TomoScanBase] = None) -> O
         return None
 
     with HDF5File(histogram_file, mode="r") as h5f:
-        if not data_path in h5f:
+        if data_path not in h5f:
             _logger.info(f"{data_path} in {histogram_file} not found")
             return None
         else:
@@ -408,3 +418,83 @@ def _min_max_from_histo(url: DataUrl, rescale_min_percentile: int, rescale_max_p
         return _get_hst_saturations(
             hist, bins, numpy.float32(rescale_min_percentile), numpy.float32(rescale_max_percentile)
         )
+
+
+def _remove_volume_singleframe(volume, check=True):
+    volume_directory = volume.data_url.file_path()
+    if check:
+        volume_files = set(volume.browse_data_files())
+        files_names_pattern = os.path.join(volume_directory, "*." + volume.data_extension)
+        files_on_disk = set(glob(files_names_pattern))
+        # Don't check strict equality here, as some files on disk might be already removed.
+        # i.e, there should be no more files on disk than expected files in the volume
+        if not (files_on_disk.issubset(volume_files)):
+            raise RuntimeError(f"Unexpected files present in {volume_directory}: {files_on_disk - volume_files}")
+        # TODO also check for metadata file(s) ?
+    rmtree(volume_directory)
+
+
+def _remove_volume_multiframe(volume, check=True):
+    file_path = volume.data_url.file_path()
+    if check:
+        if not (os.path.isfile(file_path)):
+            raise RuntimeError(f"Expected a file: {file_path}")
+    os.remove(file_path)
+
+
+def _remove_volume_hdf5(volume, check=True):
+    file_path = volume.data_url.file_path()
+    entry = volume.data_url.data_path().lstrip("/").split("/")[0]
+
+    # Nabu HDF5 reconstructions have a folder alongside the HDF5 file, with the same prefix
+    # For example the HDF5 file "/path/to/rec.hdf5" has an associated directory "/path/to/rec"
+    associated_dir, _ = os.path.splitext(os.path.basename(file_path))
+    associated_dir_abs = os.path.join(os.path.dirname(file_path), associated_dir)
+
+    with HDF5File(file_path, "r") as f:
+        fdesc = f[entry]
+        virtual_sources = get_hdf5_file_all_virtual_sources(fdesc, return_only_filenames=True)
+
+    # TODO check if this is legitimate. Nabu reconstruction will only do one VS (for entry/reconstruction/results/data).
+    # Bliss/Lima do have multiple VS (flats/darks/projs), but we generally don't want to remove raw data ?
+    if len(virtual_sources) > 1:
+        raise ValueError("Found more than one virtual source - this looks weird. Interrupting.")
+    #
+    if len(virtual_sources) > 0:
+        h5path, virtual_source_files_paths = first_generator_item(virtual_sources[0].items())
+        if len(virtual_source_files_paths) == 1:
+            target_dir = os.path.dirname(virtual_source_files_paths[0])
+        else:
+            target_dir = os.path.commonpath(virtual_source_files_paths)
+        target_dir_abs = os.path.join(os.path.dirname(file_path), target_dir)
+        if check and (target_dir_abs != associated_dir_abs):
+            raise ValueError(
+                f"The virtual sources in {file_path}:{h5path} reference the directory {target_dir}, but expected was {associated_dir}"
+            )
+        if os.path.isdir(target_dir_abs):
+            rmtree(associated_dir_abs)
+    os.remove(file_path)
+
+
+def remove_volume(volume, check=True):
+    """
+    Remove files belonging to a volume, claim disk space.
+
+    Parameters
+    ----------
+    volume: tomoscan.esrf.volume
+        Volume object
+    check: bool, optional
+        Whether to check if the files that would be removed do not have extra other files ; interrupt the operation if so.
+
+    """
+    if isinstance(volume, (EDFVolume, JP2KVolume, TIFFVolume)):
+        _remove_volume_singleframe(volume, check=check)
+    elif isinstance(volume, MultiTIFFVolume):
+        _remove_volume_multiframe(volume, check=check)
+    elif isinstance(volume, HDF5Volume):
+        if len(list_hdf5_entries(volume.file_path)) > 1:
+            raise NotImplementedError("Removing a HDF5 volume with more than one entry is not supported")
+        _remove_volume_hdf5(volume, check=check)
+    else:
+        raise TypeError("Unknown type of volume")

nabu/io/detector_distortion.py

@@ -3,7 +3,6 @@ from scipy import sparse
 
 
 class DetectorDistortionBase:
-    """ """
 
     def __init__(self, detector_full_shape_vh=(0, 0)):
         """This is the basis class.
@@ -110,7 +109,7 @@ class DetectorDistortionBase:
             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()
+            raise ValueError(message)
 
         x_start, x_end = 0, self.detector_full_shape_vh[1]
 
@@ -165,7 +164,8 @@ class DetectorDistortionMapsXZ(DetectorDistortionBase):
         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:
+        Parameters
+        ----------
             map_x : float 2D array
             map_z : float 2D array
         """
@@ -173,7 +173,6 @@ class DetectorDistortionMapsXZ(DetectorDistortionBase):
         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
@@ -185,7 +184,7 @@ class DetectorDistortionMapsXZ(DetectorDistortionBase):
 
         # padding
         sz, sx = detector_full_shape_vh
-        total_detector_npixs = sz * sx
+        # 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]])
 
@@ -253,7 +252,7 @@ class DetectorDistortionMapsXZ(DetectorDistortionBase):
             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()
+            raise ValueError(message)
 
         x_start, x_end = 0, self.detector_full_shape_vh[1]
 

nabu/io/reader.py

@@ -4,6 +4,7 @@ from math import ceil
 from multiprocessing.pool import ThreadPool
 from posixpath import sep as posix_sep, join as posix_join
 import numpy as np
+from h5py import Dataset
 from silx.io import get_data
 from silx.io.dictdump import h5todict
 from tomoscan.io import HDF5File
@@ -555,7 +556,11 @@ class VolReaderBase:
             slice_x = None
         if isinstance(sub_region, (tuple, list)):
             slice_angle, slice_z, slice_x = sub_region
-        self.sub_region = (slice_angle or slice(None, None), slice_z or slice(None, None), slice_x or slice(None, None))
+        self.sub_region = (
+            slice_angle if slice_angle is not None else slice(None, None),
+            slice_z if slice_z is not None else slice(None, None),
+            slice_x if slice_x is not None else slice(None, None),
+        )
 
     def _set_processing_function(self, processing_func, processing_func_args, processing_func_kwargs):
         self.processing_func = processing_func
@@ -619,7 +624,7 @@ class NXTomoReader(VolReaderBase):
             If provided, this function first argument must be the source buffer (3D array: stack of raw images),
             and the second argument must be the destination buffer (3D array, stack of output images). It can be None.
 
-        Other parameters
+        Other Parameters
         ----------------
         The other parameters are passed to "processing_func" if this parameter is not None.
 
@@ -681,9 +686,13 @@ class NXTomoReader(VolReaderBase):
             # In this case, we can use h5py read_direct() to avoid extraneous memory consumption
             image_key_slice = self._image_key_slices[0]
             # merge image key selection and user selection (if any)
-            self._source_selection = (
-                merge_slices(image_key_slice, self.sub_region[0] or slice(None, None)),
-            ) + self.sub_region[1:]
+            angles_slice = self.sub_region[0]
+            if isinstance(angles_slice, slice) or angles_slice is None:
+                angles_slice = merge_slices(image_key_slice, self.sub_region[0] or slice(None, None))
+            else:  # assuming numpy array
+                # TODO more elegant
+                angles_slice = np.arange(self.data_shape_total[0], dtype=np.uint64)[image_key_slice][angles_slice]
+            self._source_selection = (angles_slice,) + self.sub_region[1:]
         else:
             user_selection_dim0 = self.sub_region[0]
             indices = np.arange(self.data_shape_total[0])
@@ -793,7 +802,7 @@ class NXDarksFlats:
 
     def get_reduced_current(self, h5_path="{entry}/control/data", method="median"):
         current = self.get_raw_current(h5_path=h5_path)
-        return {k: self._reduce_func[method](current[k]) for k in current.keys()}
+        return {k: self._reduce_func[method](current[k]) for k in current}
 
 
 class EDFStackReader(VolReaderBase):
@@ -987,6 +996,12 @@ def get_entry_from_h5_path(h5_path):
     return v[0] or v[1]
 
 
+def list_hdf5_entries(fname):
+    with HDF5File(fname, "r") as f:
+        entries = list(f.keys())
+    return entries
+
+
 def check_virtual_sources_exist(fname, data_path):
     with HDF5File(fname, "r") as f:
         if data_path not in f:
@@ -1006,6 +1021,30 @@ def check_virtual_sources_exist(fname, data_path):
     return True
 
 
+def get_hdf5_file_all_virtual_sources(file_path_or_obj, return_only_filenames=False):
+    result = []
+
+    def collect_vsources(name, obj):
+        if isinstance(obj, Dataset) and obj.is_virtual:
+            vs = obj.virtual_sources()
+            if return_only_filenames:
+                vs = [vs_.file_name for vs_ in vs]
+            result.append({name: vs})
+
+    _self_opened_file = False
+    if isinstance(file_path_or_obj, str):
+        fdesc = HDF5File(file_path_or_obj, "r")
+        _self_opened_file = True
+    else:
+        fdesc = file_path_or_obj
+
+    fdesc.visititems(collect_vsources)
+
+    if _self_opened_file:
+        fdesc.close()
+    return result
+
+
 def import_h5_to_dict(h5file, h5path, asarray=False):
     """
     Wrapper on top of silx.io.dictdump.dicttoh5 replacing "None" with None

nabu/io/reader_helical.py

@@ -1,4 +1,5 @@
-from .reader import *
+import numpy as np
+from .reader import ChunkReader, get_compacted_dataslices
 
 
 class ChunkReaderHelical(ChunkReader):
@@ -101,9 +102,9 @@ class ChunkReaderHelical(ChunkReader):
             self._load_multi(sub_total_prange_slice)
         else:
             if self.dataset_subsampling > 1:
-                assert (
-                    False
-                ), " in helica pipeline, load file _load_single has not yet been adapted to angular subsampling "
+                raise ValueError(
+                    "in helical pipeline, load file _load_single has not yet been adapted to angular subsampling"
+                )
             self._load_single(sub_total_prange_slice)
         self._loaded = True
 

nabu/io/tests/test_cast_volume.py

@@ -12,7 +12,7 @@ from tomoscan.esrf.volume import (
     MultiTIFFVolume,
     TIFFVolume,
 )
-from nabu.io.writer import __have_jp2k__
+from tomoscan.esrf.volume.jp2kvolume import has_glymur as __have_jp2k__
 from tomoscan.esrf.scan.edfscan import EDFTomoScan
 from tomoscan.esrf.scan.nxtomoscan import NXtomoScan
 import pytest
@@ -105,7 +105,7 @@ def test_find_histogram_hdf5_volume(tmp_path):
         scheme="silx",
     )
 
-    assert find_histogram(volume=HDF5Volume(file_path=h5_file, data_path="entry")) == None
+    assert find_histogram(volume=HDF5Volume(file_path=h5_file, data_path="entry")) is None
 
 
 def test_find_histogram_single_frame_volume(tmp_path):

nabu/io/tests/test_readers.py

@@ -1,41 +1,23 @@
 from math import ceil
 from tempfile import TemporaryDirectory
-from dataclasses import dataclass
 from tomoscan.io import HDF5File
 import pytest
 import numpy as np
 from nxtomo.application.nxtomo import ImageKey
 from tomoscan.esrf import EDFVolume
 from nabu.pipeline.reader import NXTomoReaderBinning
-from nabu.testutils import utilstest, __do_long_tests__, get_file
+from nabu.testutils import utilstest, __do_long_tests__, get_file, get_dummy_nxtomo_info
 from nabu.utils import indices_to_slices, merge_slices
 from nabu.io.reader import EDFStackReader, NXTomoReader, NXDarksFlats
-
-
-@dataclass
-class SimpleNXTomoDescription:
-    n_darks: int = 0
-    n_flats1: int = 0
-    n_projs: int = 0
-    n_flats2: int = 0
-    n_align: int = 0
-    frame_shape: tuple = None
-    dtype: np.dtype = np.uint16
+from nabu.resources.dataset_analyzer import analyze_dataset
 
 
 @pytest.fixture(scope="class")
 def bootstrap_nx_reader(request):
     cls = request.cls
-
-    cls.nx_fname = utilstest.getfile("dummy_nxtomo.nx")
-    cls.nx_data_path = "entry/instrument/detector/data"
-    cls.data_desc = SimpleNXTomoDescription(
-        n_darks=10, n_flats1=11, n_projs=100, n_flats2=11, n_align=12, frame_shape=(11, 10), dtype=np.uint16
+    cls.nx_fname, cls.data_desc, cls.image_key, cls.projs_vals, cls.darks_vals, cls.flats1_vals, cls.flats2_vals = (
+        get_dummy_nxtomo_info()
     )
-    cls.projs_vals = np.arange(cls.data_desc.n_projs) + cls.data_desc.n_flats1 + cls.data_desc.n_darks
-    cls.darks_vals = np.arange(cls.data_desc.n_darks)
-    cls.flats1_vals = np.arange(cls.data_desc.n_darks, cls.data_desc.n_darks + cls.data_desc.n_flats1)
-    cls.flats2_vals = np.arange(cls.data_desc.n_darks, cls.data_desc.n_darks + cls.data_desc.n_flats2)
 
     yield
     # teardown
@@ -45,15 +27,15 @@ def bootstrap_nx_reader(request):
 class TestNXReader:
     def test_incorrect_path(self):
         with pytest.raises(FileNotFoundError):
-            reader = NXTomoReader("/invalid/path", self.nx_data_path)
+            reader = NXTomoReader("/invalid/path")
         with pytest.raises(KeyError):
-            reader = NXTomoReader(self.nx_fname, "/bad/data/path")
+            reader = NXTomoReader(self.nx_fname, "/bad/data/path")  # noqa: F841
 
     def test_simple_reads(self):
         """
         Test NXTomoReader with simplest settings
         """
-        reader1 = NXTomoReader(self.nx_fname, self.nx_data_path)
+        reader1 = NXTomoReader(self.nx_fname)
         data1 = reader1.load_data()
         assert data1.shape == (self.data_desc.n_projs,) + self.data_desc.frame_shape
         assert np.allclose(data1[:, 0, 0], self.projs_vals)
@@ -62,15 +44,15 @@ class TestNXReader:
         """
         Test the data selection using "image_key".
         """
-        reader_projs = NXTomoReader(self.nx_fname, self.nx_data_path, image_key=ImageKey.PROJECTION.value)
+        reader_projs = NXTomoReader(self.nx_fname, image_key=ImageKey.PROJECTION.value)
         data = reader_projs.load_data()
         assert np.allclose(data[:, 0, 0], self.projs_vals)
 
-        reader_darks = NXTomoReader(self.nx_fname, self.nx_data_path, image_key=ImageKey.DARK_FIELD.value)
+        reader_darks = NXTomoReader(self.nx_fname, image_key=ImageKey.DARK_FIELD.value)
         data_darks = reader_darks.load_data()
         assert np.allclose(data_darks[:, 0, 0], self.darks_vals)
 
-        reader_flats = NXTomoReader(self.nx_fname, self.nx_data_path, image_key=ImageKey.FLAT_FIELD.value)
+        reader_flats = NXTomoReader(self.nx_fname, image_key=ImageKey.FLAT_FIELD.value)
         data_flats = reader_flats.load_data()
         assert np.allclose(data_flats[:, 0, 0], np.concatenate([self.flats1_vals, self.flats2_vals]))
 
@@ -83,10 +65,10 @@ class TestNXReader:
         def _check_correct_shape_succeeds(shape, sub_region, test_description=""):
             err_msg = "Something wrong with the following test:" + test_description
             data_buffer = np.zeros(shape, dtype="f")
-            reader1 = NXTomoReader(self.nx_fname, self.nx_data_path, sub_region=sub_region)
+            reader1 = NXTomoReader(self.nx_fname, sub_region=sub_region)
             data1 = reader1.load_data(output=data_buffer)
             assert id(data1) == id(data_buffer), err_msg
-            reader2 = NXTomoReader(self.nx_fname, self.nx_data_path, sub_region=sub_region)
+            reader2 = NXTomoReader(self.nx_fname, sub_region=sub_region)
             data2 = reader2.load_data()
             assert np.allclose(data1, data2), err_msg
 
@@ -120,11 +102,10 @@ class TestNXReader:
 
         for test_case in test_cases:
             for wrong_shape in test_case["wrong_shapes"]:
-                with pytest.raises(ValueError):
+                with pytest.raises(ValueError):  # noqa: PT012
                     data_buffer_wrong_shape = np.zeros(wrong_shape, dtype="f")
                     reader = NXTomoReader(
                         self.nx_fname,
-                        self.nx_data_path,
                         sub_region=test_case["sub_region"],
                     )
                     reader.load_data(output=data_buffer_wrong_shape)
@@ -148,7 +129,7 @@ class TestNXReader:
         ]
 
         for test_case in test_cases:
-            reader = NXTomoReader(self.nx_fname, self.nx_data_path, sub_region=test_case["sub_region"])
+            reader = NXTomoReader(self.nx_fname, sub_region=test_case["sub_region"])
             data = reader.load_data()
             assert data.shape == test_case["expected_shape"]
             assert np.allclose(data[:, 0, 0], test_case["expected_values"])
@@ -156,7 +137,7 @@ class TestNXReader:
     def test_reading_with_binning_(self):
         from nabu.pipeline.reader import NXTomoReaderBinning
 
-        reader_with_binning = NXTomoReaderBinning((2, 2), self.nx_fname, self.nx_data_path)
+        reader_with_binning = NXTomoReaderBinning((2, 2), self.nx_fname)
         data = reader_with_binning.load_data()
         assert data.shape == (self.data_desc.n_projs,) + tuple(n // 2 for n in self.data_desc.frame_shape)
 
@@ -171,13 +152,12 @@ class TestNXReader:
 
         distortion_corrector = DetectorDistortionBase(detector_full_shape_vh=data_desc.frame_shape)
         distortion_corrector.set_sub_region_transformation(target_sub_region=sub_region_xy)
-        adapted_subregion = distortion_corrector.get_adapted_subregion(sub_region_xy)
+        # adapted_subregion = distortion_corrector.get_adapted_subregion(sub_region_xy)
         sub_region = (slice(None, None), slice(*sub_region_xy[2:]), slice(*sub_region_xy[:2]))
 
         reader_distortion_corr = NXTomoReaderDistortionCorrection(
             distortion_corrector,
             self.nx_fname,
-            self.nx_data_path,
             sub_region=sub_region,
         )
 
@@ -220,7 +200,7 @@ class TestNXReader:
         for test_case in test_cases:
             binning = test_case.get("binning", None)
             reader_cls = NXTomoReader
-            init_args = [self.nx_fname, self.nx_data_path]
+            init_args = [self.nx_fname]
             init_kwargs = {"sub_region": test_case["sub_region"]}
             if binning is not None:
                 reader_cls = NXTomoReaderBinning
@@ -231,6 +211,29 @@ class TestNXReader:
             assert data.shape == test_case["expected_shape"], err_msg
             assert np.allclose(data[:, 0, 0], test_case["expected_values"]), err_msg
 
+    def test_load_exclude_projections(self):
+        n_z, n_x = self.data_desc.frame_shape
+        # projs_idx = np.where(self.image_key == 0)[0]
+        projs_idx = np.arange(self.data_desc.n_projs, dtype=np.int64)
+        excluded_projs_idx_1 = projs_idx[10:20]
+        excluded_projs_idx_2 = np.concatenate([projs_idx[10:14], projs_idx[50:57]])
+
+        set_to_nparray = lambda x: np.array(sorted(list(x)))
+
+        projs_idx1 = set_to_nparray(set(projs_idx) - set(excluded_projs_idx_1))
+        projs_idx2 = set_to_nparray(set(projs_idx) - set(excluded_projs_idx_2))
+
+        sub_regions_to_test = (
+            (projs_idx1, None, None),
+            (projs_idx1, slice(0, n_z // 2), None),
+            (projs_idx2, None, None),
+            (projs_idx2, slice(3, n_z // 2), None),
+        )
+        for sub_region in sub_regions_to_test:
+            reader = NXTomoReader(self.nx_fname, sub_region=sub_region)
+            data = reader.load_data()
+            assert np.allclose(data[:, 0, 0], self.projs_vals[sub_region[0]])
+
 
 @pytest.fixture(scope="class")
 def bootstrap_edf_reader(request):
@@ -328,7 +331,7 @@ class TestEDFReader:
 
         distortion_corrector = DetectorDistortionBase(detector_full_shape_vh=self.frame_shape)
         distortion_corrector.set_sub_region_transformation(target_sub_region=sub_region_xy)
-        adapted_subregion = distortion_corrector.get_adapted_subregion(sub_region_xy)
+        # adapted_subregion = distortion_corrector.get_adapted_subregion(sub_region_xy)
         sub_region = (slice(None, None), slice(*sub_region_xy[2:]), slice(*sub_region_xy[:2]))
 
         reader_distortion_corr = EDFStackReaderDistortionCorrection(