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

nabu/estimation/cor_sino.py

@@ -1,30 +1,16 @@
-"""
-This module provides global definitions and methods to compute COR in extrem
-Half Acquisition mode
-"""
-
-__authors__ = ["C. Nemoz", "H.Payno"]
-__license__ = "MIT"
-__date__ = "13/04/2021"
-
 import numpy as np
 from scipy.signal import convolve2d
+from scipy.fft import rfft
+
+from ..utils import deprecation_warning, is_scalar
 from ..resources.logger import LoggerOrPrint
 
+try:
+    from algotom.prep.calculation import find_center_vo, find_center_360
 
-def schift(mat, val):
-    ker = np.zeros((3, 3))
-    s = 1.0
-    if val < 0:
-        s = -1.0
-    val = s * val
-    ker[1, 1] = 1 - val
-    if s > 0:
-        ker[1, 2] = val
-    else:
-        ker[1, 0] = val
-    mat = convolve2d(mat, ker, mode="same")
-    return mat
+    __have_algotom__ = True
+except ImportError:
+    __have_algotom__ = False
 
 
 class SinoCor:
@@ -57,6 +43,21 @@ class SinoCor:
 
         self.window_width = round(self.sx / 5)
 
+    @staticmethod
+    def schift(mat, val):
+        ker = np.zeros((3, 3))
+        s = 1.0
+        if val < 0:
+            s = -1.0
+        val = s * val
+        ker[1, 1] = 1 - val
+        if s > 0:
+            ker[1, 2] = val
+        else:
+            ker[1, 0] = val
+        mat = convolve2d(mat, ker, mode="same")
+        return mat
+
     def overlap(self, side="right", window_width=None):
         """
         Compute COR by minimizing difference of circulating ROI
@@ -151,7 +152,7 @@ class SinoCor:
             x0 = xc1 + pix
             for isf in isfr:
                 if isf != 0:
-                    ims = schift(self.data1[:, x0 : x0 + xwin].copy(), -p_sign * isf)
+                    ims = self.schift(self.data1[:, x0 : x0 + xwin].copy(), -p_sign * isf)
                 else:
                     ims = self.data1[:, x0 : x0 + xwin]
 
@@ -175,9 +176,336 @@ class SinoCorInterface:
     def __init__(self, logger=None, **kwargs):
         self._logger = logger
 
-    def find_shift(self, img_1, img_2, side="right", window_width=None, neighborhood=7, shift_value=0.1, **kwargs):
+    def find_shift(
+        self,
+        img_1,
+        img_2,
+        side="right",
+        window_width=None,
+        neighborhood=7,
+        shift_value=0.1,
+        return_relative_to_middle=None,
+        **kwargs,
+    ):
+
+        # 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="CenterOfRotationCoarseToFine.find_shift",
+            )
+            return_relative_to_middle = True  # the kwarg above will be False by default in a future release
+        # ---
+
         cor_finder = SinoCor(img_1, img_2, logger=self._logger)
         cor_finder.estimate_cor_coarse(side=side, window_width=window_width)
         cor = cor_finder.estimate_cor_fine(neighborhood=neighborhood, shift_value=shift_value)
         # offset will be added later - keep compatibility with result from AlignmentBase.find_shift()
-        return cor - img_1.shape[1] / 2
+        if return_relative_to_middle:
+            return cor - (img_1.shape[1] - 1) / 2
+        else:
+            return cor
+
+
+class CenterOfRotationFourierAngles:
+    """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.x_rotation_axis_pixel_position. 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.
+    """
+
+    def __init__(self, *args, **kwargs):
+        pass
+
+    def _convert_from_fft_2_fftpack_format(self, f_signal, o_signal_length):
+        """
+        Converts a scipy.fft.rfft into the (legacy) scipy.fftpack.rfft format.
+        The fftpack.rfft returns a (roughly) twice as long array as fft.rfft as the latter returns an array
+        of complex numbers wheras the former returns an array with real and imag parts in consecutive
+        spots in the array.
+
+        Parameters
+        ----------
+        f_signal : array_like
+            The output of scipy.fft.rfft(signal)
+        o_signal_length : int
+            Size of the original signal (before FT).
+
+        Returns
+        -------
+        out
+            The rfft converted to the fftpack.rfft format (roughly twice as long).
+        """
+        out = np.zeros(o_signal_length, dtype=np.float32)
+        if o_signal_length % 2 == 0:
+            out[0] = f_signal[0].real
+            out[1::2] = f_signal[1:].real
+            out[2::2] = f_signal[1:-1].imag
+        else:
+            out[0] = f_signal[0].real
+            out[1::2] = f_signal[1:].real
+            out[2::2] = f_signal[1:].imag
+        return out
+
+    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_signal = self._convert_from_fft_2_fftpack_format(f_signal, line.shape[0])
+            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_width, near_std, crop_around_cor, near_step):
+        sym_range = None
+        if abs_pos is not None:
+            if crop_around_cor:
+                sym_range = int(abs_pos - near_std * 2), int(abs_pos + near_std * 2)
+
+        window = 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, near_step)
+
+        return xx
+
+    def _symmetry_correlation(self, px, array, angles, window, shift_sino):
+        if 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, signal, near_weight, near_alpha):
+        if abs_pos is not None:
+            if signal == "sinlet":
+                coef = self.sinlet((abs_pos, near_std, -near_weight, 1), px)
+            elif signal == "gaussian":
+                coef = self.gaussian((abs_pos, near_std, -near_weight, 1), px)
+            elif signal == "tukey":
+                coef = self.tukey((abs_pos, near_std * 2, near_alpha, -near_weight, 1), px)
+            else:
+                raise ValueError("Shape unsupported")
+        else:
+            coef = np.ones_like(px)
+        return coef
+
+    def find_shift(
+        self,
+        sino,
+        angles=None,
+        side="center",
+        near_std=100,
+        near_width=20,
+        shift_sino=True,
+        crop_around_cor=False,
+        signal="tukey",
+        near_weight=0.1,
+        near_alpha=0.5,
+        near_step=0.5,
+        return_relative_to_middle=None,
+    ):
+        detector_width = sino.shape[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="CenterOfRotationFourierAngles.find_shift",
+            )
+            return_relative_to_middle = True  # the kwarg above will be False by default in a future release
+        # ---
+
+        if angles is None:
+            angles = np.linspace(0, 2 * np.pi, sino.shape[0], endpoint=True)
+        increment = np.abs(angles[0] - angles[1])
+        if np.abs(angles[0] - angles[-1]) < (360 - 0.5) * np.pi / 180 - increment:
+            raise ValueError("Not enough angles, estimator skipped")
+
+        if is_scalar(side):
+            abs_pos = side
+        # COMPAT.
+        elif side == "near":
+            deprecation_warning(
+                "side='near' is deprecated, please use side=<a scalar>", do_print=True, func_name="fourier_angles_near"
+            )
+            abs_pos = detector_width // 2
+        ##.
+        elif side == "center":
+            abs_pos = detector_width // 2
+        elif side == "left":
+            abs_pos = detector_width // 4
+        elif side == "right":
+            abs_pos = detector_width * 3 // 4
+        else:
+            raise ValueError(f"side '{side}' is not handled")
+
+        px = self._px(detector_width, abs_pos, near_width, near_std, crop_around_cor, near_step)
+
+        coef_f = self._symmetry_correlation(
+            px,
+            sino,
+            angles,
+            near_width,
+            shift_sino,
+        )
+        coef_p = self._cor_correlation(px, abs_pos, near_std, signal, near_weight, near_alpha)
+        coef = coef_f * coef_p
+
+        if len(px) > 0:
+            cor = px[np.argmin(coef)] - (detector_width - 1) / 2
+        else:
+            # raise ValueError ?
+            cor = None
+        if not (return_relative_to_middle):
+            cor += (detector_width - 1) / 2
+        return cor
+
+    __call__ = find_shift
+
+
+class CenterOfRotationVo:
+    """
+    A wrapper around algotom 'find_center_vo' and 'find_center_360'.
+
+    Nghia T. Vo, Michael Drakopoulos, Robert C. Atwood, and Christina Reinhard,
+    "Reliable method for calculating the center of rotation in parallel-beam tomography,"
+    Opt. Express 22, 19078-19086 (2014)
+    """
+
+    default_extra_options = {}
+
+    def __init__(self, logger=None, verbose=False, extra_options=None):
+        if not (__have_algotom__):
+            raise ImportError("Need the 'algotom' package")
+        self.extra_options = self.default_extra_options.copy()
+        self.extra_options.update(extra_options or {})
+
+    def find_shift(
+        self,
+        sino,
+        halftomo=False,
+        is_360=False,
+        win_width=100,
+        side="center",
+        search_width_fraction=0.1,
+        step=0.25,
+        radius=4,
+        ratio=0.5,
+        dsp=True,
+        ncore=None,
+        hor_drop=None,
+        ver_drop=None,
+        denoise=True,
+        norm=True,
+        use_overlap=False,
+        return_relative_to_middle=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="CenterOfRotationVo.find_shift",
+            )
+            return_relative_to_middle = True  # the kwarg above will be False by default in a future release
+        # ---
+
+        if halftomo:
+            side_algotom = {"left": 0, "right": 1}.get(side, None)
+            cor, _, _, _ = find_center_360(
+                sino, win_width, side=side_algotom, denoise=denoise, norm=norm, use_overlap=use_overlap, ncore=ncore
+            )
+        else:
+            if is_360 and not (halftomo):
+                # Take only one part of the sinogram and use "find_center_vo" - this works better in this case
+                sino = sino[: sino.shape[0] // 2]
+
+            sino_width = sino.shape[-1]
+            search_width = int(search_width_fraction * sino_width)
+
+            if side == "left":
+                start, stop = 0, search_width
+            elif side == "center":
+                start, stop = sino_width // 2 - search_width, sino_width // 2 + search_width
+            elif side == "right":
+                start, stop = sino_width - search_width, sino_width
+            elif is_scalar(side):
+                # side is passed as an offset from the middle of detector
+                side = side + (sino.shape[-1] - 1) / 2.0
+                start, stop = max(0, side - search_width), min(sino_width, side + search_width)
+            else:
+                raise ValueError("Expected 'side' to be 'left', 'center', 'right' or a scalar")
+
+            cor = find_center_vo(
+                sino,
+                start=start,
+                stop=stop,
+                step=step,
+                radius=radius,
+                ratio=ratio,
+                dsp=dsp,
+                ncore=ncore,
+                hor_drop=hor_drop,
+                ver_drop=ver_drop,
+            )
+        return cor if not (return_relative_to_middle) else cor - (sino.shape[1] - 1) / 2

nabu/estimation/focus.py

@@ -1,10 +1,54 @@
 import numpy as np
 
+from scipy.fft import fftn
+
+from ..processing.azim import azimuthal_integration_skimage_stack, azimuthal_integration_imagej_stack, __have_skimage__
 from .alignment import plt
 from .cor import CenterOfRotation
 
 
 class CameraFocus(CenterOfRotation):
+
+    def _check_position_jitter(self, img_pos):
+        pos_diff = np.diff(img_pos)
+        if np.any(pos_diff <= 0):
+            self.logger.warning(
+                "Image position regressed throughout scan! (negative movement for some image positions)"
+            )
+
+    @staticmethod
+    def _gradient(x, axes):
+        d = [None] * len(axes)
+        for ii in range(len(axes)):
+            ind = -(ii + 1)
+            padding = [(0, 0)] * len(x.shape)
+            padding[ind] = (0, 1)
+            temp_x = np.pad(x, padding, mode="constant")
+            d[ind] = np.diff(temp_x, n=1, axis=ind)
+        return np.stack(d, axis=0)
+
+    @staticmethod
+    def _compute_metric_value(data, metric, axes=(-2, -1)):
+        if metric.lower() == "std":
+            return np.std(data, axis=axes) / np.mean(data, axis=axes)
+        elif metric.lower() == "grad":
+            grad_data = CameraFocus._gradient(data, axes=axes)
+            grad_mag = np.sqrt(np.sum(grad_data**2, axis=0))
+            return np.sum(grad_mag, axis=axes)
+        elif metric.lower() == "psd":
+            f_data = fftn(data, axes=axes, workers=4)
+            f_data = np.fft.fftshift(f_data, axes=(-2, -1))
+            # octave-fasttomo3 uses |.|^2, probably with scaled FFT (norm="forward" in python),
+            # but tests show that it's less accurate.
+            f_data = np.abs(f_data)
+            ai_func = azimuthal_integration_skimage_stack if __have_skimage__ else azimuthal_integration_imagej_stack
+            az_data = ai_func(f_data, n_threads=4)
+            max_vals = np.max(az_data, axis=0)
+            az_data /= max_vals[None, :]
+            return np.mean(az_data, axis=-1)
+        else:
+            raise ValueError("Unknown metric function %s" % metric)
+
     def find_distance(
         self,
         img_stack: np.ndarray,
@@ -76,6 +120,7 @@ class CameraFocus(CenterOfRotation):
         is the associated image position (starting from 1).
         """
         self._check_img_stack_size(img_stack, img_pos)
