nabu 2025.1.0.dev13__py3-none-any.whl → 2025.1.0rc1__py3-none-any.whl

nabu/reconstruction/fbp_base.py

@@ -7,6 +7,19 @@ from .sinogram import SinoMult
 from .sinogram import get_extended_sinogram_width
 
 
+def rot_center_is_in_middle_of_roi(rot_center, roi, tol=2.0):
+    # NB. tolerance should be at least 2,
+    # because in halftomo the extended sinogram width is 2*sino_width - int(2 * XXXX)
+    #   (where  XXX depends on whether the CoR is on the left or on the right)
+    #  because of the int(2 * stuff), we can have a jump of at most two pixels.
+    #
+    start_x, end_x, start_y, end_y = roi
+    return (
+        abs((start_x + end_x - 1) / 2 - rot_center) - 0.5 < tol
+        and abs((start_y + end_y - 1) / 2 - rot_center) - 0.5 < tol
+    )
+
+
 class BackprojectorBase:
     """
     Base class for backprojectors.
@@ -162,9 +175,6 @@ class BackprojectorBase:
         self.axis_pos = self.rot_center
         self._set_angles(angles, n_angles)
         self._set_slice_roi(slice_roi)
-        #
-        # offset = start - move
-        # move = 0 if not(centered_axis) else start + (n-1)/2. - c
         if self.extra_options["centered_axis"]:
             self.offsets = {
                 "x": self.rot_center - (self.n_x - 1) / 2.0,
@@ -210,6 +220,19 @@ class BackprojectorBase:
         end_x = convert_index(end_x, self.n_x, self.n_x)
         end_y = convert_index(end_y, self.n_y, self.n_y)
         self.slice_shape = (end_y - start_y, end_x - start_x)
+        if self.extra_options["centered_axis"] and not (
+            rot_center_is_in_middle_of_roi(self.rot_center, (start_x, end_x, start_y, end_y))
+        ):
+            warnings.warn(
+                "Using 'centered_axis' when doing a non-centered ROI reconstruction might have side effects: 'start_xy' and 'end_xy' have a different meaning",
+                RuntimeWarning,
+            )
+            # self.extra_options["centered_axis"] = False
+        if self.extra_options.get("clip_outer_circle", False) and (
+            start_x > 2 or start_y > 2 or abs(end_y - self.n_y) > 2 or abs(end_y - self.n_y) > 2
+        ):
+            warnings.warn("clip_outer_circle is not supported when doing RoI reconstruction", RuntimeWarning)
+            self.extra_options["clip_outer_circle"] = False
         self.n_x = self.slice_shape[-1]
         self.n_y = self.slice_shape[-2]
         self.offsets = {"x": start_x, "y": start_y}
@@ -239,19 +262,20 @@ class BackprojectorBase:
         self._axis_correction = np.zeros((1, self.n_angles), dtype=np.float32)
         self._axis_correction[0, :] = axcorr[:]  # pylint: disable=E1136
 
+    def _get_filter_init_extra_options(self):
+        return {}
+
     def _init_filter(self, filter_name):
         self.filter_name = filter_name
         if filter_name in ["None", "none"]:
             self.sino_filter = None
             return
-        sinofilter_other_kwargs = {}
-        if self.backend != "numpy":
-            sinofilter_other_kwargs["%s_options" % self.backend] = {"ctx": self._processing.ctx}
-        sinofilter_other_kwargs["crop_filtered_data"] = self.extra_options.get("crop_filtered_data", True)
+
         # TODO
         if not (self.extra_options.get("crop_filtered_data", True)):
             warnings.warn("crop_filtered_data = False is not supported for FBP yet", RuntimeWarning)
         #
+        sinofilter_other_kwargs = self._get_filter_init_extra_options()
         self.sino_filter = self.SinoFilterClass(
             self.sino_shape,
             filter_name=self.filter_name,

nabu/reconstruction/fbp_opencl.py

@@ -74,5 +74,13 @@ class OpenCLBackprojector(BackprojectorBase):
                 return
             return cl.enqueue_copy(self._processing.queue, self._d_sino.data, sino.data)
 
+    def _get_filter_init_extra_options(self):
+        return {
+            "opencl_options": {
+                "ctx": self._processing.ctx,
+                "queue": self._processing.queue,  # !!!!
+            },
+        }
+
     def _set_kernel_slice_arg(self, d_slice):
         self.kern_proj_args[1] = d_slice

nabu/reconstruction/filtering_opencl.py

@@ -33,6 +33,8 @@ class OpenCLSinoFilter(SinoFilter):
             crop_filtered_data=crop_filtered_data,
             extra_options=extra_options,
         )
+        if not (crop_filtered_data):
+            raise NotImplementedError  # TODO
         self._init_kernels()
 
     def _init_fft(self):

nabu/reconstruction/mlem.py

@@ -12,6 +12,28 @@ except ImportError:
 class MLEMReconstructor:
     """
     A reconstructor for MLEM reconstruction using the CorrCT toolbox.
