nabu 2025.1.0.dev14__py3-none-any.whl → 2025.1.0rc2__py3-none-any.whl

nabu/pipeline/tests/test_estimators.py

@@ -1,14 +1,23 @@
 import os
+from tempfile import TemporaryDirectory
 import pytest
 import numpy as np
-from nabu.testutils import utilstest, __do_long_tests__
-from nabu.resources.dataset_analyzer import HDF5DatasetAnalyzer, analyze_dataset
+from pint import get_application_registry
+from nxtomo import NXtomo
+from nabu.testutils import utilstest, __do_long_tests__, get_data
+from nabu.resources.dataset_analyzer import HDF5DatasetAnalyzer, analyze_dataset, ImageKey
 from nabu.resources.nxflatfield import update_dataset_info_flats_darks
 from nabu.resources.utils import extract_parameters
-from nabu.pipeline.estimators import CompositeCOREstimator
+from nabu.pipeline.estimators import CompositeCOREstimator, TranslationsEstimator
 from nabu.pipeline.config import parse_nabu_config_file
 from nabu.pipeline.estimators import SinoCORFinder, CORFinder
 
+from nabu.estimation.tests.test_motion_estimation import (
+    check_motion_estimation,
+    project_volume,
+    _create_translations_vector,
+)
+
 
 #
 # Test CoR estimation with "composite-coarse-to-fine" (aka "near" in the legacy system vocable)
@@ -119,3 +128,231 @@ class TestCorNearPos:
             cor = finder.find_cor()
             message = f"Computed CoR {cor} and expected CoR {self.true_cor} do not coincide. Near_pos options was set to {cor_options.get('near_pos',None)}."
             assert np.isclose(self.true_cor + 0.5, cor, atol=self.abs_tol), message
