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

build/lib/build/lib/nabu/pipeline/params.py

@@ -0,0 +1,163 @@
+flatfield_modes = {
+    "true": True,
+    "1": True,
+    "false": False,
+    "0": False,
+    "forced": "force-load",
+    "force-load": "force-load",
+    "force-compute": "force-compute",
+}
+
+phase_retrieval_methods = {
+    "": None,
+    "none": None,
+    "paganin": "paganin",
+    "tie": "paganin",
+    "ctf": "CTF",
+}
+
+unsharp_methods = {
+    "gaussian": "gaussian",
+    "log": "log",
+    "laplacian": "log",
+    "imagej": "imagej",
+    "none": None,
+    "": None,
+}
+
+padding_modes = {
+    "edges": "edge",
+    "edge": "edge",
+    "mirror": "mirror",
+    "zeros": "zeros",
+    "zero": "zeros",
+}
+
+reconstruction_methods = {"fbp": "FBP", "cone": "cone", "conic": "cone", "none": None, "": None}
+
+fbp_filters = {
+    "ramlak": "ramlak",
+    "ram-lak": "ramlak",
+    "none": None,
+    "": None,
+    "shepp-logan": "shepp-logan",
+    "cosine": "cosine",
+    "hamming": "hamming",
+    "hann": "hann",
+    "tukey": "tukey",
+    "lanczos": "lanczos",
+    "hilbert": "hilbert",
+}
+
+iterative_methods = {
+    "tv": "TV",
+    "wavelets": "wavelets",
+    "l2": "L2",
+    "ls": "L2",
+    "sirt": "SIRT",
+    "em": "EM",
+}
+
+optim_algorithms = {
+    "chambolle": "chambolle-pock",
+    "chambollepock": "chambolle-pock",
+    "fista": "fista",
+}
+
+files_formats = {
+    "h5": "hdf5",
+    "hdf5": "hdf5",
+    "nexus": "hdf5",
+    "nx": "hdf5",
+    "npy": "npy",
+    "npz": "npz",
+    "tif": "tiff",
+    "tiff": "tiff",
+    "jp2": "jp2",
+    "jp2k": "jp2",
+    "j2k": "jp2",
+    "jpeg2000": "jp2",
+    "edf": "edf",
+    "vol": "vol",
+}
+
+distribution_methods = {
+    "local": "local",
+    "slurm": "slurm",
+    "": "local",
+    "preview": "preview",
+}
+
+log_levels = {
+    "0": "error",
+    "1": "warning",
+    "2": "info",
+    "3": "debug",
+}
+
+sino_normalizations = {
+    "none": None,
+    "": None,
+    "chebyshev": "chebyshev",
+    "subtraction": "subtraction",
+    "division": "division",
+}
+
+cor_methods = {
+    "auto": "centered",
+    "centered": "centered",
+    "global": "global",
+    "sino sliding window": "sino-sliding-window",
+    "sino-sliding-window": "sino-sliding-window",
+    "sliding window": "sliding-window",
+    "sliding-window": "sliding-window",
+    "sino growing window": "sino-growing-window",
+    "sino-growing-window": "sino-growing-window",
+    "growing window": "growing-window",
+    "growing-window": "growing-window",
+    "sino-coarse-to-fine": "sino-coarse-to-fine",
+    "composite-coarse-to-fine": "composite-coarse-to-fine",
+    "near": "composite-coarse-to-fine",
+    "fourier-angles": "fourier-angles",
+    "fourier angles": "fourier-angles",
+    "fourier-angle": "fourier-angles",
+    "fourier angle": "fourier-angles",
+    "octave-accurate": "octave-accurate",
+}
+
+
+tilt_methods = {
+    "1d-correlation": "1d-correlation",
+    "1dcorrelation": "1d-correlation",
+    "polarfft": "fft-polar",
+    "polar-fft": "fft-polar",
+    "fft-polar": "fft-polar",
+}
+
+rings_methods = {
+    "none": None,
+    "": None,
+    "munch": "munch",
+    "mean-subtraction": "mean-subtraction",
+    "mean_subtraction": "mean-subtraction",
+    "mean-division": "mean-division",
+    "mean_division": "mean-division",
+    "vo": "vo",
+}
+
+detector_distortion_correction_methods = {"none": None, "": None, "identity": "identity", "map_xz": "map_xz"}
+
+
+radios_rotation_mode = {
+    "none": None,
+    "": None,
+    "chunk": "chunk",
+    "chunks": "chunk",
+    "full": "full",
+}
+
+exclude_projections_type = {
+    "indices": "indices",
+    "angular_range": "angular_range",
+    "angles": "angles",
+}