+
+    Parameters
+    ----------
+    data_vwu_shape : tuple
+        Shape of the input data, expected to be (n_slices, n_angles, n_dets). Raises an error if the shape is not 3D.
+    angles_rad : numpy.ndarray
+        Angles in radians for the projections. Must match the second dimension of `data_vwu_shape`.
+    shifts_vu : numpy.ndarray, optional.
+        Shifts in the v and u directions for each angle. If provided, must have the same number of cols as `angles_rad`. Each col is (tv,tu)
+    cor : float, optional
+        Center of rotation, which will be adjusted based on the sinogram width.
+    n_iterations : int, optional
+        Number of iterations for the MLEM algorithm. Default is 50.
+    extra_options : dict, optional
+        Additional options for the reconstruction process. Default options include:
+        - scale_factor (float, default is 1.0): Scale factor for the reconstruction.
+        - compute_shifts (boolean, default is False): Whether to compute shifts.
+        - tomo_consistency (boolean, default is False): Whether to enforce tomographic consistency.
+        - v_min_for_v_shifts (number, default is 0): Minimum value for vertical shifts.
+        - v_max_for_v_shifts (number, default is None): Maximum value for vertical shifts.
+        - v_min_for_u_shifts (number, default is 0): Minimum value for horizontal shifts.
+        - v_max_for_u_shifts (number, default is None): Maximum value for horizontal shifts.
     """
 
     default_extra_options = {
@@ -21,14 +43,21 @@ class MLEMReconstructor:
         "v_max_for_v_shifts": None,
         "v_min_for_u_shifts": 0,
         "v_max_for_u_shifts": None,
+        "scale_factor": 1.0,
+        "centered_axis": False,
+        "clip_outer_circle": False,
+        "outer_circle_value": 0.0,
+        "filter_cutoff": 1.0,
+        "padding_mode": None,
+        "crop_filtered_data": True,
     }
 
     def __init__(
         self,
-        sinos_shape,
+        data_vwu_shape,
         angles_rad,
         shifts_uv=None,
-        cor=None,
+        cor=None,  # absolute
         n_iterations=50,
         extra_options=None,
     ):
@@ -36,9 +65,10 @@ class MLEMReconstructor:
             raise ImportError("Need corrct package")
         self.angles_rad = angles_rad
         self.n_iterations = n_iterations
+        self.scale_factor = extra_options.get("scale_factor", 1.0)
 
         self._configure_extra_options(extra_options)
-        self._set_sino_shape(sinos_shape)
+        self._set_sino_shape(data_vwu_shape)
         self._set_shifts(shifts_uv, cor)
 
     def _configure_extra_options(self, extra_options):
@@ -57,17 +87,22 @@ class MLEMReconstructor:
 
     def _set_shifts(self, shifts_uv, cor):
         if shifts_uv is None:
-            self.shifts_uv = np.zeros([self.n_angles, 2])
+            self.shifts_vu = None
         else:
             if shifts_uv.shape[0] != self.n_angles:
                 raise ValueError(
                     f"Number of shifts given ({shifts_uv.shape[0]}) does not mathc the number of projections ({self.n_angles})."
                 )
-            self.shifts_uv = shifts_uv.copy()
-        self.cor = cor
+            self.shifts_vu = -shifts_uv.copy().T[::-1]
+        if cor is None:
+            self.cor = 0.0
+        else:
+            self.cor = (
+                -cor + (self.sinos_shape[-1] - 1) / 2.0
+            )  # convert absolute to relative in the ASTRA convention, which is opposite to Nabu relative convention.
 
     def reset_rot_center(self, cor):
-        self.cor = cor
+        self.cor = -cor + (self.sinos_shape[-1] - 1) / 2.0
 
     def reconstruct(self, data_vwu):
         """
