nabu 2024.1.10__py3-none-any.whl → 2024.2.0__py3-none-any.whl

nabu/estimation/cor.py

@@ -1,10 +1,9 @@
 import math
 import numpy as np
-from scipy.fftpack import rfft
-from numbers import Real
+from ..utils import deprecated_class, deprecation_warning, is_scalar
 from ..misc import fourier_filters
 from .alignment import AlignmentBase, plt, progress_bar, local_fftn, local_ifftn
-from ..resources.utils import extract_parameters
+
 
 # three possible  values for the validity check, which can optionally be returned by the find_shifts methods
 cor_result_validity = {
@@ -16,10 +15,12 @@ cor_result_validity = {
 
 
 class CenterOfRotation(AlignmentBase):
+
     def find_shift(
         self,
         img_1: np.ndarray,
         img_2: np.ndarray,
+        side=None,
         shift_axis: int = -1,
         roi_yxhw=None,
         median_filt_shape=None,
@@ -28,7 +29,7 @@ class CenterOfRotation(AlignmentBase):
         high_pass=None,
         low_pass=None,
         return_validity=False,
-        cor_options=None,
+        return_relative_to_middle=None,
     ):
         """Find the Center of Rotation (CoR), given two images.
 
@@ -108,6 +109,15 @@ class CenterOfRotation(AlignmentBase):
 
         >>> cor_position = CoR_calc.find_shift(radio1, radio2, median_filt_shape=(3, 3))
         """
+        # COMPAT.
+        if return_relative_to_middle is None:
+            deprecation_warning(
+                "The current default behavior is to return the shift relative the the middle of the image. In a future release, this function will return the shift relative to the left-most pixel. To keep the current behavior, please use 'return_relative_to_middle=True'.",
+                do_print=True,
+                func_name="CenterOfRotation.find_shift",
+            )
+            return_relative_to_middle = True  # the kwarg above will be False by default in a future release
+        # ---
 
         self._check_img_pair_sizes(img_1, img_2)
 
@@ -131,17 +141,20 @@ class CenterOfRotation(AlignmentBase):
 
         estimated_cor = fitted_shifts_vh[shift_axis] / 2.0
 
-        if isinstance(self.cor_options.get("near_pos", None), (int, float)):
-            near_pos = self.cor_options["near_pos"]
+        if is_scalar(side):
+            near_pos = side - (img_1.shape[-1] - 1) / 2
             if (
                 np.abs(near_pos - estimated_cor) / near_pos > 0.2
-            ):  # For comparison, near_pos is RELATIVE (as estimated_cor is).
+            ):  # For comparison, near_pos is RELATIVE to the middle of image (as estimated_cor is).
                 validity_check_result = cor_result_validity["questionable"]
             else:
                 validity_check_result = cor_result_validity["sound"]
         else:
             validity_check_result = cor_result_validity["unknown"]
 
+        if not (return_relative_to_middle):
+            estimated_cor += (img_1.shape[-1] - 1) / 2
+
         if return_validity:
             return estimated_cor, validity_check_result
         else:
@@ -153,16 +166,15 @@ class CenterOfRotationSlidingWindow(CenterOfRotation):
         self,
         img_1: np.ndarray,
         img_2: np.ndarray,
-        side,
+        side="center",
         window_width=None,
         roi_yxhw=None,
         median_filt_shape=None,
-        padding_mode=None,
         peak_fit_radius=1,
         high_pass=None,
         low_pass=None,
         return_validity=False,
-        cor_options=None,
+        return_relative_to_middle=None,
     ):
         """Semi-automatically find the Center of Rotation (CoR), given two images
         or sinograms. Suitable for half-aquisition scan.
@@ -170,86 +182,28 @@ class CenterOfRotationSlidingWindow(CenterOfRotation):
         This method finds the half-shift between two opposite images,  by
         minimizing difference over a moving window.
 
-        The output of this function, allows to compute motor movements for
-        aligning the sample rotation axis. Given the following values:
-
-        - L1: distance from source to motor
-        - L2: distance from source to detector
-        - ps: physical pixel size
-        - v: output of this function
-
-        displacement of motor = (L1 / L2 * ps) * v
+        Parameters and usage is the same as CenterOfRotation, except for the following two parameters.
 
         Parameters
         ----------
-        img_1: numpy.ndarray
-            First image
-        img_2: numpy.ndarray
-            Second image, it needs to have been flipped already (e.g. using numpy.fliplr).
-        side: string
-            Expected region of the CoR. Allowed values: 'left', 'center' or 'right'.
+        side: string or float, optional
+            Expected region of the CoR. Allowed values: 'left', 'center' or 'right'. Default is 'center'
         window_width: int, optional
-            Width of window that will slide on the other image / part of the
-            sinogram. Default is None.
-        roi_yxhw: (2, ) or (4, ) numpy.ndarray, tuple, or array, optional
-            4 elements vector containing: vertical and horizontal coordinates
-            of first pixel, plus height and width of the Region of Interest (RoI).
-            Or a 2 elements vector containing: plus height and width of the
-            centered Region of Interest (RoI).
-            Default is None -> deactivated.
-        median_filt_shape: (2, ) numpy.ndarray, tuple, or array, optional
-            Shape of the median filter window. Default is None -> deactivated.
-        padding_mode: str in numpy.pad's mode list, optional
-            Padding mode, which determines the type of convolution. If None or
-            'wrap' are passed, this resorts to the traditional circular convolution.
-            If 'edge' or 'constant' are passed, it results in a linear convolution.
-            Default is the circular convolution.
-            All options are:
-                None | 'constant' | 'edge' | 'linear_ramp' | 'maximum' | 'mean'
-                | 'median' | 'minimum' | 'reflect' | 'symmetric' |'wrap'
-        peak_fit_radius: int, optional
-            Radius size around the max correlation pixel, for sub-pixel fitting.
-            Minimum and default value is 1.
-        low_pass: float or sequence of two floats
-            Low-pass filter properties, as described in `nabu.misc.fourier_filters`
-        high_pass: float or sequence of two floats
-            High-pass filter properties, as described in `nabu.misc.fourier_filters`
-        return_validity: a boolean, defaults to false
-            if set to True adds a second return value which may have three string values.
-            These values are "unknown", "sound", "questionable".
-            It will be "uknown" if the  validation method is not implemented
-            and it will be "sound" or "questionable" if it is implemented.
-
-        Raises
-        ------
-        ValueError
-            In case images are not 2-dimensional or have different sizes.
-
-        Returns
-        -------
-        float
-            Estimated center of rotation position from the center of the RoI in pixels.
-
-        Examples
-        --------
-        The following code computes the center of rotation position for two
-        given images in a tomography scan, where the second image is taken at
-        180 degrees from the first.
-
-        >>> radio1 = data[0, :, :]
-        ... radio2 = np.fliplr(data[1, :, :])
-        ... CoR_calc = CenterOfRotationSlidingWindow()
-        ... cor_position = CoR_calc.find_shift(radio1, radio2)
-
-        Or for noisy images:
-
-        >>> cor_position = CoR_calc.find_shift(radio1, radio2, median_filt_shape=(3, 3))
+            Width of window that will slide on the other image / part of the sinogram. Default is None.
         """
