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

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

@@ -1,163 +0,0 @@
-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

@@ -1,210 +0,0 @@
-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

@@ -1,78 +0,0 @@
-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

@@ -1,149 +0,0 @@
-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