+
+
+def _add_fake_flats_and_dark_to_data(data, n_darks=10, n_flats=21, dark_val=1, flat_val=3):
+    img_shape = data.shape[1:]
+    # Use constant darks/flats, to avoid "reduction" (mean/median) issues
+    fake_darks = np.ones((n_darks,) + img_shape, dtype=np.uint16) * dark_val
+    fake_flats = np.ones((n_flats,) + img_shape, dtype=np.uint16) * flat_val
+    return data * (fake_flats[0, 0, 0] - fake_darks[0, 0, 0]) + fake_darks[0, 0, 0], fake_darks, fake_flats
+
+
+def _generate_nx_for_180_dataset(volume, output_file_path, n_darks=10, n_flats=21):
+
+    n_angles = 250
+    cor = -10
+
+    alpha_x = 4
+    beta_x = 3
+    alpha_y = -5
+    beta_y = 10
+    beta_z = 0
+    orig_det_dist = 0
+
+    angles0 = np.linspace(0, np.pi, n_angles, False)
+    return_angles = np.deg2rad([180.0, 135.0, 90.0, 45.0, 0.0])
+    angles = np.hstack([angles0, return_angles]).ravel()
+    a = np.arange(angles0.size + return_angles.size) / angles0.size
+
+    tx = _create_translations_vector(a, alpha_x, beta_x)
+    ty = _create_translations_vector(a, alpha_y, beta_y)
+    tz = _create_translations_vector(a, 0, beta_z)
+
+    sinos = project_volume(volume, angles, -tx, -ty, -tz, cor=-cor, orig_det_dist=orig_det_dist)
+    data = np.moveaxis(sinos, 1, 0)
+
+    sample_motion_xy = np.stack([-tx, ty], axis=1)
+    sample_motion_z = -tz
+    angles_deg = np.degrees(angles0)
+    return_angles_deg = np.degrees(return_angles)
+    n_return_radios = len(return_angles_deg)
+    n_radios = data.shape[0] - n_return_radios
+
+    ureg = get_application_registry()
+    fake_raw_data, darks, flats = _add_fake_flats_and_dark_to_data(data, n_darks=n_darks, n_flats=n_flats)
+
+    nxtomo = NXtomo()
+    nxtomo.instrument.detector.data = np.concatenate(
+        [
+            darks,
+            flats,
+            fake_raw_data,  # radios + return radios (in float32 !)
+        ]
+    )
+    image_key_control = np.concatenate(
+        [
+            [ImageKey.DARK_FIELD.value] * n_darks,
+            [ImageKey.FLAT_FIELD.value] * n_flats,
+            [ImageKey.PROJECTION.value] * n_radios,
+            [ImageKey.ALIGNMENT.value] * n_return_radios,
+        ]
+    )
+    nxtomo.instrument.detector.image_key_control = image_key_control
+
+    rotation_angle = np.concatenate(
+        [np.zeros(n_darks, dtype="f"), np.zeros(n_flats, dtype="f"), angles_deg, return_angles_deg]
+    )
+    nxtomo.sample.rotation_angle = rotation_angle * ureg.degree
+    nxtomo.instrument.detector.field_of_view = "Full"
+    nxtomo.instrument.detector.x_pixel_size = nxtomo.instrument.detector.y_pixel_size = 1 * ureg.micrometer
+    nxtomo.save(file_path=output_file_path, data_path="entry", overwrite=True)
+
+    return sample_motion_xy, sample_motion_z, cor
+
+
+def _generate_nx_for_360_dataset(volume, output_file_path, n_darks=10, n_flats=21):
+
+    n_angles = 250
+    cor = -5.5
+
+    alpha_x = -2
+    beta_x = 7.0
+    alpha_y = -2
+    beta_y = 3
+    beta_z = 100
+    orig_det_dist = 0
+
+    angles = np.linspace(0, 2 * np.pi, n_angles, False)
+    a = np.linspace(0, 1, angles.size, endpoint=False)  # theta/theta_max
+
+    tx = _create_translations_vector(a, alpha_x, beta_x)
+    ty = _create_translations_vector(a, alpha_y, beta_y)
+    tz = _create_translations_vector(a, 0, beta_z)
+
+    sinos = project_volume(volume, angles, -tx, -ty, -tz, cor=-cor, orig_det_dist=orig_det_dist)
+    data = np.moveaxis(sinos, 1, 0)
+
+    sample_motion_xy = np.stack([-tx, ty], axis=1)
+    sample_motion_z = -tz
+    angles_deg = np.degrees(angles)
+
+    ureg = get_application_registry()
+
+    fake_raw_data, darks, flats = _add_fake_flats_and_dark_to_data(data, n_darks=n_darks, n_flats=n_flats)
+
+    nxtomo = NXtomo()
+    nxtomo.instrument.detector.data = np.concatenate([darks, flats, fake_raw_data])  # in float32 !
+
+    image_key_control = np.concatenate(
+        [
+            [ImageKey.DARK_FIELD.value] * n_darks,
+            [ImageKey.FLAT_FIELD.value] * n_flats,
+            [ImageKey.PROJECTION.value] * data.shape[0],
+        ]
+    )
+    nxtomo.instrument.detector.image_key_control = image_key_control
+
+    rotation_angle = np.concatenate(
+        [
+            np.zeros(n_darks, dtype="f"),
+            np.zeros(n_flats, dtype="f"),
+            angles_deg,
+        ]
+    )
+    nxtomo.sample.rotation_angle = rotation_angle * ureg.degree
+    nxtomo.instrument.detector.field_of_view = "Full"
+    nxtomo.instrument.detector.x_pixel_size = nxtomo.instrument.detector.y_pixel_size = 1 * ureg.micrometer
+    nxtomo.save(file_path=output_file_path, data_path="entry", overwrite=True)
+
+    return sample_motion_xy, sample_motion_z, cor
+
+
+@pytest.fixture(scope="class")
+def setup_test_motion_estimator(request):
+    cls = request.cls
+    cls.volume = get_data("motion/mri_volume_subsampled.npy")
+
+
+@pytest.mark.skipif(not (__do_long_tests__), reason="need environment variable NABU_LONG_TESTS=1")
+@pytest.mark.usefixtures("setup_test_motion_estimator")
+class TestMotionEstimator:
+
+    def _setup(self, tmpdir):
+        # pytest uses some weird data structure for "tmpdir"
+        if not (isinstance(tmpdir, str)):
+            tmpdir = str(tmpdir)
+        #
+        if getattr(self, "volume", None) is None:
+            self.volume = get_data("motion/mri_volume_subsampled.npy")
+
+    def test_estimate_motion_360_dataset(self, tmpdir, verbose=False):
+        self._setup(tmpdir)
+        nx_file_path = os.path.join(tmpdir, "mri_projected_360_motion.nx")
+        sample_motion_xy, sample_motion_z, cor = _generate_nx_for_360_dataset(self.volume, nx_file_path)
+
+        dataset_info = analyze_dataset(nx_file_path)
+
+        translations_estimator = TranslationsEstimator(
+            dataset_info, do_flatfield=True, rot_center=cor, angular_subsampling=5, deg_xy=2, deg_z=2
+        )
+        estimated_shifts_h, estimated_shifts_v, estimated_cor = translations_estimator.estimate_motion()
+
+        s = translations_estimator.angular_subsampling
+        if verbose:
+            translations_estimator.motion_estimator.plot_detector_shifts(cor=cor)
+            translations_estimator.motion_estimator.plot_movements(
+                cor=cor,
+                angles_rad=dataset_info.rotation_angles[::s],
+                gt_xy=sample_motion_xy[::s, :],
+                gt_z=sample_motion_z[::s],
+            )
+        check_motion_estimation(
+            translations_estimator.motion_estimator,
+            dataset_info.rotation_angles[::s],
+            cor,
+            sample_motion_xy[::s, :],
+            sample_motion_z[::s],
+            fit_error_shifts_tol_vu=(0.2, 0.2),
+            fit_error_det_tol_vu=(1e-5, 5e-2),
+            fit_error_tol_xyz=(0.05, 0.05, 0.05),
+            fit_error_det_all_angles_tol_vu=(1e-5, 0.05),
+        )
+
+    def test_estimate_motion_180_dataset(self, tmpdir, verbose=False):
+        self._setup(tmpdir)
+        nx_file_path = os.path.join(tmpdir, "mri_projected_180_motion.nx")
+
+        sample_motion_xy, sample_motion_z, cor = _generate_nx_for_180_dataset(self.volume, nx_file_path)
+
+        dataset_info = analyze_dataset(nx_file_path)
+
+        translations_estimator = TranslationsEstimator(
+            dataset_info,
+            do_flatfield=True,
+            rot_center=cor,
+            angular_subsampling=2,
+            deg_xy=2,
+            deg_z=2,
+            shifts_estimator="DetectorTranslationAlongBeam",
+        )
+        estimated_shifts_h, estimated_shifts_v, estimated_cor = translations_estimator.estimate_motion()
+
+        if verbose:
+            translations_estimator.motion_estimator.plot_detector_shifts(cor=cor)
+            translations_estimator.motion_estimator.plot_movements(
+                cor=cor,
+                angles_rad=dataset_info.rotation_angles,
+                gt_xy=sample_motion_xy[: dataset_info.n_angles],
+                gt_z=sample_motion_z[: dataset_info.n_angles],
+            )
+
+        check_motion_estimation(
+            translations_estimator.motion_estimator,
+            dataset_info.rotation_angles,
+            cor,
+            sample_motion_xy,
+            sample_motion_z,
+            fit_error_shifts_tol_vu=(0.02, 0.1),
+            fit_error_det_tol_vu=(1e-2, 0.5),
+            fit_error_tol_xyz=(0.5, 2, 1e-2),
+            fit_error_det_all_angles_tol_vu=(1e-2, 2),
+        )
+
+
+if __name__ == "__main__":
+
+    T = TestMotionEstimator()
+    with TemporaryDirectory(suffix="_motion", prefix="nabu_testdata") as tmpdir:
+        T.test_estimate_motion_360_dataset(tmpdir, verbose=True)
+        T.test_estimate_motion_180_dataset(tmpdir, verbose=True)