build/lib/build/lib/nabu/pipeline/processconfig.py

@@ -0,0 +1,210 @@
+import os
+from .config import parse_nabu_config_file
+from ..utils import is_writeable
+from ..resources.logger import Logger, PrinterLogger
+from .config import validate_config
+from ..resources.dataset_analyzer import analyze_dataset
+from .estimators import DetectorTiltEstimator
+
+
+class ProcessConfigBase:
+    """
+    A class for describing the Nabu process configuration.
+    """
+
+    # Must be overriden by inheriting class
+    default_nabu_config = None
+    config_renamed_keys = None
+
+    def __init__(
+        self,
+        conf_fname=None,
+        conf_dict=None,
+        dataset_info=None,
+        create_logger=False,
+    ):
+        """
+        Initialize a ProcessConfig class.
+
+        Parameters
+        ----------
+        conf_fname: str
+            Path to the nabu configuration file. If provided, the parameters
+            `conf_dict` is ignored.
+        conf_dict: dict
+            A dictionary describing the nabu processing steps.
+            If provided, the parameter `conf_fname` is ignored.
+        dataset_info: DatasetAnalyzer
+            A `DatasetAnalyzer` class instance.
+        checks: bool, optional, default is True
+            Whether to perform checks on configuration and datasets (recommended !)
+        remove_unused_radios: bool, optional, default is True
+            Whether to remove unused radios, i.e radios present in the dataset,
+            but not explicitly listed in the scan metadata.
+        create_logger: str or bool, optional
+            Whether to create a Logger object. Default is False, meaning that the logger
+            object creation is left to the user.
+            If set to True, a Logger object is created, and logs will be written
+            to the file "nabu_dataset_name.log".
+            If set to a string, a Logger object is created, and the logs will be written
+            to the file specified by this string.
+        """
+
+        # Step (1a): create 'nabu_config'
+        self._parse_configuration(conf_fname, conf_dict)
+        self._create_logger(create_logger)
+
+        # Step (1b): create 'dataset_info'
+        self._browse_dataset(dataset_info)
+
+        # Step (2)
+        self._update_dataset_info_with_user_config()
+
+        # Step (3): estimate tilt, CoR, ...
+        self._dataset_estimations()
+
+        # Step (4)
+        self._coupled_validation()
+
+        # Step (5)
+        self._build_processing_steps()
+
+        # Step (6)
+        self._configure_save_steps()
+        self._configure_resume()
+
+    def _create_logger(self, create_logger):
+        if create_logger is False:
+            self.logger = PrinterLogger()
+            return
+        elif create_logger is True:
+            dataset_loc = self.nabu_config["dataset"]["location"]
+            dataset_fname_rel = os.path.basename(dataset_loc)
+            if os.path.isfile(dataset_loc):
+                logger_filename = os.path.join(
+                    os.path.abspath(os.getcwd()), os.path.splitext(dataset_fname_rel)[0] + "_nabu.log"
+                )
+            else:
+                logger_filename = os.path.join(os.path.abspath(os.getcwd()), dataset_fname_rel + "_nabu.log")
+        elif isinstance(create_logger, str):
+            logger_filename = create_logger
+        else:
+            raise ValueError("Expected bool or str for create_logger")
+        if not is_writeable(os.path.dirname(logger_filename)):
+            self.logger = PrinterLogger()
+            self.logger.error("Cannot create logger file %s: no permission to write therein" % logger_filename)
+        else:
+            self.logger = Logger("nabu", level=self.nabu_config["pipeline"]["verbosity"], logfile=logger_filename)
+
+    def _parse_configuration(self, conf_fname, conf_dict):
+        """
+        Parse the user configuration and builds a dictionary.
+
+        Parameters
+        ----------
+        conf_fname: str
+            Path to the .conf file. Mutually exclusive with 'conf_dict'
+        conf_dict: dict
+            Dictionary with the configuration. Mutually exclusive with 'conf_fname'
+        """
+        if not ((conf_fname is None) ^ (conf_dict is None)):
+            raise ValueError("You must either provide 'conf_fname' or 'conf_dict'")
+        if conf_fname is not None:
+            if not os.path.isfile(conf_fname):
+                raise ValueError("No such file: %s" % conf_fname)
+            self.conf_fname = conf_fname
+            self.conf_dict = parse_nabu_config_file(conf_fname)
+        else:
+            self.conf_dict = conf_dict
+        if self.default_nabu_config is None or self.config_renamed_keys is None:
+            raise ValueError(
+                "'default_nabu_config' and 'config_renamed_keys' must be specified by classes inheriting from ProcessConfig"
+            )
+        self.nabu_config = validate_config(
+            self.conf_dict,
+            self.default_nabu_config,
+            self.config_renamed_keys,
+        )
+
+    def _browse_dataset(self, dataset_info):
+        """
+        Browse a dataset and builds a data structure with the relevant information.
+        """
+        self.logger.debug("Browsing dataset")
+        if dataset_info is not None:
+            self.dataset_info = dataset_info
+        else:
+            extra_options = {
+                "exclude_projections": self.nabu_config["dataset"]["exclude_projections"],
+                "hdf5_entry": self.nabu_config["dataset"]["hdf5_entry"],
+                "nx_version": self.nabu_config["dataset"]["nexus_version"],
+            }
+            self.dataset_info = analyze_dataset(
+                self.nabu_config["dataset"]["location"], extra_options=extra_options, logger=self.logger
+            )
+
+    def _update_dataset_info_with_user_config(self):
+        """
+        Update the 'dataset_info' (DatasetAnalyzer class instance) data structure with options from user configuration.
+        """
+        raise ValueError("Base class")
+
+    def _get_rotation_axis_position(self):
+        self.dataset_info.axis_position = self.nabu_config["reconstruction"]["rotation_axis_position"]
+
+    def _update_rotation_angles(self):
+        raise ValueError("Base class")
+
+    def _dataset_estimations(self):
+        """
+        Perform estimation of several parameters like center of rotation and detector tilt angle.
+        """
+        self.logger.debug("Doing dataset estimations")
+        self._get_tilt()
+        self._get_cor()
+
+    def _get_cor(self):
+        raise ValueError("Base class")
+
+    def _get_tilt(self):
+        tilt = self.nabu_config["preproc"]["tilt_correction"]
+        user_rot_projs = self.nabu_config["preproc"]["rotate_projections"]
+        if user_rot_projs is not None and tilt is not None:
+            msg = "=" * 80 + "\n"
+            msg += (
+                "Both 'detector_tilt' and 'rotate_projections' options were provided. The option 'rotate_projections' will take precedence. This means that the projections will be rotated by %f degrees and the option 'detector_tilt' will be ignored."
+                % user_rot_projs
+            )
+            msg += "\n" + "=" * 80
+            self.logger.warning(msg)
+            tilt = user_rot_projs
+        #
+        if isinstance(tilt, str):  # auto-tilt
+            self.tilt_estimator = DetectorTiltEstimator(
+                self.dataset_info, logger=self.logger, autotilt_options=self.nabu_config["preproc"]["autotilt_options"]
+            )
+            tilt = self.tilt_estimator.find_tilt(tilt_method=tilt)
+        self.dataset_info.detector_tilt = tilt
+
+    def _coupled_validation(self):
+        """
+        Validate together the dataset information and user configuration.
+        Update 'dataset_info' and 'nabu_config'
+        """
+        raise ValueError("Base class")
+
+    def _build_processing_steps(self):
+        """
+        Build the processing steps, i.e a tuple (steps, options) where
+           - steps is a list of str (list of processing steps names)
+           - options is a dict with processing options
+        """
+        raise ValueError("Base class")
+
+    build_processing_steps = _build_processing_steps  # COMPAT.
+
+    def _configure_save_steps(self):
+        raise ValueError("Base class")
+
+    def _configure_resume(self):
+        raise ValueError("Base class")

