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

build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/nabu/estimation/tests/test_alignment.py

@@ -1,70 +0,0 @@
-import numpy as np
-import pytest
-from nabu.estimation.alignment import AlignmentBase
-
-
-@pytest.fixture(scope="class")
-def bootstrap_base(request):
-    cls = request.cls
-    cls.abs_tol = 2.5e-2
-
-
-@pytest.mark.usefixtures("bootstrap_base")
-class TestAlignmentBase:
-    def test_peak_fitting_2d_3x3(self):
-        # Fit a 3 x 3 grid
-        fy = np.linspace(-1, 1, 3)
-        fx = np.linspace(-1, 1, 3)
-        yy, xx = np.meshgrid(fy, fx, indexing="ij")
-
-        peak_pos_yx = np.random.rand(2) * 1.6 - 0.8
-        f_vals = np.exp(-((yy - peak_pos_yx[0]) ** 2 + (xx - peak_pos_yx[1]) ** 2) / 100)
-
-        fitted_peak_pos_yx = AlignmentBase.refine_max_position_2d(f_vals, fy, fx)
-
-        message = (
-            "Computed peak position: (%f, %f) " % (*fitted_peak_pos_yx,)
-            + " and real peak position (%f, %f) do not coincide." % (*peak_pos_yx,)
-            + " Difference: (%f, %f)," % (*(fitted_peak_pos_yx - peak_pos_yx),)
-            + " tolerance: %f" % self.abs_tol
-        )
-        assert np.all(np.isclose(peak_pos_yx, fitted_peak_pos_yx, atol=self.abs_tol)), message
-
-    def test_peak_fitting_2d_error_checking(self):
-        # Fit a 3 x 3 grid
-        fy = np.linspace(-1, 1, 3)
-        fx = np.linspace(-1, 1, 3)
-        yy, xx = np.meshgrid(fy, fx, indexing="ij")
-
-        peak_pos_yx = np.random.rand(2) + 1.5
-        f_vals = np.exp(-((yy - peak_pos_yx[0]) ** 2 + (xx - peak_pos_yx[1]) ** 2) / 100)
-
-        with pytest.raises(ValueError) as ex:
-            AlignmentBase.refine_max_position_2d(f_vals, fy, fx)
-
-        message = (
-            "Error should have been raised about the peak being fitted outside margins, "
-            + "other error raised instead:\n%s" % str(ex.value)
-        )
-        assert "positions are outside the input margins" in str(ex.value), message
-
-    def test_extract_peak_regions_1d(self):
-        img = np.random.randint(0, 10, size=(8, 8))
-
-        peaks_pos = np.argmax(img, axis=-1)
-        peaks_val = np.max(img, axis=-1)
-
-        cc_coords = np.arange(0, 8)
-
-        (
-            found_peaks_val,
-            found_peaks_pos,
-        ) = AlignmentBase.extract_peak_regions_1d(img, axis=-1, cc_coords=cc_coords)
-        message = (
-            "The found peak positions do not correspond to the expected peak positions:\n  Expected: %s\n  Found: %s"
-            % (
-                peaks_pos,
-                found_peaks_pos[1, :],
-            )
-        )
-        assert np.all(peaks_val == found_peaks_val[1, :]), message

build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/nabu/estimation/tests/test_cor.py