@@ -78,14 +113,17 @@ class MLEMReconstructor:
         """
         if not isinstance(data_vwu, np.ndarray):
             data_vwu = data_vwu.get()
-        data_vwu /= data_vwu.mean()
+        # data_vwu /= data_vwu.mean()
 
         # MLEM recons
         self.vol_geom_align = cct.models.VolumeGeometry.get_default_from_data(data_vwu)
-        self.prj_geom_align = cct.models.ProjectionGeometry.get_default_parallel()
-        # Vertical shifts were handled in pipeline. Set them to ZERO
-        self.shifts_uv[:, 1] = 0.0
-        self.prj_geom_align.set_detector_shifts_vu(self.shifts_uv.T[::-1])
+        if self.shifts_vu is not None:
+            self.prj_geom_align = cct.models.ProjectionGeometry.get_default_parallel()
+            # Vertical shifts were handled in pipeline. Set them to ZERO
+            self.shifts_vu[:, 0] = 0.0
+            self.prj_geom_align.set_detector_shifts_vu(self.shifts_vu, self.cor)
+        else:
+            self.prj_geom_align = None
 
         variances_align = cct.processing.compute_variance_poisson(data_vwu)
         self.weights_align = cct.processing.compute_variance_weight(variances_align, normalized=True)  # , use_std=True
@@ -97,5 +135,4 @@ class MLEMReconstructor:
             self.vol_geom_align, self.angles_rad, rot_axis_shift_pix=self.cor, prj_geom=self.prj_geom_align
         ) as A:
             rec, _ = solver(A, data_vwu, iterations=self.n_iterations, **self.solver_opts)
-
-        return rec
+        return rec * self.scale_factor

nabu/reconstruction/tests/test_filtering.py

@@ -106,7 +106,11 @@ class TestSinoFilter:
             assert id(res) == id(output), "when providing output, return value must not change"
 
         ref = filter_sinogram(
-            h_sino, sino_filter.dwidth_padded, filter_name=config["filter_name"], padding_mode=config["padding_mode"]
+            h_sino,
+            sino_filter.dwidth_padded,
+            filter_name=config["filter_name"],
+            padding_mode=config["padding_mode"],
+            crop_filtered_data=config["crop_filtered_data"],
         )
 
         assert np.allclose(res.get(), ref, atol=6e-5), "test_cuda_filter: something wrong with config=%s" % (
@@ -118,6 +122,8 @@ class TestSinoFilter:
     )
     @pytest.mark.parametrize("config", tests_scenarios)
     def test_opencl_filter(self, config):
+        if not (config["crop_filtered_data"]):
+            pytest.skip("crop_filtered_data=False is not supported for OpenCL backend yet")
         sino = self.sino_cl if not (config["truncated_sino"]) else self.sino_truncated_cl
         h_sino = self.sino if not (config["truncated_sino"]) else self.sino_truncated
 
@@ -126,6 +132,7 @@ class TestSinoFilter:
             filter_name=config["filter_name"],
             padding_mode=config["padding_mode"],
             opencl_options={"ctx": self.cl.ctx},
+            crop_filtered_data=config["crop_filtered_data"],
         )
         if config["output_provided"]:
             output = parray.zeros(self.cl.queue, sino.shape, "f")
@@ -136,7 +143,11 @@ class TestSinoFilter:
             assert id(res) == id(output), "when providing output, return value must not change"
 
         ref = filter_sinogram(
-            h_sino, sino_filter.dwidth_padded, filter_name=config["filter_name"], padding_mode=config["padding_mode"]
+            h_sino,
+            sino_filter.dwidth_padded,
+            filter_name=config["filter_name"],
+            padding_mode=config["padding_mode"],
+            crop_filtered_data=config["crop_filtered_data"],
         )
 
         assert np.allclose(res.get(), ref, atol=6e-5), "test_opencl_filter: something wrong with config=%s" % (

nabu/reconstruction/tests/test_mlem.py

@@ -9,84 +9,113 @@ from nabu.reconstruction.mlem import MLEMReconstructor, __have_corrct__
 @pytest.fixture(scope="class")
 def bootstrap(request):
     cls = request.cls
-    datafile = get_data("sl_mlem.npz")
-    cls.data = datafile["data"]
+    datafile = get_data("test_mlem.npz")
+    cls.data_wvu = datafile["data_wvu"]
     cls.angles_rad = datafile["angles_rad"]
-    cls.random_u_shifts = datafile["random_u_shifts"]
-    cls.ref_rec_noshifts = datafile["ref_rec_noshifts"]
-    cls.ref_rec_shiftsu = datafile["ref_rec_shiftsu"]
-    cls.ref_rec_u_rand = datafile["ref_rec_u_rand"]
-    cls.ref_rec_shiftsv = datafile["ref_rec_shiftsv"]
-    # cls.ref_rec_v_rand = datafile["ref_rec_v_rand"]
-    cls.tol = 2e-4
+    cls.pixel_size_cm = datafile["pixel_size"] * 1e4  # pixel_size originally in um
+    cls.true_cor = datafile["true_cor"]
+    cls.mlem_cor_None_nosh = datafile["mlem_cor_None_nosh"]
+    cls.mlem_cor_truecor_nosh = datafile["mlem_cor_truecor_nosh"]
+    cls.mlem_cor_truecor_shifts_v0 = datafile["mlem_cor_truecor_shifts_v0"]
+    cls.shifts_uv_v0 = datafile["shifts_uv_v0"]
+    cls.shifts_uv = datafile["shifts_uv"]
+
+    cls.tol = 1.3e-4
 
 
 @pytest.mark.skipif(not (__has_pycuda__ and __have_corrct__), reason="Need pycuda and corrct for this test")
 @pytest.mark.usefixtures("bootstrap")
-class TestMLEM:
+class TestMLEMReconstructor:
     """These tests test the general MLEM reconstruction algorithm
     and the behavior of the reconstruction with respect to horizontal shifts.
     Only horizontal shifts are tested here because vertical shifts are handled outside
     the reconstruction object, but in the embedding reconstruction pipeline. See FullFieldReconstructor