-
+        # COMPAT.
+        if return_relative_to_middle is None:
+            deprecation_warning(
+                "The current default behavior is to return the shift relative the the middle of the image. In a future release, this function will return the shift relative to the left-most pixel. To keep the current behavior, please use 'return_relative_to_middle=True'.",
+                do_print=True,
+                func_name="CenterOfRotationSlidingWindow.find_shift",
+            )
+            return_relative_to_middle = True  # the kwarg above will be False by default in a future release
+        # ---
         validity_check_result = cor_result_validity["unknown"]
 
         if side is None:
-            raise ValueError("Side should be one of 'left', 'right', or 'center'. 'None' was given instead")
+            raise ValueError("Side should be one of 'left', 'right', 'center' or a scalar. 'None' was given instead")
 
         self._check_img_pair_sizes(img_1, img_2)
 
@@ -267,42 +221,36 @@ class CenterOfRotationSlidingWindow(CenterOfRotation):
             img_2, roi_yxhw=roi_yxhw, median_filt_shape=median_filt_shape, high_pass=high_pass, low_pass=low_pass
         )
         img_shape = img_2.shape
+        img_width = img_shape[-1]
 
-        near_pos = self.cor_options.get("near_pos", None)
-        if near_pos is None:
+        if isinstance(side, str):
             if window_width is None:
-                if side.lower() == "center":
-                    window_width = round(img_shape[-1] / 4.0 * 3.0)
+                if side == "center":
+                    window_width = round(img_width / 4.0 * 3.0)
                 else:
-                    window_width = round(img_shape[-1] / 10)
+                    window_width = round(img_width / 10)
             window_shift = window_width // 2
             window_width = window_shift * 2 + 1
-
-            win_1_start_seed = 0
-            # number of pixels where the window will "slide".
-            n = img_shape[-1] - window_width
+            if side == "right":
+                win_2_start = 0
+            elif side == "left":
+                win_2_start = img_width - window_width
+            else:
+                win_2_start = img_width // 2 - window_shift
         else:
-            abs_pos = near_pos + img_shape[-1] // 2
-            offset = min(img_shape[-1] - abs_pos, abs_pos)  # distance to closest edge.
+            abs_pos = int(side + img_width // 2)
+            window_fraction = 0.1  # Hard-coded ?
 
-            window_fraction = 0.4  # Hard-coded ?
-            window_shift = int(np.floor(offset * window_fraction))
-            window_width = 2 * window_shift + 1
+            window_width = round(window_fraction * img_width)
+            window_shift = window_width // 2
+            window_width = window_shift * 2 + 1
 
-            sliding_shift = int(np.floor(offset * (1 - window_fraction))) - 1
-            n = 2 * sliding_shift + 1
-            win_1_start_seed = 2 * near_pos - sliding_shift
+            win_2_start = np.clip(abs_pos - window_shift, 0, img_width // 2 - 1)
+            win_2_start = img_width // 2 - 1 - win_2_start
 
-        if side.lower() == "right":
-            win_2_start = 0
-        elif side.lower() == "left":
-            win_2_start = img_shape[-1] - window_width
-        elif side.lower() == "center":
-            win_2_start = img_shape[-1] // 2 - window_shift
-        else:
-            raise ValueError(
-                "Side should be one of 'left', 'right', or 'center'. '%s' was given instead" % side.lower()
-            )
+        win_1_start_seed = 0
+        # number of pixels where the window will "slide".
+        n = img_width - window_width
 
         win_2_end = win_2_start + window_width
 
@@ -334,14 +282,14 @@ class CenterOfRotationSlidingWindow(CenterOfRotation):
         win_pos_max, win_val_max = self.refine_max_position_1d(f_vals, return_vertex_val=True)
 
         # Derive the COR
-        if isinstance(near_pos, Real):
+        if is_scalar(side):
             cor_h = -(win_2_start - (win_1_start_seed + win_ind_max + win_pos_max)) / 2.0
             cor_pos = -(win_2_start - (win_1_start_seed + np.arange(n))) / 2.0
         else:
             cor_h = -(win_2_start - (win_ind_max + win_pos_max)) / 2.0
             cor_pos = -(win_2_start - np.arange(n)) / 2.0
 
-        if (side.lower() == "right" and win_ind_max == 0) or (side.lower() == "left" and win_ind_max == n):
+        if (side == "right" and win_ind_max == 0) or (side == "left" and win_ind_max == n):
             self.logger.warning("Sliding window width %d might be too large!" % window_width)
 
         if self.verbose:
@@ -357,6 +305,9 @@ class CenterOfRotationSlidingWindow(CenterOfRotation):
             plt.legend()
             plt.show(block=False)
 
+        if not (return_relative_to_middle):
+            cor_h += (img_width - 1) / 2.0
+
         if return_validity:
             return cor_h, validity_check_result
         else:
@@ -377,6 +328,7 @@ class CenterOfRotationGrowingWindow(CenterOfRotation):
         high_pass=None,
         low_pass=None,
         return_validity=False,
+        return_relative_to_middle=None,
     ):
         """Automatically find the Center of Rotation (CoR), given two images or
         sinograms. Suitable for half-aquisition scan.
@@ -384,85 +336,23 @@ class CenterOfRotationGrowingWindow(CenterOfRotation):
         This method finds the half-shift between two opposite images,  by
         minimizing difference over a moving window.
 
-        The output of this function, allows to compute motor movements for
-        aligning the sample rotation axis. Given the following values:
-
-        - L1: distance from source to motor
-        - L2: distance from source to detector
-        - ps: physical pixel size
-        - v: output of this function
-
-        displacement of motor = (L1 / L2 * ps) * v
+        Usage and parameters are the same as CenterOfRotationSlidingWindow, except for the following parameter.
 
         Parameters
         ----------
-        img_1: numpy.ndarray
-            First image
-        img_2: numpy.ndarray
-            Second image, it needs to have been flipped already (e.g. using numpy.fliplr).
-        side: string, optional
-            Expected region of the CoR. Allowed values: 'left', 'center', 'right', or 'all'.
-            Default is 'all'.
         min_window_width: int, optional
             Minimum window width that covers the common region of the two images /
             sinograms. Default is 11.
-        roi_yxhw: (2, ) or (4, ) numpy.ndarray, tuple, or array, optional
-            4 elements vector containing: vertical and horizontal coordinates
-            of first pixel, plus height and width of the Region of Interest (RoI).
-            Or a 2 elements vector containing: plus height and width of the
-            centered Region of Interest (RoI).
-            Default is None -> deactivated.
-        median_filt_shape: (2, ) numpy.ndarray, tuple, or array, optional
-            Shape of the median filter window. Default is None -> deactivated.
-        padding_mode: str in numpy.pad's mode list, optional
-            Padding mode, which determines the type of convolution. If None or
-            'wrap' are passed, this resorts to the traditional circular convolution.
-            If 'edge' or 'constant' are passed, it results in a linear convolution.
-            Default is the circular convolution.
-            All options are:
-                None | 'constant' | 'edge' | 'linear_ramp' | 'maximum' | 'mean'
-                | 'median' | 'minimum' | 'reflect' | 'symmetric' |'wrap'
-        peak_fit_radius: int, optional
-            Radius size around the max correlation pixel, for sub-pixel fitting.
-            Minimum and default value is 1.
-        low_pass: float or sequence of two floats
-            Low-pass filter properties, as described in `nabu.misc.fourier_filters`
-        high_pass: float or sequence of two floats
-            High-pass filter properties, as described in `nabu.misc.fourier_filters`
-        return_validity: a boolean, defaults to false
-            if set to True adds a second return value which may have three string values.
-            These values are "unknown", "sound", "questionable".
-            It will be "uknown" if the  validation method is not implemented
-            and it will be "sound" or "questionable" if it is implemented.
-
-
-
-        Raises
-        ------
-        ValueError
-            In case images are not 2-dimensional or have different sizes.
-
-        Returns
-        -------
-        float
-            Estimated center of rotation position from the center of the RoI in pixels.
-
-        Examples
-        --------
-        The following code computes the center of rotation position for two
-        given images in a tomography scan, where the second image is taken at
-        180 degrees from the first.
-
-        >>> radio1 = data[0, :, :]
-        ... radio2 = np.fliplr(data[1, :, :])
-        ... CoR_calc = CenterOfRotationGrowingWindow()
-        ... cor_position = CoR_calc.find_shift(radio1, radio2)
-
-        Or for noisy images:
-
-        >>> cor_position = CoR_calc.find_shift(radio1, radio2, median_filt_shape=(3, 3))
         """
-
+        # COMPAT.
+        if return_relative_to_middle is None:
+            deprecation_warning(
+                "The current default behavior is to return the shift relative the the middle of the image. In a future release, this function will return the shift relative to the left-most pixel. To keep the current behavior, please use 'return_relative_to_middle=True'.",
+                do_print=True,
+                func_name="CenterOfRotationGrowingWindow.find_shift",
+            )
+            return_relative_to_middle = True  # the kwarg above will be False by default in a future release
+        # ---
         validity_check_result = cor_result_validity["unknown"]
 
         self._check_img_pair_sizes(img_1, img_2)
@@ -491,38 +381,35 @@ class CenterOfRotationGrowingWindow(CenterOfRotation):
         img_lower_half_size = np.floor(img_shape[-1] / 2).astype(np.intp)
         img_upper_half_size = np.ceil(img_shape[-1] / 2).astype(np.intp)
 
-        use_estimate_from_motor = "near_pos" in self.cor_options.keys() and isinstance(
-            self.cor_options["near_pos"], (int, float)
-        )
-        use_estimate_from_motor = False  # Not yet implemented.
-        if use_estimate_from_motor:
-            near_pos = self.cor_options["near_pos"]
-
+        if is_scalar(side):
+            self.logger.error(
+                "Passing a first CoR guess is not supported for CenterOfRotationGrowingWindow. Using side='all'."
+            )
+            side = "all"
+        if side.lower() == "right":
+            win_1_mid_start = img_lower_half_size
+            win_1_mid_end = np.floor(img_shape[-1] * 3 / 2).astype(np.intp) - min_window_width
+            win_2_mid_start = -img_upper_half_size + min_window_width
+            win_2_mid_end = img_upper_half_size
+        elif side.lower() == "left":
+            win_1_mid_start = -img_lower_half_size + min_window_width
+            win_1_mid_end = img_lower_half_size
+            win_2_mid_start = img_upper_half_size
+            win_2_mid_end = np.ceil(img_shape[-1] * 3 / 2).astype(np.intp) - min_window_width
+        elif side.lower() == "center":
+            win_1_mid_start = 0
+            win_1_mid_end = img_shape[-1]
+            win_2_mid_start = 0
+            win_2_mid_end = img_shape[-1]
+        elif side.lower() == "all":
+            win_1_mid_start = -img_lower_half_size + min_window_width
+            win_1_mid_end = np.floor(img_shape[-1] * 3 / 2).astype(np.intp) - min_window_width
+            win_2_mid_start = -img_upper_half_size + min_window_width
+            win_2_mid_end = np.ceil(img_shape[-1] * 3 / 2).astype(np.intp) - min_window_width
         else:
-            if side.lower() == "right":
-                win_1_mid_start = img_lower_half_size
-                win_1_mid_end = np.floor(img_shape[-1] * 3 / 2).astype(np.intp) - min_window_width
-                win_2_mid_start = -img_upper_half_size + min_window_width
-                win_2_mid_end = img_upper_half_size
-            elif side.lower() == "left":
-                win_1_mid_start = -img_lower_half_size + min_window_width
-                win_1_mid_end = img_lower_half_size
-                win_2_mid_start = img_upper_half_size
-                win_2_mid_end = np.ceil(img_shape[-1] * 3 / 2).astype(np.intp) - min_window_width
-            elif side.lower() == "center":
-                win_1_mid_start = 0
-                win_1_mid_end = img_shape[-1]
-                win_2_mid_start = 0
-                win_2_mid_end = img_shape[-1]
-            elif side.lower() == "all":
-                win_1_mid_start = -img_lower_half_size + min_window_width
-                win_1_mid_end = np.floor(img_shape[-1] * 3 / 2).astype(np.intp) - min_window_width
-                win_2_mid_start = -img_upper_half_size + min_window_width
-                win_2_mid_end = np.ceil(img_shape[-1] * 3 / 2).astype(np.intp) - min_window_width
-            else:
-                raise ValueError(
-                    "Side should be one of 'left', 'right', or 'center'. '%s' was given instead" % side.lower()
-                )
+            raise ValueError(
+                "Side should be one of 'left', 'right', or 'center' or 'all'. '%s' was given instead" % side.lower()
+            )
 
         n1 = win_1_mid_end - win_1_mid_start
         n2 = win_2_mid_end - win_2_mid_start
@@ -579,6 +466,9 @@ class CenterOfRotationGrowingWindow(CenterOfRotation):
             ax.set_title("Window dispersions")
             plt.show(block=False)
 
+        if not (return_relative_to_middle):
+            cor_h += (img_shape[-1] - 1) / 2.0
+
         if return_validity:
             return cor_h, validity_check_result
         else:
@@ -617,6 +507,7 @@ class CenterOfRotationAdaptiveSearch(CenterOfRotation):
         margins=None,
         filtered_cost=True,
         return_validity=False,
+        return_relative_to_middle=None,
     ):
         """Find the Center of Rotation (CoR), given two images.
 
@@ -624,79 +515,25 @@ class CenterOfRotationAdaptiveSearch(CenterOfRotation):
         means of correlation computed in Fourier space.
         A global search is done on on the detector span (minus a margin) without assuming centered scan conditions.
 
-        The output of this function, allows to compute motor movements for
-        aligning the sample rotation axis. Given the following values:
-
-        - L1: distance from source to motor
-        - L2: distance from source to detector
-        - ps: physical pixel size
-        - v: output of this function
-
-        displacement of motor = (L1 / L2 * ps) * v
+        Usage and parameters are the same as CenterOfRotation, except for the following parameters.
 
         Parameters
         ----------
-        img_1: numpy.ndarray
-            First image
-        img_2: numpy.ndarray
-            Second image, it needs to have been flipped already (e.g. using numpy.fliplr).
-        roi_yxhw: (2, ) or (4, ) numpy.ndarray, tuple, or array, optional
-            4 elements vector containing: vertical and horizontal coordinates
-            of first pixel, plus height and width of the Region of Interest (RoI).
-            Or a 2 elements vector containing: plus height and width of the
-            centered Region of Interest (RoI).
-            Default is None -> deactivated.
-        median_filt_shape: (2, ) numpy.ndarray, tuple, or array, optional
-            Shape of the median filter window. Default is None -> deactivated.
-        padding_mode: str in numpy.pad's mode list, optional
-            Padding mode, which determines the type of convolution. If None or
-            'wrap' are passed, this resorts to the traditional circular convolution.
-            If 'edge' or 'constant' are passed, it results in a linear convolution.
-            Default is the circular convolution.
-            All options are:
-                None | 'constant' | 'edge' | 'linear_ramp' | 'maximum' | 'mean'
-                | 'median' | 'minimum' | 'reflect' | 'symmetric' |'wrap'
-        low_pass: float or sequence of two floats.
-            Low-pass filter properties, as described in `nabu.misc.fourier_filters`
-        high_pass: float or sequence of two floats
-            High-pass filter properties, as described in `nabu.misc.fourier_filters`.
         margins:  None or a couple of floats or ints
             if margins is None or in the form of  (margin1,margin2) the search is done between margin1 and  dim_x-1-margin2.
             If left to None then by default (margin1,margin2)  = ( 10, 10 ).
         filtered_cost: boolean.
             True by default. It triggers the use of filtered images in the calculation of the cost function.
-        return_validity: a boolean, defaults to false
-            if set to True adds a second return value which may have three string values.
-            These values are "unknown", "sound", "questionable".
-            It will be "uknown" if the  validation method is not implemented
-            and it will be "sound" or "questionable" if it is implemented.
-
-        Raises
-        ------
-        ValueError
-            In case images are not 2-dimensional or have different sizes.
-
-        Returns
-        -------
-        float
-            Estimated center of rotation position from the center of the RoI in pixels.
-
-        Examples
-        --------
-        The following code computes the center of rotation position for two
-        given images in a tomography scan, where the second image is taken at
-        180 degrees from the first.
-
-        >>> radio1 = data[0, :, :]
-        ... radio2 = np.fliplr(data[1, :, :])
-        ... CoR_calc = CenterOfRotationAdaptiveSearch()
-        ... cor_position = CoR_calc.find_shift(radio1, radio2)
-
-        Or for noisy images:
-
-        >>> cor_position = CoR_calc.find_shift(radio1, radio2, median_filt_shape=(3, 3), high_pass=20, low_pass=1   )
         """