nabu/preproc/ccd.py

@@ -1,5 +1,6 @@
 import numpy as np
 from ..utils import check_supported
+from scipy.ndimage import binary_dilation
 from silx.math.medianfilter import medfilt2d
 
 
@@ -13,6 +14,7 @@ class CCDFilter:
     def __init__(
         self,
         radios_shape: tuple,
+        kernel_size: int = 3,
         correction_type: str = "median_clip",
         median_clip_thresh: float = 0.1,
         abs_diff=False,
@@ -26,6 +28,9 @@ class CCDFilter:
         radios_shape: tuple
             A tuple describing the shape of the radios stack, in the form
             `(n_radios, n_z, n_x)`.
+        kernel_size: int
+            Size of the kernel for the median filter.
+            Default is 3.
         correction_type: str
             Correction type for radios ("median_clip", "sigma_clip", ...)
         median_clip_thresh: float, optional
@@ -48,6 +53,7 @@ class CCDFilter:
              then this pixel value is set to the median value.
         """
         self._set_radios_shape(radios_shape)
+        self.kernel_size = kernel_size
         check_supported(correction_type, self._supported_ccd_corrections, "CCD correction mode")
         self.correction_type = correction_type
         self.median_clip_thresh = median_clip_thresh
@@ -67,11 +73,11 @@ class CCDFilter:
         self.shape = (n_z, n_x)
 
     @staticmethod
-    def median_filter(img):
+    def median_filter(img, kernel_size=3):
         """
         Perform a median filtering on an image.
         """
-        return medfilt2d(img, (3, 3), mode="reflect")
+        return medfilt2d(img, (kernel_size, kernel_size), mode="reflect")
 
     def median_clip_mask(self, img, return_medians=False):
         """
@@ -85,7 +91,7 @@ class CCDFilter:
         return_medians: bool, optional
             Whether to return the median values additionally to the mask.
         """
-        median_values = self.median_filter(img)
+        median_values = self.median_filter(img, kernel_size=self.kernel_size)
         if not self.abs_diff:
             invalid_mask = img >= median_values + self.median_clip_thresh
         else:
@@ -124,6 +130,50 @@ class CCDFilter:
 
         return output
 
+    def dezinger_correction(self, radios, dark=None, nsigma=5, output=None):
+        """
+        Compute the median clip correction on a radios stack, and propagates the invalid pixels into vert and horiz directions.
+
+        Parameters
+        ----------
+        radios: numpy.ndarray
+            A radios stack.
+        dark: numpy.ndarray, optional
+            A dark image. Default is None. If not None, it is subtracted from the radios.
+        nsigma: float, optional
+            Number of standard deviations to use for the zinger detection.
+            Default is 5.
+        output: numpy.ndarray, optional
+            Output array
+        """
+        if radios.shape[1:] != self.radios_shape[1:]:
+            raise ValueError(f"Expected radios shape {self.radios_shape}, got {radios.shape}")
+
+        if output is None:
+            output = np.copy(radios)
+        else:
+            output[:] = radios[:]
+
+        n_radios = radios.shape[0]
+        for i in range(n_radios):
+            if dark is None:
+                dimg = radios[i]
+            elif dark.shape == radios.shape[1:]:
+                dimg = radios[i] - dark
+            else:
+                raise ValueError("Dark image shape does not match radios shape.")
+
+            dimg = radios[i] - dark
+            med = self.median_filter(dimg, self.kernel_size)
+            err = dimg - med
+            ds0 = err.std()
+            msk = err > ds0 * nsigma
+            gromsk = binary_dilation(msk)
+
+            output[i] = np.where(gromsk, med, radios[i])
+
+        return output
+
 
 class Log:
     """

nabu/preproc/flatfield.py

@@ -1,8 +1,11 @@
+import os
 from multiprocessing.pool import ThreadPool
 from bisect import bisect_left
 import numpy as np
+from tomoscan.io import HDF5File
 from ..io.reader import load_images_from_dataurl_dict
 from ..utils import check_supported, deprecated_class, get_num_threads
+from .ccd import CCDFilter
 
 
 class FlatFieldArrays:
@@ -102,7 +105,7 @@ class FlatFieldArrays:
         self._precompute_flats_indices_weights()
         self._configure_srcurrent_normalization(radios_srcurrent, flats_srcurrent)
         self.distortion_correction = distortion_correction
-        self.n_threads = min(1, get_num_threads(n_threads) // 2)
+        self.n_threads = max(1, get_num_threads(n_threads) // 2)
 
     def _set_parameters(self, radios_shape, radios_indices, interpolation, nan_value):
         self._set_radios_shape(radios_shape)
@@ -450,3 +453,305 @@ class FlatFieldDataUrls(FlatField):
             radios_srcurrent=radios_srcurrent,
             flats_srcurrent=flats_srcurrent,
         )
+
+
+class PCAFlatsNormalizer:
+    """This class implement a flatfield normalization based on a PCA of a series of acauired flatfields.
+    The PCA decomposition is handled by a PCAFlatsDecomposer object.
+
+    This implementation was proposed by Jailin C. et al in https://doi.org/10.1107/S1600577516015812.
+
+    Code initially written by ID11 @ ESRF staff.
+    Jonathan Wright - Implementation based on research paper
+    Pedro D. Resende - Added saving and loading from file capabilities
+
+    Jerome Lesaint - Integrated the solution in Nabu.
+
+    """
+
+    def __init__(self, components, dark, mean):
+        """Initializes all variables needed to perform the flatfield normalization.
+
+        Parameters
+        -----------
+        components: ndarray
+            The components of the PCA decomposition.
+        dark: ndarray
+            The dark image. Should be one single 2D image.
+        mean: ndarray
+            The mean image of the series of flats.
+        """
+        ones = np.ones_like(components[0], dtype=np.float32)[np.newaxis]  # This comp will account for I0
+        self.components = np.concatenate([ones, components], axis=0)
+        self.dark = dark
+        self.mean = mean
+        self.n_threads = max(1, get_num_threads() // 2)
+        self._setmask()
+        self.ccdfilter = CCDFilter(mean.shape)
+
+    def _form_lsq_matrix(self):
+        """This function form the Least Square matrix, based on the flats components and the mask."""
+        self.Amat = np.stack([gg for gg in self.g], axis=1)  # JL: this is the matrix for the fit
+
+    def _setmask(self, prop=0.125):
+        """Sets the mask to select where the model is going to be fitted.
+
+        Parameters
+        ----------
+        prop: float, default: 0.125
+            The proportion of the image width to take on each side of the image as a mask.
+
+            By default it sets the strips on each side of the frame in the form:
+                mask[:, lim:] = True
+                mask[:, -lim:] = True
+            Where lim = prop * flat.shape[1]
+
+        If you need a custom mask, see update_mask() method.
+        """
+
+        lim = int(prop * self.mean.shape[1])
+        self.mask = np.zeros(self.mean.shape, dtype=bool)
+        self.mask[:, :lim] = True
+        self.mask[:, -lim:] = True
+        self.g = []
+        for component in self.components:
+            self.g.append(component[self.mask])
+
+        self._form_lsq_matrix()
+
+    def update_mask(self, mask: np.ndarray):
+        """Method to update the mask with a custom mask in the form of a boolean 2+D array.
+
+        Paramters
+        =========
+        mask: np.ndarray of Boolean;
+            The array of boolean allows the selection of the region of the image that will be used to fit against the components.
+
+        It will set the mask, replacing the standard mask created with setmask().
+        """
+        if mask.dtype == bool:
+            self.mask = mask
+            self.g = []
+            for component in self.components:
+                self.g.append(component[self.mask])
+
+            self._form_lsq_matrix()
+        else:
+            raise TypeError("Not a boolean array. Will keep the default mask")
+
+    def normalize_radios(self, projections, mask=None, prop=0.125):
+        """This is to keep the flatfield API in the pipeline."""
+        self.correct_stack(projections, mask=mask, prop=prop)
+
+    def correct_stack(
+        self,
+        projections: np.ndarray,
+        mask: np.ndarray = None,
+        prop: float = 0.125,
+    ):
+        """This functions normalizes the stack of projections.
+
+        Performs correction on a stack of projections based on the calculated decomposition.
+        The normalizations is done in-place. The previous projections before normalization are lost.
+
+        Parameters
+        ----------
+        projections: ndarray
+            Stack of projections to normalize.
+
+        prop: float (default: {0.125})
+            Fraction to mask on the horizontal field of view, assuming vertical rotation axis
+
+        mask: np.ndarray (default: None)
+            Custom mask if your data requires it.
+
+        Returns
+        -------
+        corrected projections: np.ndarray
+            Flat field corrected images. Note that the returned projections are exp-transformed to fit the pipeline (e.g. to allow for phase retrieval).
+        """
+        self.projections = self.ccdfilter.dezinger_correction(projections, self.dark)
+
+        if mask is not None:
+            self.update_mask(mask=mask)
+        else:
+            self._setmask(prop=prop)
+
+        with ThreadPool(self.n_threads) as tp:
+            for i, cor, sol in tp.map(self._readcorrect1, range(len(projections))):
+                # solution[i] = sol
+                projections[i] = np.exp(-cor)
+
+    def _readcorrect1(self, ii):
+        """Method to allow parallelization of the normalization."""
+        corr, s = self.correctproj(self.projections[ii])
+        return ii, corr, s
+
+    def correctproj(self, projection):
+        """Performs the correction on one projection of the stack.
+
+        Parameters
+        ----------
+        projection: np.ndarray, float
+            Radiograph from the acquisition stack.
+
+        Returns
+        -------
+        The fitted projection.
+        """
+        logp = np.log(projection.astype(np.float32) - self.dark)
+        corr = self.mean - logp
+        # model to be fitted !!
+        return self.fit(corr)
+
+    def fit(self, corr):
+        """Fit the (masked) projection to the (masked) components of the PCA decomposition.
+
+        This is for each projection, so worth optimising ...
+        """
+        y = corr[self.mask]
+        solution = np.linalg.lstsq(self.Amat, y, rcond=None)[0]
+        correction = np.einsum("ijk,i->jk", self.components, solution)
+        return corr - correction, solution
+
+
+class PCAFlatsDecomposer:
+    """This class implements a PCA decomposition of a serie of acquired flatfields.
+    The PCA decomposition is used to normalize the projections through a PCAFLatNormalizer object.
+
+    This implementation was proposed by Jailin C. et al in https://doi.org/10.1107/S1600577516015812.
+
+    Code initially written by ID11 @ ESRF staff.
+    Jonathan Wright - Implementation based on research paper
+    Pedro D. Resende - Added saving and loading from file capabilities
+
+    Jerome Lesaint - Integrated the solution in Nabu.
+    """
+
+    def __init__(self, flats: np.ndarray, darks: np.ndarray, nsigma=3):
+        """
+
+        Parameters
+        -----------
+        flats: np.ndarray
+            A stack of darks corrected flat field images
+        darks: np.ndarray
+            An image or stack of images of the dark current images of the camera.
+
+        Does the log scaling.
+        Subtracts mean and does eigenvector decomposition.
+        """
+        self.n_threads = max(1, get_num_threads() // 2)
+        self.flats = np.empty(flats.shape, dtype=np.float32)
+
+        darks = darks.astype(np.float32)
+        if darks.ndim == 3:
+            self.dark = np.median(darks, axis=0)
+        else:
+            self.dark = darks.copy()
+        del darks
+
+        self.nsigma = nsigma
+        self.ccdfilter = CCDFilter(self.dark.shape)
+        self._ccdfilter_and_log(flats)  # Log is taken here (after dezinger)
+
+        self.mean = np.mean(self.flats, axis=0)  # average
+
+        self.flats = self.flats - self.mean  # makes a copy
+        self.cov = self.compute_correlation_matrix()
+        self.compute_pca()
+        self.generate_pca_flats(nsigma=nsigma)  # Default nsigma=3
+
+    def __str__(self):
+
+        return f"PCA decomposition from flat images. \nThere are {self.components} components created at {self.sigma} level."
+
+    def _ccdfilter_and_log(self, flats: np.ndarray):
+        """Dezinger (substract dark, apply median filter) and takes log of the flat stack"""
+
+        self.ccdfilter.dezinger_correction(flats, self.dark, nsigma=self.nsigma)
+
+        with ThreadPool(self.n_threads) as tp:
+            for i, frame in enumerate(tp.map(np.log, flats)):
+                self.flats[i] = frame
+
+    @staticmethod
+    def ccij(args):
+        """Compute the covariance (img[i]*img[j]).sum() / npixels
+        It is a wrapper for threading.
+        args == i, j, npixels, imgs
+        """
+
+        i, j, NY, imgs = args
+        return i, j, np.einsum("ij,ij", imgs[i], imgs[j]) / NY
+
+    def compute_correlation_matrix(self):
+        """Computes an (nflats x nflats) correlation matrix"""
+
+        N = len(self.flats)
+        CC = np.zeros((N, N), float)
+        args = [(i, j, N, self.flats) for i in range(N) for j in range(i + 1)]
+        with ThreadPool(self.n_threads) as tp:
+            for i, j, result in tp.map(self.ccij, args):
+                CC[i, j] = CC[j, i] = result
+        return CC
+
+    def compute_pca(self):
+        """Gets eigenvectors and eigenvalues and sorts them into order"""
+
+        self.eigenvalues, self.eigenvectors = np.linalg.eigh(
+            self.cov
+        )  # Not sure why the eigh is needed. eig should be enough.
+        order = np.argsort(abs(self.eigenvalues))[::-1]  # high to low
+        self.eigenvalues = self.eigenvalues[order]
+        self.eigenvectors = self.eigenvectors[:, order]
+
+    def generate_pca_flats(self, nsigma=3):
+        """Projects the eigenvectors back into image space.
+
+        Parameters
+        ----------
+        nsigma: int (default: 3)
+        """
+
+        self.sigma = nsigma
+        av = abs(self.eigenvalues)
+        N = (av > (av[-2] * nsigma)).sum()  # Go for 3 sigma
+        self.components = [
+            None,
+        ] * N
+
+        def calculate(ii):
+            calc = np.einsum("i,ijk->jk", self.eigenvectors[:, ii], self.flats)
+            norm = (calc**2).sum()
+            return ii, calc / np.sqrt(norm)
+
+        with ThreadPool(self.n_threads) as tp:
+            for ii, result in tp.map(calculate, range(N)):
+                self.components[ii] = result
+
+        # simple gradients
+        r, c = self.components[0].shape
+        self.components.append(np.outer(np.ones(r), np.linspace(-1 / c, 1 / c, c)))
+        self.components.append(np.outer(np.linspace(-1 / r, 1 / r, r), np.ones(c)))
+
+    def save_decomposition(self, path="PCA_flats.h5", overwrite=True, entry="entry0000"):
+        """Saves the basic information of a PCA decomposition in view of the normalization of projections.
+
+        Parameters
+        ----------
+        path: str (default: "PCA_flats.h5")
+            Full path to the h5 file you want to save your results. It will overwrite!! Be careful.
+        """
+
+        file_exists = os.path.exists(path)
+        if overwrite or not file_exists:
+            with HDF5File(path, "w") as hout:
+                group = hout.create_group(entry)
+                group["eigenvalues"] = self.eigenvalues
+                group["dark"] = self.dark.astype(np.float32)
+                group["p_mean"] = self.mean.astype(np.float32)
+                group["p_components"] = np.array(self.components)
+                hout.flush()
+        else:
+            raise OSError(f"The file {path} already exists and you chose to NOT overwrite.")