build/lib/build/lib/nabu/pipeline/tests/test_chunk_reader.py

@@ -0,0 +1,78 @@
+import numpy as np
+import pytest
+from nabu.io.utils import get_compacted_dataslices
+from nabu.resources.dataset_analyzer import HDF5DatasetAnalyzer
+from nabu.testutils import compare_arrays, __do_long_tests__, get_file
+from nabu.io.reader import ChunkReader
+
+
+@pytest.fixture(scope="class")
+def bootstrap(request):
+    cls = request.cls
+
+    cls.dataset_fname = get_file("bamboo_reduced.nx")
+    cls.tol = 1e-7
+
+
+def get_compacted_dataslices_as_sorted_tuples(reader):
+    slice_to_tuple = lambda s: (s.start, s.stop, s.step)
+    data_slices_tuples = list(
+        set(
+            [
+                slice_to_tuple(u.data_slice())
+                for u in get_compacted_dataslices(
+                    reader.files, subsampling=reader.dataset_subsampling, begin=reader._files_begin_idx
+                ).values()
+            ]
+        )
+    )
+    return sorted(data_slices_tuples, key=lambda t: t[0])
+
+
+@pytest.mark.skipif(not (__do_long_tests__), reason="Use __do_long_tests__ for this test")
+@pytest.mark.usefixtures("bootstrap")
+class TestChunkReader:
+    def test_subsampling(self):
+        """
+        Test reading data from even/odd projections
+        """
+        dataset_info = HDF5DatasetAnalyzer(self.dataset_fname)
+
+        # Read all projections, then only even-numbered ones, then odd-numbered ones
+        # Use the same object to hopefully use less memory (through garbage collection)
+        reader = ChunkReader(dataset_info.projections, dataset_subsampling=None)
+        reader.load_data()
+        first_sino_all = reader.data[:, 0, :].copy()
+        compacted_dataslices_all = get_compacted_dataslices_as_sorted_tuples(reader)
+
+        reader = ChunkReader(dataset_info.projections, dataset_subsampling=(2, 0))
+        reader.load_data()
+        first_sino_even = reader.data[:, 0, :].copy()
+        compacted_dataslices_even = get_compacted_dataslices_as_sorted_tuples(reader)
+
+        reader = ChunkReader(dataset_info.projections, dataset_subsampling=(2, 1))
+        reader.load_data()
+        first_sino_odd = reader.data[:, 0, :].copy()
+        compacted_dataslices_odd = get_compacted_dataslices_as_sorted_tuples(reader)
+
+        # from spire.utils import ims
+        # ims([first_sino_all[::2], first_sino_even, first_sino_all[::2]*1. - first_sino_even])
+        # ims([first_sino_all[::2], first_sino_even, first_sino_all[1::2]*1. - first_sino_odd])
+
+        # Check that the compacted data slices are correct
+        assert len(compacted_dataslices_all) == len(compacted_dataslices_even) == len(compacted_dataslices_odd)
+        for data_slice_all, data_slice_even, data_slice_odd in zip(
+            compacted_dataslices_all, compacted_dataslices_even, compacted_dataslices_odd
+        ):
+            indices_all = np.arange(100000)[slice(*data_slice_all)]
+            indices_even = np.arange(100000)[slice(*data_slice_even)]
+            indices_odd = np.arange(100000)[slice(*data_slice_odd)]
+            assert indices_all[::2].size == indices_even.size
+            assert np.allclose(indices_all[::2], indices_even)
+            assert indices_all[1::2].size == indices_odd.size
+            assert np.allclose(indices_all[1::2], indices_odd)
+
+        is_close, max_err = compare_arrays(first_sino_all[::2, :], first_sino_even, self.tol, return_residual=True)
+        assert is_close, "ChunkReader: something wrong when subsampling for even projections. max_err=%.3e" % max_err
+        is_close, max_err = compare_arrays(first_sino_all[1::2, :], first_sino_odd, self.tol, return_residual=True)
+        assert is_close, "ChunkReader: something wrong when subsampling for odd projections. max_err=%.3e" % max_err