-
+        # COMPAT.
+        if return_relative_to_middle is None:
+            deprecation_warning(
+                "The current default behavior is to return the shift relative the the middle of the image. In a future release, this function will return the shift relative to the left-most pixel. To keep the current behavior, please use 'return_relative_to_middle=True'.",
+                do_print=True,
+                func_name="CenterOfRotationAdaptiveSearch.find_shift",
+            )
+            return_relative_to_middle = True  # the kwarg above will be False by default in a future release
+        # ---
         validity_check_result = cor_result_validity["unknown"]
 
         self._check_img_pair_sizes(img_1, img_2)
@@ -773,6 +610,7 @@ class CenterOfRotationAdaptiveSearch(CenterOfRotation):
                     low_pass=low_pass,
                     high_pass=high_pass,
                     roi_yxhw=roi_yxhw,
+                    return_relative_to_middle=True,
                 )
             except ValueError as err:
                 if "positions are outside the input margins" in str(err):
@@ -890,6 +728,9 @@ class CenterOfRotationAdaptiveSearch(CenterOfRotation):
         # The return value is the optimum which had been placed in the middle of the neighborood
         cor_position = min_neighborood[2]
 
+        if not (return_relative_to_middle):
+            cor_position += (img_1.shape[-1] - 1) / 2.0
+
         if return_validity:
             return cor_position, validity_check_result
         else:
@@ -898,217 +739,13 @@ class CenterOfRotationAdaptiveSearch(CenterOfRotation):
     __call__ = find_shift
 
 
-class CenterOfRotationFourierAngles(CenterOfRotation):
-    """This CoR estimation algo is proposed by V. Valls (BCU). It is based on the Fourier
-    transform of the columns on the sinogram.
-    It requires an initial guesss of the CoR wich is retrieved from
-    dataset_info.dataset_scanner.estimated_cor_from_motor. It is assumed in mm and pixel size in um.
-    Options are (for the moment) hard-coded in the SinoCORFinder.cor_finder.extra_options dict.
-    """
-
-    _default_cor_options = {
-        "crop_around_cor": False,
-        "side": "center",
-        "near_pos": None,
-        "near_std": 100,
-        "near_width": 20,
-        "near_shape": "tukey",
-        "near_weight": 0.1,
-        "near_alpha": 0.5,
-        "shift_sino": True,
-        "near_step": 0.5,
-        "refine": False,
-    }
-
-    def _freq_radio(self, sinos, ifrom, ito):
-        size = (sinos.shape[0] + sinos.shape[0] % 2) // 2
-        fs = np.empty((size, sinos.shape[1]))
-        for i in range(ifrom, ito):
-            line = sinos[:, i]
-            f_signal = rfft(line)
-            f = np.abs(f_signal[: (f_signal.size - 1) // 2 + 1])
-            f2 = np.abs(f_signal[(f_signal.size - 1) // 2 + 1 :][::-1])
-            if len(f) > len(f2):
-                f[1:] += f2
-            else:
-                f[0:] += f2
-            fs[:, i] = f
-        with np.errstate(divide="ignore", invalid="ignore", under="ignore"):
-            fs = np.log(fs)
-        return fs
-
-    def gaussian(self, p, x):
-        return p[3] + p[2] * np.exp(-((x - p[0]) ** 2) / (2 * p[1] ** 2))
-
-    def tukey(self, p, x):
-        pos, std, alpha, height, background = p
-        alpha = np.clip(alpha, 0, 1)
-        pi = np.pi
-        inv_alpha = 1 - alpha
-        width = std / (1 - alpha * 0.5)
-        xx = (np.abs(x - pos) - (width * 0.5 * inv_alpha)) / (width * 0.5 * alpha)
-        xx = np.clip(xx, 0, 1)
-        return (0.5 + np.cos(pi * xx) * 0.5) * height + background
-
-    def sinlet(self, p, x):
-        std = p[1] * 2.5
-        lin = np.maximum(0, std - np.abs(p[0] - x)) * 0.5 * np.pi / std
-        return p[3] + p[2] * np.sin(lin)
-
-    def _px(self, detector_width, abs_pos, near_std):
-        sym_range = None
-        if abs_pos is not None:
-            if self.cor_options["crop_around_cor"]:
-                sym_range = int(abs_pos - near_std * 2), int(abs_pos + near_std * 2)
-
-        window = self.cor_options["near_width"]
-        if sym_range is not None:
-            xx_from = max(window, sym_range[0])
-            xx_to = max(xx_from, min(detector_width - window, sym_range[1]))
-            if xx_from == xx_to:
-                sym_range = None
-        if sym_range is None:
-            xx_from = window
-            xx_to = detector_width - window
-
-        xx = np.arange(xx_from, xx_to, self.cor_options["near_step"])
-
-        return xx
-
-    def _symmetry_correlation(self, px, array, angles):
-        window = self.cor_options["near_width"]
-        if self.cor_options["shift_sino"]:
-            shift_index = np.argmin(np.abs(angles - np.pi)) - np.argmin(np.abs(angles - 0))
-        else:
-            shift_index = None
-        px_from = int(px[0])
-        px_to = int(np.ceil(px[-1]))
-        f_coef = np.empty(len(px))
-        f_array = self._freq_radio(array, px_from - window, px_to + window)
-        if shift_index is not None:
-            shift_array = np.empty(array.shape, dtype=array.dtype)
-            shift_array[0 : len(shift_array) - shift_index, :] = array[shift_index:, :]
-            shift_array[len(shift_array) - shift_index :, :] = array[:shift_index, :]
-            f_shift_array = self._freq_radio(shift_array, px_from - window, px_to + window)
-        else:
-            f_shift_array = f_array
-
-        for j, x in enumerate(px):
-            i = int(np.floor(x))
-            if x - i > 0.4:  # TO DO : Specific to near_step = 0.5?
-                f_left = f_array[:, i - window : i]
-                f_right = f_shift_array[:, i + 1 : i + window + 1][:, ::-1]
-            else:
-                f_left = f_array[:, i - window : i]
-                f_right = f_shift_array[:, i : i + window][:, ::-1]
-            with np.errstate(divide="ignore", invalid="ignore"):
-                f_coef[j] = np.sum(np.abs(f_left - f_right))
-        return f_coef
-
-    def _cor_correlation(self, px, abs_pos, near_std):
-        if abs_pos is not None:
-            signal = self.cor_options["near_shape"]
-            weight = self.cor_options["near_weight"]
-            alpha = self.cor_options["near_alpha"]
-            if signal == "sinlet":
-                coef = self.sinlet((abs_pos, near_std, -weight, 1), px)
-            elif signal == "gaussian":
-                coef = self.gaussian((abs_pos, near_std, -weight, 1), px)
-            elif signal == "tukey":
-                coef = self.tukey((abs_pos, near_std * 2, alpha, -weight, 1), px)
-            else:
-                raise ValueError("Shape unsupported")
-        else:
-            coef = np.ones_like(px)
-        return coef
-
-    def find_shift(
-        self,
-        img_1,
-        img_2,
-        angles,
-        side,
-        roi_yxhw=None,
-        median_filt_shape=None,
-        padding_mode=None,
-        peak_fit_radius=1,
-        high_pass=None,
-        low_pass=None,
-    ):
-        sinos = np.vstack([img_1, np.fliplr(img_2).copy()])
-        detector_width = sinos.shape[1]
-
-        increment = np.abs(angles[0] - angles[1])
-        if np.abs(angles[0] - angles[-1]) < (360 - 0.5) * np.pi / 180 - increment:
-            self.logger.warning("Not enough angles, estimator skipped")
-            return None
-
-        near_pos = self.cor_options.get("near_pos", None)  # A RELATIVE estimation of the COR
-
-        # Default coarse estimate to center of detector
-        # if no one is given either in NX or by user.
-        if near_pos is None:
-            self.logger.warning("No initial guess was found (from metadata or user) for CoR")
-            self.logger.warning("Setting initial guess to center of detector.")
-            if side == "center":
-                abs_pos = detector_width // 2
-            elif side == "left":
-                abs_pos = detector_width // 4
-            elif side == "right":
-                abs_pos = detector_width * 3 // 4
-            elif side == "near":
-                abs_pos = detector_width // 2
-            else:
-                raise ValueError(f"side '{side}' is not handled")
-        elif isinstance(near_pos, (int, float)):  # Convert RELATIVE to ABSOLUTE position
-            abs_pos = near_pos + detector_width / 2
-
-        near_std = None
-        if abs_pos is not None:
-            near_std = self.cor_options["near_std"]
-
-        px = self._px(detector_width, abs_pos, near_std)
-
-        coef_f = self._symmetry_correlation(
-            px,
-            sinos,
-            angles,
-        )
-        coef_p = self._cor_correlation(px, abs_pos, near_std)
-        coef = coef_f * coef_p
-
-        if len(px) > 0:
-            if self.cor_options["refine"]:
-                f_vals, f_pos = self.extract_peak_regions_1d(-coef, peak_radius=20, cc_coords=px)
-                cor, _ = self.refine_max_position_1d(f_vals, fx=f_pos, return_vertex_val=True)
-            else:
-                cor = px[np.argmin(coef)]
-            cor = cor - detector_width / 2
-        else:
-            cor = None
-
-        return cor
-
-    __call__ = find_shift
-
-
-class CenterOfRotationOctaveAccurate(AlignmentBase):
+class CenterOfRotationOctaveAccurate(CenterOfRotation):
     """This is a Python implementation of Octave/fastomo3/accurate COR estimator.
     The Octave 'accurate' function is renamed `local_correlation`.
     The Nabu standard `find_shift` has the same API as the other COR estimators (sliding, growing...)
 
-    The class inherits directly from AlignmentBase.
     """
 
-    _default_cor_options = {
-        "maxsize": [5, 5],
-        "refine": None,
-        "pmcc": False,
-        "normalize": True,
-        "low_pass": 0.01,
-        "limz": 0.5,
-    }
-
     def _cut(self, im, nrows, ncols, new_center_row=None, new_center_col=None):
         """Cuts a sub-matrix out of a larger matrix.
         Cuts in the center of the original matrix, except if new center is specified
@@ -1331,7 +968,7 @@ class CenterOfRotationOctaveAccurate(AlignmentBase):
 
         rapp_hist = []
         if np.sum(np.abs(cor_estimate) + 1 >= z1.shape):
-            self.logger.info(f"Approximate shift of [{cor_estimate[0]},{cor_estimate[1]}] is too large, setting [0 0]")
+            self.logger.debug(f"Approximate shift of [{cor_estimate[0]},{cor_estimate[1]}] is too large, setting [0 0]")
             cor_estimate = np.array([0, 0])
         maxsize = np.minimum(maxsize, np.floor((np.array(z1.shape) - 1) / 2)).astype(int)
         maxsize = np.minimum(maxsize, np.array(z1.shape) - np.abs(cor_estimate) - 1).astype(int)
@@ -1400,25 +1037,21 @@ class CenterOfRotationOctaveAccurate(AlignmentBase):
                 cor_estimate = c
                 # Check that new shift estimate was not already done (avoid eternal loop)
                 if self._checkifpart(cor_estimate, rapp_hist):
-                    if self.verbose:
-                        self.logger.info(f"Stuck in loop?")
+                    self.logger.debug("Stuck in loop?")
                     refine = True
                     shiftfound = True
                     c = np.array([np.nan, np.nan])
                 else:
                     rapp_hist.append(cor_estimate)
-                    if self.verbose:
-                        self.logger.info(f"Changing shift estimate: {cor_estimate}")
+                    self.logger.debug(f"Changing shift estimate: {cor_estimate}")
                     maxsize = np.minimum(maxsize, np.array(z1.shape) - np.abs(cor_estimate) - 1).astype(int)
                     if (maxsize == 0).sum():
-                        if self.verbose:
-                            self.logger.info(f"Edge of image reached")
+                        self.logger.debug("Edge of image reached")
                         refine = False
                         shiftfound = True
                         c = np.array([np.nan, np.nan])
             elif len(rapp_hist) > 0:
-                if self.verbose:
-                    self.logger.info("\n")
+                self.logger.debug("\n")
 
         ####################################
         # refine result; useful when shifts are not integer values
@@ -1455,102 +1088,31 @@ class CenterOfRotationOctaveAccurate(AlignmentBase):
 
     def find_shift(
         self,
-        img_1: np.ndarray,
-        img_2: np.ndarray,
-        side: str,
+        img_1,
+        img_2,
+        side="center",
         roi_yxhw=None,
         median_filt_shape=None,
         padding_mode=None,
         low_pass=0.01,
         high_pass=None,
+        maxsize=[5, 5],
+        refine=None,
+        pmcc=False,
+        normalize=True,
+        limz=0.5,
+        return_relative_to_middle=None,
     ):
-        """Automatically finds the Center of Rotation (CoR), given two images
-        (projections/radiographs). Suitable for half-aquisition scan.
-
-        This method finds the half-shift between two opposite images,  by
-        minimizing the variance of small ROI around a global COR estimate
-        (obtained by maximizing Fourier-space computed global correlations).
-
-
-        The output of this function, allows to compute motor movements for
-        aligning the sample rotation axis. Given the following values:
-
-        - L1: distance from source to motor
-        - L2: distance from source to detector
-        - ps: physical pixel size
-        - v: output of this function
-
-        displacement of motor = (L1 / L2 * ps) * v
-
-        Parameters
-        ----------
-        img_1: numpy.ndarray
-            First image
-        img_2: numpy.ndarray
-            Second image, it needs to have been flipped already (e.g. using numpy.fliplr).
-        side: string
-            Expected region of the CoR. Must be 'center' in that case.
-        roi_yxhw: (2, ) or (4, ) numpy.ndarray, tuple, or array, optional
-            4 elements vector containing: vertical and horizontal coordinates
-            of first pixel, plus height and width of the Region of Interest (RoI).
-            Or a 2 elements vector containing: plus height and width of the
-            centered Region of Interest (RoI).
-            Default is None -> deactivated.
-            The ROI will be used for the global estimate.
-        median_filt_shape: (2, ) numpy.ndarray, tuple, or array, optional
-            Shape of the median filter window. Default is None -> deactivated.
-        padding_mode: str in numpy.pad's mode list, optional
-            Padding mode, which determines the type of convolution. If None or
-            'wrap' are passed, this resorts to the traditional circular convolution.
-            If 'edge' or 'constant' are passed, it results in a linear convolution.
-            Default is the circular convolution.
-            All options are:
-                None | 'constant' | 'edge' | 'linear_ramp' | 'maximum' | 'mean'
-                | 'median' | 'minimum' | 'reflect' | 'symmetric' |'wrap'
-        low_pass: float or sequence of two floats
-            Low-pass filter properties, as described in `nabu.misc.fourier_filters`
-        high_pass: float or sequence of two floats
-            High-pass filter properties, as described in `nabu.misc.fourier_filters`
-
-                    Raises
-        ------
-        ValueError
-            In case images are not 2-dimensional or have different sizes.
-
-        Returns
-        -------
-        float
-            Estimated center of rotation position from the center of the RoI in pixels.
-
-        Examples
-        --------
-        The following code computes the center of rotation position for two
-        given images in a tomography scan, where the second image is taken at
-        180 degrees from the first.
-
-        >>> radio1 = data[0, :, :]
-        ... radio2 = np.fliplr(data[1, :, :])
-        ... CoR_calc = CenterOfRotationOctaveAccurate()
-        ... cor_position = CoR_calc.find_shift(radio1, radio2)
-
-        Or for noisy images:
-
-        >>> cor_position = CoR_calc.find_shift(radio1, radio2, median_filt_shape=(3, 3))
-        """
-
-        self.logger.info(
-            f"Estimation of the COR with following options: high_pass={high_pass}, low_pass={low_pass}, limz={self.cor_options['limz']}."
-        )
-
-        self._check_img_pair_sizes(img_1, img_2)
-
-        if side != "center":
-            self.logger.fatal(
-                "The accurate algorithm cannot handle half acq. Use 'near', 'fourier-angles', 'sliding-window' or 'growing-window' instead."
-            )
-            raise ValueError(
-                "The accurate algorithm cannot handle half acq. Use 'near', 'fourier-angles', 'sliding-window' or 'growing-window' instead."
+        # COMPAT.
+        if return_relative_to_middle is None:
+            deprecation_warning(
+                "The current default behavior is to return the shift relative the the middle of the image. In a future release, this function will return the shift relative to the left-most pixel. To keep the current behavior, please use 'return_relative_to_middle=True'.",
+                do_print=True,
+                func_name="CenterOfRotationOctaveAccurate.find_shift",
             )
+            return_relative_to_middle = True  # the kwarg above will be False by default in a future release
+        # ---
+        self._check_img_pair_sizes(img_1, img_2)
 
         img_shape = img_2.shape
         roi_yxhw = self._determine_roi(img_shape, roi_yxhw)
@@ -1572,10 +1134,10 @@ class CenterOfRotationOctaveAccurate(AlignmentBase):
         shift -= np.array(img_shape) // 2
 
         # The real "accurate" starts here (i.e. the octave findshift() func).
-        if np.abs(shift[0]) > 10 * self.cor_options["limz"]:
+        if np.abs(shift[0]) > 10 * limz:
             # This is suspiscious. We don't trust results of correlate.
-            self.logger.info(f"Pre-correlation yields {shift[0]} pixels vertical motion")
-            self.logger.info(f"We do not consider it.")
+            self.logger.warning("Pre-correlation yields {shift[0]} pixels vertical motion")
+            self.logger.warning("We do not consider it.")
             shift = (0, 0)
 
         # Limit the size of region for comparison to cutsize in both directions.
@@ -1590,32 +1152,44 @@ class CenterOfRotationOctaveAccurate(AlignmentBase):
             shift = oldshift + self._local_correlation(
                 im0,
                 im1,
-                maxsize=self.cor_options["maxsize"],
-                refine=self.cor_options["refine"],
-                pmcc=self.cor_options["pmcc"],
-                normalize=self.cor_options["normalize"],
+                maxsize=maxsize,
+                refine=refine,
+                pmcc=pmcc,
+                normalize=normalize,
             )
         else:
             shift = self._local_correlation(
                 img_1,
                 img_2,
-                maxsize=self.cor_options["maxsize"],
+                maxsize=maxsize,
                 cor_estimate=oldshift,
-                refine=self.cor_options["refine"],
-                pmcc=self.cor_options["pmcc"],
-                normalize=self.cor_options["normalize"],
+                refine=refine,
+                pmcc=pmcc,
+                normalize=normalize,
             )
         if ((shift - oldshift) ** 2).sum() > 4:
-            self.logger.info(f"Pre-correlation ({oldshift}) and accurate correlation ({shift}) are not consistent.")
-            self.logger.info("Please check!!!")
+            self.logger.warning(f"Pre-correlation ({oldshift}) and accurate correlation ({shift}) are not consistent.")
+            self.logger.warning("Please check!!!")
 
         offset = shift[1] / 2
 
-        if np.abs(shift[0]) > self.cor_options["limz"]:
-            self.logger.info("Verify alignment or sample motion.")
-            self.logger.info(f"Verical motion: {shift[0]} pixels.")
-            self.logger.info(f"Offset?: {offset} pixels.")
+        if np.abs(shift[0]) > limz:
+            self.logger.debug("Verify alignment or sample motion.")
+            self.logger.debug(f"Verical motion: {shift[0]} pixels.")
+            self.logger.debug(f"Offset?: {offset} pixels.")
         else:
-            self.logger.info(f"Offset?: {offset} pixels.")
+            self.logger.debug(f"Offset?: {offset} pixels.")
+
+        if not (return_relative_to_middle):
+            offset += (img_shape[1] - 1) / 2
 
         return offset
+
+
+# COMPAT.
+from .cor_sino import CenterOfRotationFourierAngles as CenterOfRotationFourierAngles0
+
+CenterOfRotationFourierAngles = deprecated_class(
+    "CenterOfRotationFourierAngles was moved to nabu.estimation.cor_sino", do_print=True
+)(CenterOfRotationFourierAngles0)
+#