@@ -1,472 +0,0 @@
-import os
-import numpy as np
-import pytest
-import scipy.ndimage
-import h5py
-from nabu.testutils import utilstest, __do_long_tests__
-from nabu.testutils import get_data as nabu_get_data
-
-from nabu.estimation.cor import (
-    CenterOfRotation,
-    CenterOfRotationAdaptiveSearch,
-    CenterOfRotationGrowingWindow,
-    CenterOfRotationSlidingWindow,
-    CenterOfRotationFourierAngles,
-    CenterOfRotationOctaveAccurate,
-)
-from nabu.estimation.cor_sino import SinoCor
-
-
-@pytest.fixture(scope="class")
-def bootstrap_cor(request):
-    cls = request.cls
-    cls.abs_tol = 0.2
-    cls.data, calib_data = get_cor_data_h5("test_alignment_cor.h5")
-    cls.cor_gl_pix, cls.cor_hl_pix, cls.tilt_deg = calib_data
-
-
-@pytest.fixture(scope="class")
-def bootstrap_cor_win(request):
-    cls = request.cls
-    cls.abs_tol = 0.2
-    cls.data_ha_proj, cls.cor_ha_pr_pix = get_cor_win_proj_data_h5("ha_autocor_radios.npz")
-    cls.data_ha_sino, cls.cor_ha_sn_pix = get_cor_win_sino_data_h5("halftomo_1_sino.npz")
-
-
-@pytest.fixture(scope="class")
-def bootstrap_cor_accurate(request):
-    cls = request.cls
-    cls.abs_tol = 0.2
-    cls.image_pair_stylo, cls.cor_pos_abs_stylo = get_cor_win_proj_data_h5("stylo_accurate.npz")
-    cls.image_pair_blc12781, cls.cor_pos_abs_blc12781 = get_cor_win_proj_data_h5("blc12781_accurate.npz")
-
-
-@pytest.fixture(scope="class")
-def bootstrap_cor_fourier(request):
-    cls = request.cls
-    cls.abs_tol = 0.2
-    dataset_relpath = os.path.join("sino_bamboo_hercules_for_test.npz")
-    dataset_downloaded_path = utilstest.getfile(dataset_relpath)
-    a = np.load(dataset_downloaded_path)
-    cls.sinos = a["sinos"]
-    cls.angles = a["angles"]
-    cls.true_cor = a["true_cor"]
-    cls.estimated_cor_from_motor = a["estimated_cor_from_motor"]
-
-
-def get_cor_data_h5(*dataset_path):
-    """
-    Get a dataset file from silx.org/pub/nabu/data
-    dataset_args is a list describing a nested folder structures, ex.
-    ["path", "to", "my", "dataset.h5"]
-    """
-    dataset_relpath = os.path.join(*dataset_path)
-    dataset_downloaded_path = utilstest.getfile(dataset_relpath)
-    with h5py.File(dataset_downloaded_path, "r") as hf:
-        data = hf["/entry/instrument/detector/data"][()]
-
-        cor_global_pix = hf["/calibration/alignment/global/x_rotation_axis_pixel_position"][()]
-
-        cor_highlow_pix = hf["/calibration/alignment/highlow/x_rotation_axis_pixel_position"][()]
-        tilt_deg = hf["/calibration/alignment/highlow/z_camera_tilt"][()]
-
-    return data, (cor_global_pix, cor_highlow_pix, tilt_deg)
-
-
-def get_cor_win_proj_data_h5(*dataset_path):
-    """
-    Get a dataset file from silx.org/pub/nabu/data
-    dataset_args is a list describing a nested folder structures, ex.
-    ["path", "to", "my", "dataset.h5"]
-    """
-    dataset_relpath = os.path.join(*dataset_path)
-    dataset_downloaded_path = utilstest.getfile(dataset_relpath)
-    data = np.load(dataset_downloaded_path)
-    radios = np.stack((data["radio1"], data["radio2"]), axis=0)
-
-    return radios, data["cor_pos"]
-
-
-def get_cor_win_sino_data_h5(*dataset_path):
-    """
-    Get a dataset file from silx.org/pub/nabu/data
-    dataset_args is a list describing a nested folder structures, ex.
-    ["path", "to", "my", "dataset.h5"]
-    """
-    dataset_relpath = os.path.join(*dataset_path)
-    dataset_downloaded_path = utilstest.getfile(dataset_relpath)
-    data = np.load(dataset_downloaded_path)
-    sino_shape = data["sino"].shape
-    sinos = np.stack((data["sino"][: sino_shape[0] // 2], data["sino"][sino_shape[0] // 2 :]), axis=0)
-
-    return sinos, data["cor"] - sino_shape[1] / 2
-
-
-@pytest.mark.usefixtures("bootstrap_cor")
-class TestCor:
-    def test_cor_posx(self):
-        radio1 = self.data[0, :, :]
-        radio2 = np.fliplr(self.data[1, :, :])
-
-        CoR_calc = CenterOfRotation()
-        cor_position = CoR_calc.find_shift(radio1, radio2)
-        assert np.isscalar(cor_position), f"cor_position expected to be a scale, {type(cor_position)} returned"
-
-        message = "Computed CoR %f " % cor_position + " and real CoR %f do not coincide" % self.cor_gl_pix
-        assert np.isclose(self.cor_gl_pix, cor_position, atol=self.abs_tol), message
-
-        # testing again with the validity return value
-        cor_position, result_validity = CoR_calc.find_shift(radio1, radio2, return_validity=True)
-        assert np.isscalar(cor_position)
-
-        message = (
-            "returned result_validity is  %s " % result_validity
-            + " while it should be unknown because the validity check is not yet implemented"
-        )
-        assert result_validity == "unknown", message
-
-    def test_noisy_cor_posx(self):
-        radio1 = np.fmax(self.data[0, :, :], 0)
-        radio2 = np.fmax(self.data[1, :, :], 0)
-
-        radio1 = np.random.poisson(radio1 * 400)
-        radio2 = np.random.poisson(np.fliplr(radio2) * 400)
-
-        CoR_calc = CenterOfRotation()
-        cor_position = CoR_calc.find_shift(radio1, radio2, median_filt_shape=(3, 3))
-        assert np.isscalar(cor_position), f"cor_position expected to be a scale, {type(cor_position)} returned"
-
-        message = "Computed CoR %f " % cor_position + " and real CoR %f do not coincide" % self.cor_gl_pix
-        assert np.isscalar(cor_position)
-        assert np.isclose(self.cor_gl_pix, cor_position, atol=self.abs_tol), message
-
-    def test_noisyHF_cor_posx(self):
-        """test with noise at high frequencies"""
-        radio1 = self.data[0, :, :]
-        radio2 = np.fliplr(self.data[1, :, :])
-
-        noise_level = radio1.max() / 16.0
-        noise_ima1 = np.random.normal(0.0, size=radio1.shape) * noise_level
-        noise_ima2 = np.random.normal(0.0, size=radio2.shape) * noise_level
-
-        noise_ima1 = noise_ima1 - scipy.ndimage.gaussian_filter(noise_ima1, 2.0)
-        noise_ima2 = noise_ima2 - scipy.ndimage.gaussian_filter(noise_ima2, 2.0)
-
-        radio1 = radio1 + noise_ima1
-        radio2 = radio2 + noise_ima2
-
-        CoR_calc = CenterOfRotation()
-
-        # cor_position = CoR_calc.find_shift(radio1, radio2)
-        cor_position = CoR_calc.find_shift(radio1, radio2, low_pass=(6.0, 0.3))
-        assert np.isscalar(cor_position), f"cor_position expected to be a scale, {type(cor_position)} returned"
-
-        message = "Computed CoR %f " % cor_position + " and real CoR %f do not coincide" % self.cor_gl_pix
-        assert np.isclose(self.cor_gl_pix, cor_position, atol=self.abs_tol), message
-
-    @pytest.mark.skipif(not (__do_long_tests__), reason="need environment variable NABU_LONG_TESTS=1")
-    def test_half_tomo_cor_exp(self):
-        """test the half_tomo algorithm on experimental data"""
-
-        radios = nabu_get_data("ha_autocor_radios.npz")
-        radio1 = radios["radio1"]
-        radio2 = radios["radio2"]
-        cor_pos = radios["cor_pos"]
-
-        radio2 = np.fliplr(radio2)
-
-        CoR_calc = CenterOfRotationAdaptiveSearch()
-
-        cor_position = CoR_calc.find_shift(radio1, radio2, low_pass=1, high_pass=20, filtered_cost=True)
-        assert np.isscalar(cor_position), f"cor_position expected to be a scale, {type(cor_position)} returned"
-
-        message = (
-            "Computed CoR %f " % cor_position
-            + " and real CoR %f should coincide when using the halftomo algorithm with hald tomo data" % cor_pos
-        )
-        assert np.isclose(cor_pos, cor_position, atol=self.abs_tol), message
-
-    @pytest.mark.skipif(not (__do_long_tests__), reason="need environment variable NABU_LONG_TESTS=1")
-    def test_half_tomo_cor_exp_limited(self):
-        """test the hal_tomo algorithm on experimental data and global search with limits"""
-
-        radios = nabu_get_data("ha_autocor_radios.npz")
-        radio1 = radios["radio1"]
-        radio2 = radios["radio2"]
-        cor_pos = radios["cor_pos"]
-
-        radio2 = np.fliplr(radio2)
-
-        CoR_calc = CenterOfRotationAdaptiveSearch()
-
-        cor_position, result_validity = CoR_calc.find_shift(
-            radio1, radio2, low_pass=1, high_pass=20, margins=(100, 10), filtered_cost=False, return_validity=True
-        )
-        assert np.isscalar(cor_position), f"cor_position expected to be a scale, {type(cor_position)} returned"
-
-        message = (
-            "Computed CoR %f " % cor_position
-            + " and real CoR %f should coincide when using the halftomo algorithm with hald tomo data" % cor_pos
-        )
-        assert np.isclose(cor_pos, cor_position, atol=self.abs_tol), message
-
-        message = "returned result_validity is  %s " % result_validity + " while it should be sound"
-
-        assert result_validity == "sound", message
-
-    def test_cor_posx_linear(self):
-        radio1 = self.data[0, :, :]
-        radio2 = np.fliplr(self.data[1, :, :])
-
-        CoR_calc = CenterOfRotation()
-        cor_position = CoR_calc.find_shift(radio1, radio2, padding_mode="edge")
-        assert np.isscalar(cor_position), f"cor_position expected to be a scale, {type(cor_position)} returned"
-
-        message = "Computed CoR %f " % cor_position + " and real CoR %f do not coincide" % self.cor_gl_pix
-        assert np.isclose(self.cor_gl_pix, cor_position, atol=self.abs_tol), message
-
-    def test_error_checking_001(self):
-        CoR_calc = CenterOfRotation()
-
-        radio1 = self.data[0, :, :1:]
-        radio2 = self.data[1, :, :]
-
-        with pytest.raises(ValueError) as ex:
-            CoR_calc.find_shift(radio1, radio2)
-
-        message = "Error should have been raised about img #1 shape, other error raised instead:\n%s" % str(ex.value)
-        assert "Images need to be 2-dimensional. Shape of image #1" in str(ex.value), message
-
-    def test_error_checking_002(self):
-        CoR_calc = CenterOfRotation()
-
-        radio1 = self.data[0, :, :]
-        radio2 = self.data
-
-        with pytest.raises(ValueError) as ex:
-            CoR_calc.find_shift(radio1, radio2)
-
-        message = "Error should have been raised about img #2 shape, other error raised instead:\n%s" % str(ex.value)
-        assert "Images need to be 2-dimensional. Shape of image #2" in str(ex.value), message
-
-    def test_error_checking_003(self):
-        CoR_calc = CenterOfRotation()
-
-        radio1 = self.data[0, :, :]
-        radio2 = self.data[1, :, 0:10]
-
-        with pytest.raises(ValueError) as ex:
-            CoR_calc.find_shift(radio1, radio2)
-
-        message = (
-            "Error should have been raised about different image shapes, "
-            + "other error raised instead:\n%s" % str(ex.value)
-        )
-        assert "Images need to be of the same shape" in str(ex.value), message
-
-
-@pytest.mark.skipif(not (__do_long_tests__), reason="Need NABU_LONG_TESTS=1 for this test")
-@pytest.mark.usefixtures("bootstrap_cor", "bootstrap_cor_win")
-class TestCorWindowSlide:
-    def test_proj_center_axis_lft(self):
-        radio1 = self.data[0, :, :]
-        radio2 = np.fliplr(self.data[1, :, :])
-
-        CoR_calc = CenterOfRotationSlidingWindow()
-        cor_position = CoR_calc.find_shift(
-            radio1, radio2, side="left", window_width=round(radio1.shape[-1] / 4.0 * 3.0)
-        )
-        assert np.isscalar(cor_position), f"cor_position expected to be a scale, {type(cor_position)} returned"
-
-        message = "Computed CoR %f " % cor_position + " and expected CoR %f do not coincide" % self.cor_gl_pix
-        assert np.isclose(self.cor_gl_pix, cor_position, atol=self.abs_tol), message
-
-        cor_position, result_validity = CoR_calc.find_shift(
-            radio1, radio2, side="left", window_width=round(radio1.shape[-1] / 4.0 * 3.0), return_validity=True
-        )
-
-        message = "returned result_validity is  %s " % result_validity + " while it should be sound"
-
-        assert result_validity == "sound", message
-
-    def test_proj_center_axis_cen(self):
-        radio1 = self.data[0, :, :]
-        radio2 = np.fliplr(self.data[1, :, :])
-
-        CoR_calc = CenterOfRotationSlidingWindow()
-        cor_position = CoR_calc.find_shift(radio1, radio2, side="center")
-        assert np.isscalar(cor_position), f"cor_position expected to be a scale, {type(cor_position)} returned"
-
-        message = "Computed CoR %f " % cor_position + " and expected CoR %f do not coincide" % self.cor_gl_pix
-        assert np.isclose(self.cor_gl_pix, cor_position, atol=self.abs_tol), message
-
-    def test_proj_right_axis_rgt(self):
-        radio1 = self.data_ha_proj[0, :, :]
-        radio2 = np.fliplr(self.data_ha_proj[1, :, :])
-
-        CoR_calc = CenterOfRotationSlidingWindow()
-        cor_position = CoR_calc.find_shift(radio1, radio2, side="right")
-        assert np.isscalar(cor_position), f"cor_position expected to be a scale, {type(cor_position)} returned"
-
-        message = "Computed CoR %f " % cor_position + " and expected CoR %f do not coincide" % self.cor_ha_pr_pix
-        assert np.isclose(self.cor_ha_pr_pix, cor_position, atol=self.abs_tol), message
-
-    def test_proj_left_axis_lft(self):
-        radio1 = np.fliplr(self.data_ha_proj[0, :, :])
-        radio2 = self.data_ha_proj[1, :, :]
-
-        CoR_calc = CenterOfRotationSlidingWindow()
-        cor_position = CoR_calc.find_shift(radio1, radio2, side="left")
-        assert np.isscalar(cor_position), f"cor_position expected to be a scale, {type(cor_position)} returned"
-
-        message = "Computed CoR %f " % cor_position + " and expected CoR %f do not coincide" % -self.cor_ha_pr_pix
-        assert np.isclose(-self.cor_ha_pr_pix, cor_position, atol=self.abs_tol), message
-
-    def test_sino_right_axis_rgt(self):
-        sino1 = self.data_ha_sino[0, :, :]
-        sino2 = np.fliplr(self.data_ha_sino[1, :, :])
-
-        CoR_calc = CenterOfRotationSlidingWindow()
-        cor_position = CoR_calc.find_shift(sino1, sino2, side="right")
-        assert np.isscalar(cor_position), f"cor_position expected to be a scale, {type(cor_position)} returned"
-
-        message = "Computed CoR %f " % cor_position + " and expected CoR %f do not coincide" % self.cor_ha_sn_pix
-        assert np.isclose(self.cor_ha_sn_pix, cor_position, atol=self.abs_tol * 5), message
-
-
-@pytest.mark.skipif(not (__do_long_tests__), reason="need NABU_LONG_TESTS for this test")
-@pytest.mark.usefixtures("bootstrap_cor", "bootstrap_cor_win")
-class TestCorWindowGrow:
-    def test_proj_center_axis_cen(self):
-        radio1 = self.data[0, :, :]
-        radio2 = np.fliplr(self.data[1, :, :])
-
-        CoR_calc = CenterOfRotationGrowingWindow()
-        cor_position = CoR_calc.find_shift(radio1, radio2, side="center")
-        assert np.isscalar(cor_position), f"cor_position expected to be a scale, {type(cor_position)} returned"
-        message = "Computed CoR %f " % cor_position + " and expected CoR %f do not coincide" % self.cor_gl_pix
-        assert np.isclose(self.cor_gl_pix, cor_position, atol=self.abs_tol), message
-
-    def test_proj_right_axis_rgt(self):
-        radio1 = self.data_ha_proj[0, :, :]
-        radio2 = np.fliplr(self.data_ha_proj[1, :, :])
-
-        CoR_calc = CenterOfRotationGrowingWindow()
-        cor_position = CoR_calc.find_shift(radio1, radio2, side="right")
-        assert np.isscalar(cor_position), f"cor_position expected to be a scale, {type(cor_position)} returned"
-
-        message = "Computed CoR %f " % cor_position + " and expected CoR %f do not coincide" % self.cor_ha_pr_pix
-        assert np.isclose(self.cor_ha_pr_pix, cor_position, atol=self.abs_tol), message
-
-    def test_proj_left_axis_lft(self):
-        radio1 = np.fliplr(self.data_ha_proj[0, :, :])
-        radio2 = self.data_ha_proj[1, :, :]
-
-        CoR_calc = CenterOfRotationGrowingWindow()
-        cor_position = CoR_calc.find_shift(radio1, radio2, side="left")
-        assert np.isscalar(cor_position), f"cor_position expected to be a scale, {type(cor_position)} returned"
-
-        message = "Computed CoR %f " % cor_position + " and expected CoR %f do not coincide" % -self.cor_ha_pr_pix
-        assert np.isclose(-self.cor_ha_pr_pix, cor_position, atol=self.abs_tol), message
-
-        cor_position, result_validity = CoR_calc.find_shift(radio1, radio2, side="left", return_validity=True)
-
-        message = "returned result_validity is  %s " % result_validity + " while it should be sound"
-
-        assert result_validity == "sound", message
-
-    def test_proj_right_axis_all(self):
-        radio1 = self.data_ha_proj[0, :, :]
-        radio2 = np.fliplr(self.data_ha_proj[1, :, :])
-
-        CoR_calc = CenterOfRotationGrowingWindow()
-        cor_position = CoR_calc.find_shift(radio1, radio2, side="all")
-        assert np.isscalar(cor_position), f"cor_position expected to be a scale, {type(cor_position)} returned"
-
-        message = "Computed CoR %f " % cor_position + " and expected CoR %f do not coincide" % self.cor_ha_pr_pix
-        assert np.isclose(self.cor_ha_pr_pix, cor_position, atol=self.abs_tol), message
-
-    def test_sino_right_axis_rgt(self):
-        sino1 = self.data_ha_sino[0, :, :]
-        sino2 = np.fliplr(self.data_ha_sino[1, :, :])
-
-        CoR_calc = CenterOfRotationGrowingWindow()
-        cor_position = CoR_calc.find_shift(sino1, sino2, side="right")
-        assert np.isscalar(cor_position), f"cor_position expected to be a scale, {type(cor_position)} returned"
-
-        message = "Computed CoR %f " % cor_position + " and expected CoR %f do not coincide" % self.cor_ha_sn_pix
-        assert np.isclose(self.cor_ha_sn_pix, cor_position, atol=self.abs_tol * 4), message
-
-
-@pytest.mark.usefixtures("bootstrap_cor_win")
-class TestCoarseToFineSinoCor:
-    def test_coarse_to_fine(self):
-        """
-        Test nabu.estimation.cor_sino.SinoCor
-        """
-        sino_halftomo = np.vstack([self.data_ha_sino[0], self.data_ha_sino[1]])
-        sino_cor = SinoCor(self.data_ha_sino[0], np.fliplr(self.data_ha_sino[1]))
-        cor_coarse = sino_cor.estimate_cor_coarse()
-        assert np.isscalar(cor_coarse), f"cor_position expected to be a scalar, {type(cor_coarse)} returned"
-        cor_fine = sino_cor.estimate_cor_fine()
-        assert np.isscalar(cor_fine), f"cor_position expected to be a scale, {type(cor_fine)} returned"
-
-        cor_ref = self.cor_ha_sn_pix + sino_halftomo.shape[-1] / 2.0
-        message = "Computed CoR %f " % cor_fine + " and expected CoR %f do not coincide" % cor_ref
-        assert abs(cor_fine - cor_ref) < self.abs_tol * 2, message
-
-
-@pytest.mark.usefixtures("bootstrap_cor_accurate")
-class TestCorOctaveAccurate:
-    def test_cor_accurate_positive_shift(self):
-        detector_width = self.image_pair_stylo[0].shape[1]
-        CoR_calc = CenterOfRotationOctaveAccurate()
-        cor_position = CoR_calc.find_shift(self.image_pair_stylo[0], np.fliplr(self.image_pair_stylo[1]), "center")
-        cor_position = cor_position + detector_width / 2
-        assert np.isscalar(cor_position), f"cor_position expected to be a scalar, {type(cor_position)} returned"
-        message = f"Computed CoR {cor_position} and expected CoR {self.cor_pos_abs_stylo} do not coincide."
-        assert np.isclose(self.cor_pos_abs_stylo, cor_position, atol=self.abs_tol), message
-
-    def test_cor_accurate_negative_shift(self):
-        detector_width = self.image_pair_blc12781[0].shape[1]
-        CoR_calc = CenterOfRotationOctaveAccurate()
-        cor_position = CoR_calc.find_shift(
-            self.image_pair_blc12781[0], np.fliplr(self.image_pair_blc12781[1]), "center"
-        )
-        cor_position = cor_position + detector_width / 2
-        assert np.isscalar(cor_position), f"cor_position expected to be a scalar, {type(cor_position)} returned"
-        message = f"Computed CoR {cor_position} and expected CoR {self.cor_pos_abs_blc12781} do not coincide."
-        assert np.isclose(self.cor_pos_abs_blc12781, cor_position, atol=self.abs_tol), message
-
-
-@pytest.mark.usefixtures("bootstrap_cor_fourier", "bootstrap_cor_win")
-class TestCorFourierAngle:
-    def test_sino_right_axis_with_near_pos(self):
-        sino1 = self.data_ha_sino[0, :, :]
-        sino2 = np.fliplr(self.data_ha_sino[1, :, :])
-        start_angle = np.pi / 4
-        angles = np.linspace(start_angle, start_angle + 2 * np.pi, 2 * sino1.shape[0])
-
-        cor_options = {"side": 740, "refine": True}
-
-        CoR_calc = CenterOfRotationFourierAngles(cor_options=cor_options)
-        cor_position = CoR_calc.find_shift(sino1, sino2, angles, side="right")
-        assert np.isscalar(cor_position), f"cor_position expected to be a scale, {type(cor_position)} returned"
-
-        message = "Computed CoR %f " % cor_position + " and expected CoR %f do not coincide" % self.cor_ha_sn_pix
-        assert np.isclose(self.cor_ha_sn_pix, cor_position, atol=self.abs_tol * 3), message
-
-    def test_sino_right_axis_with_ignore(self):
-        sino1 = self.data_ha_sino[0, :, :]
-        sino2 = np.fliplr(self.data_ha_sino[1, :, :])
-        start_angle = np.pi / 4
-        angles = np.linspace(start_angle, start_angle + 2 * np.pi, 2 * sino1.shape[0])
-
-        cor_options = {"side": "ignore", "refine": True}
-
-        CoR_calc = CenterOfRotationFourierAngles(cor_options=cor_options)
-        cor_position = CoR_calc.find_shift(sino1, sino2, angles, side="right")
-        assert np.isscalar(cor_position), f"cor_position expected to be a scale, {type(cor_position)} returned"
-
-        message = "Computed CoR %f " % cor_position + " and expected CoR %f do not coincide" % self.cor_ha_sn_pix
-        assert np.isclose(self.cor_ha_sn_pix, cor_position, atol=self.abs_tol * 3), message

build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/nabu/estimation/tests/test_focus.py

@@ -1,105 +0,0 @@
-import os
-import numpy as np
-import pytest
-import h5py
-from nabu.testutils import utilstest, __do_long_tests__
-from nabu.estimation.focus import CameraFocus
-
-
-@pytest.fixture(scope="class")
-def bootstrap_fcs(request):
-    cls = request.cls
-    cls.abs_tol_dist = 1e-2
-    cls.abs_tol_tilt = 2.5e-4
-
-    (
-        cls.data,
-        cls.img_pos,
-        cls.pixel_size,
-        (calib_data_std, calib_data_angle),
-    ) = get_focus_data("test_alignment_focus.h5")
-    (
-        cls.angle_best_ind,
-        cls.angle_best_pos,
-        cls.angle_tilt_v,
-        cls.angle_tilt_h,
-    ) = calib_data_angle
-    cls.std_best_ind, cls.std_best_pos = calib_data_std
-
-
-def get_focus_data(*dataset_path):
-    """
-    Get a dataset file from silx.org/pub/nabu/data
-    dataset_args is a list describing a nested folder structures, ex.
-    ["path", "to", "my", "dataset.h5"]
-    """
-    dataset_relpath = os.path.join(*dataset_path)
-    dataset_downloaded_path = utilstest.getfile(dataset_relpath)
-    with h5py.File(dataset_downloaded_path, "r") as hf:
-        data = hf["/entry/instrument/detector/data"][()]
-        img_pos = hf["/entry/instrument/detector/distance"][()]
-
-        pixel_size = np.mean(
-            [
-                hf["/entry/instrument/detector/x_pixel_size"][()],
-                hf["/entry/instrument/detector/y_pixel_size"][()],
-            ]
-        )
-
-        angle_best_ind = hf["/calibration/focus/angle/best_img"][()]
-        angle_best_pos = hf["/calibration/focus/angle/best_pos"][()]
-        angle_tilt_v = hf["/calibration/focus/angle/tilt_v_rad"][()]
-        angle_tilt_h = hf["/calibration/focus/angle/tilt_h_rad"][()]
-
-        std_best_ind = hf["/calibration/focus/std/best_img"][()]
-        std_best_pos = hf["/calibration/focus/std/best_pos"][()]
-
-    calib_data_angle = (angle_best_ind, angle_best_pos, angle_tilt_v, angle_tilt_h)
-    calib_data_std = (std_best_ind, std_best_pos)
-    return data, img_pos, pixel_size, (calib_data_std, calib_data_angle)
-
-
-@pytest.mark.skipif(not (__do_long_tests__), reason="need environment variable NABU_LONG_TESTS=1")
-@pytest.mark.usefixtures("bootstrap_fcs")
-class TestFocus:
-    def test_find_distance(self):
-        focus_calc = CameraFocus()
-        focus_pos, focus_ind = focus_calc.find_distance(self.data, self.img_pos)
-
-        message = (
-            "Computed focus motor position %f " % focus_pos + " and expected %f do not coincide" % self.std_best_pos
-        )
-        assert np.isclose(self.std_best_pos, focus_pos, atol=self.abs_tol_dist), message
-
-        message = "Computed focus image index %f " % focus_ind + " and expected %f do not coincide" % self.std_best_ind
-        assert np.isclose(self.std_best_ind, focus_ind, atol=self.abs_tol_dist), message
-
-    def test_find_scintillator_tilt(self):
-        focus_calc = CameraFocus()
-        focus_pos, focus_ind, tilts_vh = focus_calc.find_scintillator_tilt(self.data, self.img_pos)
-
-        message = (
-            "Computed focus motor position %f " % focus_pos + " and expected %f do not coincide" % self.angle_best_pos
-        )
-        assert np.isclose(self.angle_best_pos, focus_pos, atol=self.abs_tol_dist), message
-
-        message = (
-            "Computed focus image index %f " % focus_ind + " and expected %f do not coincide" % self.angle_best_ind
-        )
-        assert np.isclose(self.angle_best_ind, focus_ind, atol=self.abs_tol_dist), message
-
-        expected_tilts_vh = np.squeeze(np.array([self.angle_tilt_v, self.angle_tilt_h]))
-        computed_tilts_vh = -tilts_vh / (self.pixel_size / 1000)
-        message = "Computed tilts %s and expected %s do not coincide" % (
-            computed_tilts_vh,
-            expected_tilts_vh,
-        )
-        assert np.all(np.isclose(computed_tilts_vh, expected_tilts_vh, atol=self.abs_tol_tilt)), message
-
-    def test_size_determination(self):
-        inp_shape = [2162, 2560]
-        exp_shape = np.array([2160, 2160])
-        new_shape = CameraFocus()._check_img_block_size(inp_shape, 4, suggest_new_shape=True)
-
-        message = "New suggested shape: %s and expected: %s do not coincide" % (new_shape, exp_shape)
-        assert np.all(new_shape == exp_shape), message