build/lib/build/lib/nabu/pipeline/tests/test_estimators.py

@@ -0,0 +1,149 @@
+import os
+import pytest
+import numpy as np
+from nabu.testutils import utilstest, __do_long_tests__
+from nabu.resources.dataset_analyzer import HDF5DatasetAnalyzer
+from nabu.resources.dataset_analyzer import analyze_dataset
+from nabu.resources.utils import extract_parameters
+from nabu.pipeline.estimators import CompositeCOREstimator
+from nabu.pipeline.config import parse_nabu_config_file
+from nabu.pipeline.estimators import SinoCORFinder, CORFinder
+
+
+#
+# Test CoR estimation with "composite-coarse-to-fine" (aka "near" in the legacy system vocable)
+#
+
+
+@pytest.fixture(scope="class")
+def bootstrap(request):
+    cls = request.cls
+
+    dataset_downloaded_path = utilstest.getfile("test_composite_cor_finder_data.h5")
+    cls.theta_interval = 4.5 * 1  # this is given. Radios in the middle of steps 4.5 degree long
+    # are set to zero for compression
+    # You can still change it to a multiple of 4.5
+    cls.cor_pix = 1321.625
+    cls.abs_tol = 0.0001
+    cls.dataset_info = HDF5DatasetAnalyzer(dataset_downloaded_path)
+    cls.cor_options = extract_parameters("""side="near"; near_pos = 300.0;  near_width = 20.0 """, sep=";")
+
+
+@pytest.mark.skipif(not (__do_long_tests__), reason="Need NABU_LONG_TESTS=1 for this test")
+@pytest.mark.usefixtures("bootstrap")
+class TestCompositeCorFinder:
+    def test(self):
+        cor_finder = CompositeCOREstimator(
+            self.dataset_info, theta_interval=self.theta_interval, cor_options=self.cor_options
+        )
+
+        cor_position = cor_finder.find_cor()
+        message = "Computed CoR %f " % cor_position + " and real CoR %f do not coincide" % self.cor_pix
+        assert np.isclose(self.cor_pix, cor_position, atol=self.abs_tol), message
+
+
+@pytest.fixture(scope="class")
+def bootstrap_bamboo_reduced(request):
+    cls = request.cls
+    cls.abs_tol = 0.2
+    # Dataset without estimated_cor_frm_motor (non regression test)
+    dataset_relpath = os.path.join("bamboo_reduced.nx")
+    dataset_downloaded_path = utilstest.getfile(dataset_relpath)
+    conf_relpath = os.path.join("bamboo_reduced.conf")
+    conf_downloaded_path = utilstest.getfile(conf_relpath)
+    cls.ds_std = analyze_dataset(dataset_downloaded_path)
+    cls.conf_std = parse_nabu_config_file(conf_downloaded_path)
+
+    # Dataset with estimated_cor_frm_motor
+    dataset_relpath = os.path.join("bamboo_reduced_bliss.nx")
+    dataset_downloaded_path = utilstest.getfile(dataset_relpath)
+    conf_relpath = os.path.join("bamboo_reduced_bliss.conf")
+    conf_downloaded_path = utilstest.getfile(conf_relpath)
+    cls.ds_bliss = analyze_dataset(dataset_downloaded_path)
+    cls.conf_bliss = parse_nabu_config_file(conf_downloaded_path)
+
+
+@pytest.mark.skipif(not (__do_long_tests__), reason="need environment variable NABU_LONG_TESTS=1")
+@pytest.mark.usefixtures("bootstrap_bamboo_reduced")
+class TestCorNearPos:
+    true_cor = 339.486
+
+    def test_cor_sliding_standard(self):
+        cor_options = extract_parameters(self.conf_std["reconstruction"].get("cor_options", None), sep=";")
+        finder = CORFinder("sliding-window", self.ds_std, do_flatfield=True, cor_options=cor_options)
+        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, cor, atol=self.abs_tol), message
+
+        cor_options.update({"side": "from_file"})
+        finder = CORFinder("sliding-window", self.ds_std, do_flatfield=True, cor_options=cor_options)
+        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, cor, atol=self.abs_tol), message
+
+        cor_options.update({"side": "center"})
+        finder = CORFinder("sliding-window", self.ds_std, do_flatfield=True, cor_options=cor_options)
+        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, cor, atol=self.abs_tol), message
+
+    def test_cor_fourier_angles_standard(self):
+        cor_options = extract_parameters(self.conf_std["reconstruction"].get("cor_options", None), sep=";")
+        finder = SinoCORFinder("fourier-angles", self.ds_std, do_flatfield=True, cor_options=cor_options)
+        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, cor, atol=self.abs_tol), message
+
+        # Checks that it works though no data in NX
+        cor_options.update({"side": "from_file"})
+        finder = SinoCORFinder("fourier-angles", self.ds_std, do_flatfield=True, cor_options=cor_options)
+        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, cor, atol=self.abs_tol), message
+
+        cor_options.update({"side": "center"})
+        finder = SinoCORFinder("fourier-angles", self.ds_std, do_flatfield=True, cor_options=cor_options)
+        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, cor, atol=self.abs_tol), message
+
+    def test_cor_sliding_bliss(self):
+        cor_options = extract_parameters(self.conf_bliss["reconstruction"].get("cor_options", None), sep=";")
+        finder = CORFinder("sliding-window", self.ds_bliss, do_flatfield=True, cor_options=cor_options)
+        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)}."
+        print(message)
+        assert np.isclose(self.true_cor, cor, atol=self.abs_tol), message
+
+        cor_options.update({"side": "from_file"})
+        finder = CORFinder("sliding-window", self.ds_bliss, do_flatfield=True, cor_options=cor_options)
+        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)}."
+        print(message)
+        assert np.isclose(self.true_cor, cor, atol=self.abs_tol), message
+
+        cor_options.update({"side": "center"})
+        finder = CORFinder("sliding-window", self.ds_bliss, do_flatfield=True, cor_options=cor_options)
+        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, cor, atol=self.abs_tol), message
+
+    def test_cor_fourier_angles_bliss(self):
+        cor_options = extract_parameters(self.conf_bliss["reconstruction"].get("cor_options", None), sep=";")
+        finder = SinoCORFinder("fourier-angles", self.ds_bliss, do_flatfield=True, cor_options=cor_options)
+        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, cor, atol=self.abs_tol), message
+
+        # Checks that it works though no data in NX
+        cor_options.update({"side": "from_file"})
+        finder = SinoCORFinder("fourier-angles", self.ds_bliss, do_flatfield=True, cor_options=cor_options)
+        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, cor, atol=self.abs_tol), message
+
+        cor_options.update({"side": "center"})
+        finder = SinoCORFinder("fourier-angles", self.ds_bliss, do_flatfield=True, cor_options=cor_options)
+        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, cor, atol=self.abs_tol), message