+        self._check_position_jitter(img_pos)
 
         if peak_fit_radius < 1:
             self.logger.warning("Parameter peak_fit_radius should be at least 1, given: %d instead." % peak_fit_radius)
@@ -93,19 +138,25 @@ class CameraFocus(CenterOfRotation):
             high_pass=high_pass,
         )
 
-        img_stds = np.std(img_stack, axis=(-2, -1)) / np.mean(img_stack, axis=(-2, -1))
+        img_resp = self._compute_metric_value(img_stack, metric=metric, axes=(-2, -1))
 
-        # assuming images are equispaced
+        # assuming images are equispaced!
+        # focus_step = np.mean(np.abs(np.diff(img_pos)))
         focus_step = (img_pos[-1] - img_pos[0]) / (num_imgs - 1)
 
         img_inds = np.arange(num_imgs)
-        (f_vals, f_pos) = self.extract_peak_regions_1d(img_stds, peak_radius=peak_fit_radius, cc_coords=img_inds)
-        focus_ind, img_std_max = self.refine_max_position_1d(f_vals, return_vertex_val=True)
+        (f_vals, f_pos) = self.extract_peak_regions_1d(img_resp, peak_radius=peak_fit_radius, cc_coords=img_inds)
+        focus_ind, img_resp_max = self.refine_max_position_1d(f_vals, return_vertex_val=True, return_all_coeffs=True)
         focus_ind += f_pos[1, :]
 
         focus_pos = img_pos[0] + focus_step * focus_ind
         focus_ind += 1
 