+    It is compared against a reference reconstruction generated with the `rec_mlem` function
+    defined in the `generate_test_data.py` script.
     """
 
-    def _create_MLEM_reconstructor(self, shifts_uv=None):
-        return MLEMReconstructor(
-            self.data.shape, -self.angles_rad, shifts_uv, cor=0.0, n_iterations=10  # mind the sign
+    def _rec_mlem(self, cor, shifts_uv, data_wvu, angles_rad):
+        n_angles, n_z, n_x = data_wvu.shape
+
+        mlem = MLEMReconstructor(
+            (n_z, n_angles, n_x),
+            angles_rad,
+            shifts_uv=shifts_uv,
+            cor=cor,
+            n_iterations=50,
+            extra_options={"centered_axis": True, "clip_outer_circle": True, "scale_factor": 1 / self.pixel_size_cm},
         )
+        rec_mlem = mlem.reconstruct(data_wvu.swapaxes(0, 1))
+        return rec_mlem
 
-    def test_simple_mlem_recons(self):
-        R = self._create_MLEM_reconstructor()
-        rec = R.reconstruct(self.data)
-        delta = np.abs(rec[:, ::-1, :] - self.ref_rec_noshifts)
+    def test_simple_mlem_recons_cor_None_nosh(self):
+        slice_index = 25
+        rec = self._rec_mlem(None, None, self.data_wvu, self.angles_rad)[slice_index]
+        delta = np.abs(rec - self.mlem_cor_None_nosh)
         assert np.max(delta) < self.tol
 
-    def test_mlem_recons_with_u_shifts(self):
-        shifts = np.zeros((len(self.angles_rad), 2))
-        shifts[:, 0] = -5
-        R = self._create_MLEM_reconstructor(shifts)
-        rec = R.reconstruct(self.data)
-        delta = np.abs(rec[:, ::-1] - self.ref_rec_shiftsu)
-        assert np.max(delta) < self.tol
+    def test_simple_mlem_recons_cor_truecor_nosh(self):
+        slice_index = 25
+        rec = self._rec_mlem(self.true_cor, None, self.data_wvu, self.angles_rad)[slice_index]
+        delta = np.abs(rec - self.mlem_cor_truecor_nosh)
+        assert np.max(delta) < 2.6e-4
 
-    def test_mlem_recons_with_random_u_shifts(self):
-        R = self._create_MLEM_reconstructor(self.random_u_shifts)
-        rec = R.reconstruct(self.data)
-        delta = np.abs(rec[:, ::-1] - self.ref_rec_u_rand)
-        assert np.max(delta) < self.tol
+    def test_compare_with_fbp(self):
+        from nabu.reconstruction.fbp import Backprojector
+
+        def _rec_fbp(cor, shifts_uv, data_wvu, angles_rad):
+            n_angles, n_z, n_x = data_wvu.shape
 
-    def test_mlem_recons_with_constant_v_shifts(self):
-        from nabu.preproc.shift import VerticalShift
+            if shifts_uv is None:
+                fbp = Backprojector(
+                    (n_angles, n_x),
+                    angles=angles_rad,
+                    rot_center=cor,
+                    halftomo=False,
+                    padding_mode="edges",
+                    extra_options={
+                        "centered_axis": True,
+                        "clip_outer_circle": True,
+                        "scale_factor": 1 / self.pixel_size_cm,
+                    },
+                )
+            else:
+                fbp = Backprojector(
+                    (n_angles, n_x),
+                    angles=angles_rad,
+                    rot_center=cor,
+                    halftomo=False,
+                    padding_mode="edges",
+                    extra_options={
+                        "centered_axis": True,
+                        "clip_outer_circle": True,
+                        "scale_factor": 1 / self.pixel_size_cm,  # convert um to cm
+                        "axis_correction": shifts_uv[:, 0],
+                    },
+                )
 
+            rec_fbp = np.zeros((n_z, n_x, n_x), "f")
+            for i in range(n_z):
+                rec_fbp[i] = fbp.fbp(data_wvu[:, i])
+
+            return rec_fbp
+
+        fbp = _rec_fbp(self.true_cor, None, self.data_wvu, self.angles_rad)[25]
+        mlem = self._rec_mlem(self.true_cor, None, self.data_wvu, self.angles_rad)[25]
+        delta = np.abs(fbp - mlem)
+        assert (
+            np.max(delta) < 400
+        )  # These two should not be really equal. But the test should test that both algo FBP and MLEM behave similarly.
+
+    def test_mlem_zeroshifts_equal_noshifts(self):
         shifts = np.zeros((len(self.angles_rad), 2))
-        shifts[:, 1] = -20
-
-        nv, n_angles, nu = self.data.shape
-        radios_movements = VerticalShift(
-            (n_angles, nv, nu), -shifts[:, 1]
-        )  # Minus sign here mimics what is  done in the pipeline.
-        tmp_in = np.swapaxes(self.data, 0, 1).copy()
-        tmp_out = np.zeros_like(tmp_in)
-        radios_movements.apply_vertical_shifts(tmp_in, list(range(n_angles)), output=tmp_out)
-        data = np.swapaxes(tmp_out, 0, 1).copy()
-
-        R = self._create_MLEM_reconstructor(shifts)
-        rec = R.reconstruct(data)
-
-        axslice = 120
-        trslice = 84
-        axslice1 = self.ref_rec_shiftsv[axslice]
-        axslice2 = rec[axslice, ::-1]
-        trslice1 = self.ref_rec_shiftsv[trslice]
-        trslice2 = rec[trslice, ::-1]
-        # delta = np.abs(rec[:, ::-1] - self.ref_rec_shiftsv)
-        delta_ax = np.abs(axslice1 - axslice2)
-        delta_tr = np.abs(trslice1 - trslice2)
-        assert max(np.max(delta_ax), np.max(delta_tr)) < self.tol
-
-    @pytest.mark.skip(reason="No valid reference reconstruction for this test.")
-    def test_mlem_recons_with_random_v_shifts(self):
-        """NOT YET IMPLEMENTED.
-        This is a temporary version due to unpexcted behavior of CorrCT/Astra to
-        compute a reference implementation. See [question on Astra's github](https://github.com/astra-toolbox/astra-toolbox/discussions/520).
-        """
+        rec_nosh = self._rec_mlem(self.true_cor, None, self.data_wvu, self.angles_rad)
+        rec_zerosh = self._rec_mlem(self.true_cor, shifts, self.data_wvu, self.angles_rad)
+        delta = np.abs(rec_nosh - rec_zerosh)
+        assert np.max(delta) < self.tol
+
+    def test_mlem_recons_with_u_shifts(self):
+        slice_index = 25
+        rec = self._rec_mlem(self.true_cor, self.shifts_uv_v0, self.data_wvu, self.angles_rad)[slice_index]
+        delta = np.abs(rec - self.mlem_cor_truecor_shifts_v0)
+        assert np.max(delta) < self.tol

nabu/resources/dataset_analyzer.py

@@ -1,3 +1,4 @@
+from enum import Enum
 import os
 import numpy as np
 from silx.io.url import DataUrl
@@ -7,7 +8,7 @@ from tomoscan.esrf.scan.edfscan import EDFTomoScan
 from tomoscan.esrf.scan.nxtomoscan import NXtomoScan
 from packaging.version import parse as parse_version
 
-from ..utils import BaseClassError, check_supported, indices_to_slices
+from ..utils import BaseClassError, check_supported, indices_to_slices, is_scalar, search_sorted
 from ..io.reader import EDFStackReader, NXDarksFlats, NXTomoReader
 from ..io.utils import get_compacted_dataslices
 from .utils import get_values_from_file, is_hdf5_extension
@@ -16,6 +17,33 @@ from .logger import LoggerOrPrint
 from ..pipeline.utils import nabu_env_settings
 
 
+# We could import the 1000+ LoC  nxtomo.nxobject.nxdetector.ImageKey... or we can do this
+class ImageKey(Enum):
+    ALIGNMENT = -1
+    PROJECTION = 0
+    FLAT_FIELD = 1
+    DARK_FIELD = 2
+    INVALID = 3
+
+
+# ---
+
+_image_type = {
+    "projections": ImageKey.PROJECTION.value,
+    "projection": ImageKey.PROJECTION.value,
+    "radios": ImageKey.PROJECTION.value,
+    "radio": ImageKey.PROJECTION.value,
+    "flats": ImageKey.FLAT_FIELD.value,
+    "flat": ImageKey.FLAT_FIELD.value,
+    "darks": ImageKey.DARK_FIELD.value,
+    "dark": ImageKey.DARK_FIELD.value,
+    "static": ImageKey.ALIGNMENT.value,
+    "alignment": ImageKey.ALIGNMENT.value,
+    "return": ImageKey.ALIGNMENT.value,
+    "invalid": ImageKey.INVALID.value,
+}
+
+
 class DatasetAnalyzer:
     _scanner = None
     kind = "none"
@@ -285,6 +313,24 @@ class DatasetAnalyzer:
     def scan_dirname(self):
         raise BaseClassError
 
+    def get_alignment_projections(self, image_sub_region=None):
+        raise NotImplementedError
+
+    @property
+    def all_angles(self):
+        raise NotImplementedError
+
+    def get_frame(self, idx): ...
+
+    @property
+    def is_360(self):
+        """
+        Return True iff the scan is 360 degrees (regardless of half-tomo mode)
+        """
+        angles = self.rotation_angles
+        d_theta = angles[1] - angles[0]
+        return np.isclose(angles.max() - angles.min(), 2 * np.pi, atol=2 * d_theta)
+
 
 class EDFDatasetAnalyzer(DatasetAnalyzer):
     """
@@ -358,9 +404,6 @@ class HDF5DatasetAnalyzer(DatasetAnalyzer):
 
     _scanner = NXtomoScan
     kind = "nx"
-    # We could import the 1000+ LoC  nxtomo.nxobject.nxdetector.ImageKey... or we can do this
-    _image_key_value = {"flats": 1, "darks": 2, "radios": 0}
-    #
 
     @property
     def z_translation(self):
@@ -442,7 +485,8 @@ class HDF5DatasetAnalyzer(DatasetAnalyzer):
         slices = set()
         for du in get_compacted_dataslices(images).values():
             if du.data_slice() is not None:
-                s = (du.data_slice().start, du.data_slice().stop)
+                # note: du.data_slice is a uint in recent tomoscan version
+                s = (int(du.data_slice().start), int(du.data_slice().stop))
             else:
                 s = None
             slices.add(s)
@@ -452,7 +496,7 @@ class HDF5DatasetAnalyzer(DatasetAnalyzer):
     def _select_according_to_frame_type(self, data, frame_type):
         if data is None:
             return None
-        return data[self.dataset_scanner.image_key_control == self._image_key_value[frame_type]]
+        return data[self.dataset_scanner.image_key_control == _image_type[frame_type]]
 
     def get_reduced_flats(self, method="median", force_reload=False, **reader_kwargs):
         dkrf_reader = NXDarksFlats(
@@ -475,9 +519,7 @@ class HDF5DatasetAnalyzer(DatasetAnalyzer):
         For example, if the dataset flats are located at indices [1, 2, ..., 99], then
         frame_slices("flats") will return [slice(0, 100)].
         """
-        return indices_to_slices(
-            np.where(self.dataset_scanner.image_key_control == self._image_key_value[frame_type])[0]
-        )
+        return indices_to_slices(np.where(self.dataset_scanner.image_key_control == _image_type[frame_type])[0])
 
     def get_reader(self, **kwargs):
         return NXTomoReader(self.dataset_hdf5_url.file_path(), data_path=self.dataset_hdf5_url.data_path(), **kwargs)
@@ -492,18 +534,87 @@ class HDF5DatasetAnalyzer(DatasetAnalyzer):
         # os.path.dirname(di.dataset_hdf5_url.file_path())
         return self.dataset_scanner.path
 
+    def get_alignment_projections(self, image_sub_region=None):
+        """
+        Get the extra projections (if any) that are used as "reference projections" for alignment.
+        For certain scan, when completing a (half) turn, sometimes extra projections are acquired for alignment purpose.
 
-def analyze_dataset(dataset_path, extra_options=None, logger=None):
-    if not (os.path.isdir(dataset_path)):
-        if not (os.path.isfile(dataset_path)):
-            raise ValueError("Error: %s no such file or directory" % dataset_path)
-        if not (is_hdf5_extension(os.path.splitext(dataset_path)[-1].replace(".", ""))):
-            raise ValueError("Error: expected a HDF5 file")
-        dataset_analyzer_class = HDF5DatasetAnalyzer
-    else:  # directory -> assuming EDF
-        dataset_analyzer_class = EDFDatasetAnalyzer
-    dataset_structure = dataset_analyzer_class(dataset_path, extra_options=extra_options, logger=logger)
-    return dataset_structure
+        Returns
+        -------
+        projs: numpy.ndarray
+            Array with shape (n_projections, n_y, n_x)
+        angles: numpy.ndarray
+            Corresponding angles in degrees
+        indices:
+            Indices of projections
+        """
+        sub_region = None
+        if image_sub_region is not None:
+            sub_region = (None,) + image_sub_region
+        reader = self.get_reader(image_key=ImageKey.ALIGNMENT.value, sub_region=sub_region)
+        projs = reader.load_data()
+        indices = reader.get_frames_indices()
+        angles = get_angle_at_index(self.all_angles, indices)
+        return projs, angles, indices
+
+    @property
+    def all_angles(self):
+        return np.array(self.dataset_scanner.rotation_angle)
+
+    def get_index_from_angle(self, angle, image_key=0, return_found_angle=False):
+        """
+        Return the index of the image taken at rotation angle 'angle'.
+        By default look at the projections, i.e image_key = 0
+        """
+        all_angles = self.all_angles
+        all_indices = np.arange(len(all_angles))
+        all_image_key = self.dataset_scanner.image_key_control
+
+        idx2 = np.where(all_image_key == image_key)[0]
+        angles = all_angles[idx2]
+        idx_angles_sorted = np.argsort(angles)
+        angles_sorted = angles[idx_angles_sorted]
+
+        pos = search_sorted(angles_sorted, angle)
+        # this gives a position in "idx2", but we need the position in "all_indices"
+        idx = all_indices[idx2[idx_angles_sorted[pos]]]
+        if return_found_angle:
+            return idx, angles_sorted[pos]
+        return idx
+
+    def get_image_at_angle(self, angle_deg, image_type="projection", sub_region=None, return_angle_and_index=False):
+        image_key = _image_type[image_type]
+        idx, angle_found = self.get_index_from_angle(angle_deg, image_key=image_key, return_found_angle=True)
+
+        # Option 1:
+        if sub_region is None:
+            sub_region = (None, None)
+        # Convert absolute index to index of image_key
+        idx2 = np.searchsorted(np.where(self.dataset_scanner.image_key_control == image_key)[0], idx)
+        sub_region = (slice(idx2, idx2 + 1),) + sub_region
+        reader = self.get_reader(image_key=image_key, sub_region=sub_region)
+        img = reader.load_data()[0]
+        if return_angle_and_index:
+            return img, angle_found, idx
+        return img
+
+        # Option 2:
+        # return self.get_frame(idx)
+        # something like:
+        # [fr for fr in self.dataset_scanner.frames if fr.image_key.value == 0 and fr.rotation_angle == 180 and fr._is_control_frame is False]
+
+    def get_frame(self, idx):
+        return get_data(self.dataset_scanner.frames[idx].url)
+
+
+def get_angle_at_index(all_angles, index):
+    """
+    Return the rotation angle corresponding to image index 'index'
+    """
+    if is_scalar(index):
+        return all_angles[index]
+    else:
+        return all_angles[np.array(index)]
 
 
 def get_radio_pair(dataset_info, radio_angles: tuple, return_indices=False):
@@ -549,3 +660,16 @@ def get_radio_pair(dataset_info, radio_angles: tuple, return_indices=False):
         return radios, radios_indices
     else:
         return radios
+
+
+def analyze_dataset(dataset_path, extra_options=None, logger=None):
+    if not (os.path.isdir(dataset_path)):
+        if not (os.path.isfile(dataset_path)):
+            raise ValueError("Error: %s no such file or directory" % dataset_path)
+        if not (is_hdf5_extension(os.path.splitext(dataset_path)[-1].replace(".", ""))):
+            raise ValueError("Error: expected a HDF5 file")
+        dataset_analyzer_class = HDF5DatasetAnalyzer
+    else:  # directory -> assuming EDF
+        dataset_analyzer_class = EDFDatasetAnalyzer
+    dataset_structure = dataset_analyzer_class(dataset_path, extra_options=extra_options, logger=logger)
+    return dataset_structure