+        if focus_pos.size == 1:
+            focus_pos = focus_pos[0]
+        if focus_ind.size == 1:
+            focus_ind = focus_ind[0]
+
         if self.verbose:
             self.logger.info(
                 "Fitted focus motor position:",
@@ -115,9 +166,9 @@ class CameraFocus(CenterOfRotation):
             )
             f, ax = plt.subplots(1, 1)
             self._add_plot_window(f, ax=ax)
-            ax.stem(img_pos, img_stds)
-            ax.stem(focus_pos, img_std_max, linefmt="C1-", markerfmt="C1o")
-            ax.set_title("Images std")
+            ax.stem(img_pos, img_resp)
+            ax.stem(focus_pos, img_resp_max, linefmt="C1-", markerfmt="C1o")
+            ax.set_title("Images response (metric: %s)" % metric)
             plt.show(block=False)
 
         return focus_pos, focus_ind
@@ -272,6 +323,7 @@ class CameraFocus(CenterOfRotation):
         ...     img_stack, img_pos, roi_yxhw=img_roi, regions_number=regions_number)
         """
         self._check_img_stack_size(img_stack, img_pos)
+        self._check_position_jitter(img_pos)
 
         if peak_fit_radius < 1:
             self.logger.warning("Parameter peak_fit_radius should be at least 1, given: %d instead." % peak_fit_radius)
@@ -306,15 +358,15 @@ class CameraFocus(CenterOfRotation):
         )
         img_stack = np.reshape(img_stack, block_stack_size)
 
-        img_stds = np.std(img_stack, axis=(-3, -1)) / np.mean(img_stack, axis=(-3, -1))
-        img_stds = np.reshape(img_stds, [num_imgs, -1]).transpose()
+        img_resp = self._compute_metric_value(img_stack, metric=metric, axes=(-3, -1))
+        img_resp = np.reshape(img_resp, [num_imgs, -1]).transpose()
 
         # assuming images are equispaced
         focus_step = (img_pos[-1] - img_pos[0]) / (num_imgs - 1)
 
         img_inds = np.arange(num_imgs)
-        (f_vals, f_pos) = self.extract_peak_regions_1d(img_stds, peak_radius=peak_fit_radius, cc_coords=img_inds)
-        focus_inds = self.refine_max_position_1d(f_vals)
+        (f_vals, f_pos) = self.extract_peak_regions_1d(img_resp, peak_radius=peak_fit_radius, cc_coords=img_inds)
+        focus_inds = self.refine_max_position_1d(f_vals, return_all_coeffs=True)
         focus_inds += f_pos[1, :]
 
         focus_poss = img_pos[0] + focus_step * focus_inds