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

build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/nabu/estimation/cor_sino.py

@@ -0,0 +1,183 @@
+"""
+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 ..resources.logger import LoggerOrPrint
+
+
+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
+
+
+class SinoCor:
+    """
+    This class has 2 methods:
+        - overlap. Find a rough estimate of COR
+        - accurate. Try to refine COR to 1/10 pixel
+    """
+
+    def __init__(self, img_1, img_2, logger=None):
+        """ """
+        self.logger = LoggerOrPrint(logger)
+        self.sx = img_1.shape[1]
+
+        # algorithm cannot accept odd number of projs. This is handled in the SinoCORFinder class.
+        nproj2 = img_1.shape[0]
+
+        # extract upper and lower part of sinogram, flipping H the upper part
+        self.data1 = img_1
+        self.data2 = img_2
+
+        self.rcor_abs = round(self.sx / 2.0)
+        self.cor_acc = round(self.sx / 2.0)
+
+        # parameters for overlap sino - rough estimation
+
+        # default sliding ROI is 20% of the width of the detector
+        # the maximum size of ROI in the "right" case is 2*(self.sx - COR)
+        # ex: 2048 pixels, COR= 2000, window_width should not exceed 96!
+
+        self.window_width = round(self.sx / 5)
+
+    def overlap(self, side="right", window_width=None):
+        """
+        Compute COR by minimizing difference of circulating ROI
+
+         - side:         preliminary knowledge if the COR is on right or left
+         - window_width: width of ROI that will slide on the other part of the sinogram
+                         by default, 20% of the width of the detector.
+        """
+
+        if window_width is None:
+            window_width = self.window_width
+
+        if not (window_width & 1):
+            window_width -= 1
+
+        # number of pixels where the window will "slide".
+        n = self.sx - int(window_width)
+        nr = range(n)
+
+        dmax = 1000000000.0
+        imax = 0
+
+        # Should we do both right and left and take the minimum "diff" of the 2 ?
+        # windows self.data2 moves over self.data1, measure the width of the histogram and retains the smaller one.
+        if side == "right":
+            for i in nr:
+                imout = self.data1[:, n - i : n - i + window_width] - self.data2[:, 0:window_width]
+                diff = imout.max() - imout.min()
+                if diff < dmax:
+                    dmax = diff
+                    imax = i
+            self.cor_abs = self.sx - (imax + window_width + 1.0) / 2.0
+            self.cor_rel = self.sx / 2 - (imax + window_width + 1.0) / 2.0
+        else:
+            for i in nr:
+                imout = self.data1[:, i : i + window_width] - self.data2[:, self.sx - window_width : self.sx]
+                diff = imout.max() - imout.min()
+                if diff < dmax:
+                    dmax = diff
+                    imax = i
+            self.cor_abs = (imax + window_width - 1.0) / 2
+            self.cor_rel = self.cor_abs - self.sx / 2.0 - 1
+        if imax < 1:
+            self.logger.warning("sliding width %d seems too large!" % window_width)
+        self.rcor_abs = round(self.cor_abs)
+        return self.rcor_abs
+
+    def accurate(self, neighborhood=7, shift_value=0.1):
+        """
+        refine the calculation around COR integer pre-calculated value
+        The search will be executed in the defined neighborhood
+
+        Parameters
+        -----------
+        neighborhood: int
+            Parameter for accurate calculation in the vicinity of the rough estimate.
+            It must be an odd number.
+            0.1 pixels float shifts will be performed over this number of pixel
+        """
+        # define the H-size (odd) of the window one can use to find the best overlap moving finely over ng pixels
+        if not (neighborhood & 1):
+            neighborhood += 1
+        ng2 = int(neighborhood / 2)
+
+        # pleft and pright are the number of pixels available on the left and the right of the cor position
+        # to slide a window
+        pleft = self.rcor_abs - ng2
+        pright = self.sx - self.rcor_abs - ng2 - 1
+
+        # the maximum window to slide is restricted by the smaller side
+        if pleft > pright:
+            p_sign = 1
+            xwin = 2 * (self.sx - self.rcor_abs - ng2) - 1
+        else:
+            p_sign = -1
+            xwin = 2 * (self.rcor_abs - ng2) + 1
+
+        # Note that xwin is odd
+        xc1 = self.rcor_abs - int(xwin / 2)
+        xc2 = self.sx - self.rcor_abs - int(xwin / 2) - 1
+
+        im1 = self.data1[:, xc1 : xc1 + xwin]
+        im2 = self.data2[:, xc2 : xc2 + xwin]
+
+        pixs = p_sign * (np.arange(neighborhood) - ng2)
+        diff0 = 1000000000.0
+
+        isfr = shift_value * np.arange(10)
+        self.cor_acc = self.rcor_abs
+
+        for pix in pixs:
+            x0 = xc1 + pix
+            for isf in isfr:
+                if isf != 0:
+                    ims = schift(self.data1[:, x0 : x0 + xwin].copy(), -p_sign * isf)
+                else:
+                    ims = self.data1[:, x0 : x0 + xwin]
+
+                imout = ims - self.data2[:, xc2 : xc2 + xwin]
+                diff = imout.max() - imout.min()
+                if diff < diff0:
+                    self.cor_acc = self.rcor_abs + (pix + p_sign * isf) / 2.0
+                    diff0 = diff
+        return self.cor_acc
+
+    # Aliases
+    estimate_cor_coarse = overlap
+    estimate_cor_fine = accurate
+
+
+class SinoCorInterface:
+    """
+    A class that mimics the interface of CenterOfRotation, while calling SinoCor
+    """
+
+    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):
+        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

build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/nabu/estimation/distortion.py

@@ -0,0 +1,112 @@
+import numpy as np
+import scipy.interpolate
+from .translation import DetectorTranslationAlongBeam
+from ..misc.filters import correct_spikes
+from ..resources.logger import LoggerOrPrint
+
+
+def estimate_flat_distortion(
+    flat,
+    image,
+    tile_size=100,
+    interpolation_kind="linear",
+    padding_mode="edge",
+    correction_spike_threshold=None,
+    logger=None,
+):
+    """
+    Estimate the wavefront distortion on a flat image, from another image.
+
+    Parameters
+    ----------
+    flat: np.array
+        The flat-field image to be corrected
+    image: np.ndarray
+        The image to correlate the flat against.
+    tile_size: int
+        The wavefront corrections are calculated by correlating the
+        image to the flat, region by region. The regions are tiles of size tile_size
+    interpolation_kind: "linear" or "cubic"
+        The interpolation method used for interpolation
+    padding_mode: string
+        Padding mode. Must be valid for np.pad
+        when wavefront correction is applied, the corrections are first found for the tiles,
+        which gives the shift at the center of each tiled. Then, to interpolate the corrections,
+        at the positions f every pixel, on must add also the border of the extremal tiles.
+        This is done by padding with a width of 1, and using the mode given 'padding_mode'.
+    correction_spike_threshold: float, optional
+        By default it is None and no spike correction is performed on the shifts grid which is found by correlation.
+        If set to a float, a spike removal will be applied using such threshold
+
+    Returns
+    --------
+    coordinates: np.ndarray
+        An array having dimensions (flat.shape[0], flat.shape[1], 2)
+        where each coordinates[i,j] contains the coordinates of the position
+        in the  image "flat" which correlates to the pixel (i,j) in the  image "im2".
+    """
+    logger = LoggerOrPrint(logger)
+    starts_r = np.array(range(0, image.shape[0] - tile_size, tile_size))
+    starts_c = np.array(range(0, image.shape[1] - tile_size, tile_size))
+    cor1 = np.zeros([len(starts_r), len(starts_c)], np.float32)
+    cor2 = np.zeros([len(starts_r), len(starts_c)], np.float32)
+
+    shift_finder = DetectorTranslationAlongBeam()
+    for ir, r in enumerate(starts_r):
+        for ic, c in enumerate(starts_c):
+            try:
+                coeff_v, coeff_h, shifts_vh_per_img = shift_finder.find_shift(
+                    np.array([image[r : r + tile_size, c : c + tile_size], flat[r : r + tile_size, c : c + tile_size]]),
+                    np.array([0, 1]),
+                    return_shifts=True,
+                    low_pass=(1.0, 0.3),
+                    high_pass=(tile_size, tile_size * 0.3),
+                )
+                cor1[ir, ic], cor2[ir, ic] = shifts_vh_per_img[1]
+
+            except ValueError as e:
+                if "positions are outside" in str(e):
+                    logger.debug(str(e))
+                    cor1[ir, ic], cor2[ir, ic] = (0, 0)
+                else:
+                    raise
+
+    cor1[np.isnan(cor1)] = 0
+    cor2[np.isnan(cor2)] = 0
+
+    if correction_spike_threshold is not None:
+        cor1 = correct_spikes(cor1, correction_spike_threshold)
+        cor2 = correct_spikes(cor2, correction_spike_threshold)
+
+    # TODO implement the previous spikes correction in CCDCorrection - median_clip
+    # spikes_corrector = CCDCorrection(cor1.shape, median_clip_thresh=3, abs_diff=True, preserve_borders=True)
+    # cor1 = spikes_corrector.median_clip_correction(cor1)
+    # cor2 = spikes_corrector.median_clip_correction(cor2)
+
+    cor1 = np.pad(cor1, ((1, 1), (1, 1)), mode=padding_mode)
+    cor2 = np.pad(cor2, ((1, 1), (1, 1)), mode=padding_mode)
+
+    hp = np.concatenate([[0.0], starts_c + tile_size * 0.5, [image.shape[1]]])
+    vp = np.concatenate([[0.0], starts_r + tile_size * 0.5, [image.shape[0]]])
+
+    h_ticks = np.arange(image.shape[1]).astype(np.float32)
+    v_ticks = np.arange(image.shape[0]).astype(np.float32)
+
+    spline_degree = {"linear": 1, "cubic": 3}[interpolation_kind]
+
+    interpolator = scipy.interpolate.RectBivariateSpline(vp, hp, cor1, kx=spline_degree, ky=spline_degree)
+    cor1 = interpolator(h_ticks, v_ticks)
+
+    interpolator = scipy.interpolate.RectBivariateSpline(vp, hp, cor2, kx=spline_degree, ky=spline_degree)
+    cor2 = interpolator(h_ticks, v_ticks)
+
+    hh = np.arange(image.shape[1]).astype(np.float32)
+    vv = np.arange(image.shape[0]).astype(np.float32)
+    unshifted_v, unshifted_h = np.meshgrid(vv, hh, indexing="ij")
+
+    shifted_v = unshifted_v - cor1
+    shifted_h = unshifted_h - cor2
+
+    coordinates = np.transpose(np.array([shifted_v, shifted_h]), axes=[1, 2, 0])
+
+    return coordinates

build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/nabu/estimation/focus.py

@@ -0,0 +1,362 @@
+import numpy as np
+
+from .alignment import plt
+from .cor import CenterOfRotation
+
+
+class CameraFocus(CenterOfRotation):
+    def find_distance(
+        self,
+        img_stack: np.ndarray,
+        img_pos: np.array,
+        metric="std",
+        roi_yxhw=None,
+        median_filt_shape=None,
+        padding_mode=None,
+        peak_fit_radius=1,
+        high_pass=None,
+        low_pass=None,
+    ):
+        """Find the focal distance of the camera system.
+
+        This routine computes the motor position that corresponds to having the
+        scintillator on the focal plain of the camera system.
+
+        Parameters
+        ----------
+        img_stack: numpy.ndarray
+            A stack of images at different distances.
+        img_pos: numpy.ndarray
+            Position of the images along the translation axis
+        metric: string, optional
+            The property, whose maximize occurs at the focal position.
+            Defaults to 'std' (standard deviation).
+            All options are: 'std' | 'grad' | 'psd'
+        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`.
+
+        Returns
+        -------
+        focus_pos: float
+            Estimated position of the focal plane of the camera system.
+        focus_ind: float
+            Image index of the estimated position of the focal plane of the camera system (starting from 1!).
+
+        Examples
+        --------
+        Given the focal stack associated to multiple positions of the camera
+        focus motor called `img_stack`, and the associated positions `img_pos`,
+        the following code computes the highest focus position:
+
+        >>> focus_calc = alignment.CameraFocus()
+        ... focus_pos, focus_ind = focus_calc.find_distance(img_stack, img_pos)
+
+        where `focus_pos` is the corresponding motor position, and `focus_ind`
+        is the associated image position (starting from 1).
+        """
+        self._check_img_stack_size(img_stack, 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)
+            peak_fit_radius = 1
+
+        num_imgs = img_stack.shape[0]
+        img_shape = img_stack.shape[-2:]
+        roi_yxhw = self._determine_roi(img_shape, roi_yxhw)
+
+        img_stack = self._prepare_image(
+            img_stack,
+            roi_yxhw=roi_yxhw,
+            median_filt_shape=median_filt_shape,
+            low_pass=low_pass,
+            high_pass=high_pass,
+        )
+
+        img_stds = np.std(img_stack, axis=(-2, -1)) / np.mean(img_stack, axis=(-2, -1))
+
+        # 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_ind, img_std_max = self.refine_max_position_1d(f_vals, return_vertex_val=True)
+        focus_ind += f_pos[1, :]
+
+        focus_pos = img_pos[0] + focus_step * focus_ind
+        focus_ind += 1
+
+        if self.verbose:
+            self.logger.info(
+                "Fitted focus motor position:",
+                focus_pos,
+                "and corresponding image position:",
+                focus_ind,
+            )
+            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")
+            plt.show(block=False)
+
+        return focus_pos, focus_ind
+
+    def _check_img_block_size(self, img_shape, regions_number, suggest_new_shape=True):
+        img_shape = np.array(img_shape)
+        new_shape = img_shape
+        if not len(img_shape) == 2:
+            raise ValueError(
+                "Images need to be square 2-dimensional and with shape multiple of the number of assigned regions.\n"
+                " Image shape: %s, regions number: %d" % (img_shape, regions_number)
+            )
+        if not (img_shape[0] == img_shape[1] and np.all((np.array(img_shape) % regions_number) == 0)):
+            new_shape = (img_shape // regions_number) * regions_number
+            new_shape = np.fmin(new_shape, new_shape.min())
+            message = (
+                "Images need to be square 2-dimensional and with shape multiple of the number of assigned regions.\n"
+                " Image shape: %s, regions number: %d. Cropping to image shape: %s"
+                % (img_shape, regions_number, new_shape)
+            )
+            if suggest_new_shape:
+                self.logger.info(message)
+            else:
+                raise ValueError(message)
+        return new_shape
+
+    @staticmethod
+    def _fit_plane(f_vals):
+        f_vals_half_shape = (np.array(f_vals.shape) - 1) / 2
+
+        fy = np.linspace(-f_vals_half_shape[-2], f_vals_half_shape[-2], f_vals.shape[-2])
+        fx = np.linspace(-f_vals_half_shape[-1], f_vals_half_shape[-1], f_vals.shape[-1])
+
+        fy, fx = np.meshgrid(fy, fx, indexing="ij")
+        coords = np.array([np.ones(f_vals.size), fy.flatten(), fx.flatten()])
+
+        return np.linalg.lstsq(coords.T, f_vals.flatten(), rcond=None)[0], fy, fx
+
+    def find_scintillator_tilt(
+        self,
+        img_stack: np.ndarray,
+        img_pos: np.array,
+        regions_number=4,
+        metric="std",
+        roi_yxhw=None,
+        median_filt_shape=None,
+        padding_mode=None,
+        peak_fit_radius=1,
+        high_pass=None,
+        low_pass=None,
+    ):
+        """Finds the scintillator tilt and focal distance of the camera system.
+
+        This routine computes the mounting tilt of the scintillator and the
+        motor position that corresponds to having the scintillator on the focal
+        plain of the camera system.
+
+        The input is supposed to be a stack of square images, whose sizes are
+        multiples of the `regions_number` parameter. If images with a different
+        size are passed, this function will crop the images. This also generates
+        a warning. To suppress the warning, it is suggested to specify a ROI
+        that satisfies those criteria (see examples).
+
+        The computed tilts `tilt_vh` are in unit-length per pixel-size. To
+        obtain the tilts it is necessary to divide by the pixel-size:
+
+        >>> tilt_vh_deg = np.rad2deg(np.arctan(tilt_vh / pixel_size))
+
+        The correction to be applied is:
+
+        >>> tilt_corr_vh_deg = - np.rad2deg(np.arctan(tilt_vh / pixel_size))
+
+        The legacy octave macros computed the approximation of these values in radians:
+
+        >>> tilt_corr_vh_rad = - tilt_vh / pixel_size
+
+        Note that `pixel_size` should be in the same unit scale as `img_pos`.
+
+        Parameters
+        ----------
+        img_stack: numpy.ndarray
+            A stack of images at different distances.
+        img_pos: numpy.ndarray
+            Position of the images along the translation axis
+        regions_number: int, optional
+            The number of regions to subdivide the image into, along each direction.
+            Defaults to 4.
+        metric: string, optional
+            The property, whose maximize occurs at the focal position.
+            Defaults to 'std' (standard deviation).
+            All options are: 'std' | 'grad' | 'psd'
+        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 -> auto-suggest correct size.
+        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`.
+
+        Returns
+        -------
+        focus_pos: float
+            Estimated position of the focal plane of the camera system.
+        focus_ind: float
+            Image index of the estimated position of the focal plane of the
+            camera system (starting from 1!).
+        tilts_vh: tuple(float, float)
+            Estimated scintillator tilts in the vertical and horizontal
+            direction respectively per unit-length per pixel-size.
+
+        Examples
+        --------
+        Given the focal stack associated to multiple positions of the camera
+        focus motor called `img_stack`, and the associated positions `img_pos`,
+        the following code computes the highest focus position:
+
+        >>> focus_calc = alignment.CameraFocus()
+        ... focus_pos, focus_ind, tilts_vh = focus_calc.find_scintillator_tilt(img_stack, img_pos)
+        ... tilt_corr_vh_deg = - np.rad2deg(np.arctan(tilt_vh / pixel_size))
+
+        or to keep compatibility with the old octave macros:
+
+        >>> tilt_corr_vh_rad = - tilt_vh / pixel_size
+
+        For non square images, or images with sizes that are not multiples of
+        the `regions_number` parameter, and no ROI is being passed, this function
+        will try to crop the image stack to the correct size.
+        If you want to remove the warning message, it is suggested to set a ROI
+        like the following:
+
+        >>> regions_number = 4
+        ... img_roi = (np.array(img_stack.shape[1:]) // regions_number) * regions_number
+        ... img_roi = np.fmin(img_roi, img_roi.min())
+        ... focus_calc = alignment.CameraFocus()
+        ... focus_pos, focus_ind, tilts_vh = focus_calc.find_scintillator_tilt(
+        ...     img_stack, img_pos, roi_yxhw=img_roi, regions_number=regions_number)
+        """
+        self._check_img_stack_size(img_stack, 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)
+            peak_fit_radius = 1
+
+        num_imgs = img_stack.shape[0]
+        img_shape = img_stack.shape[-2:]
+        if roi_yxhw is None:
+            # If no roi is being passed, we try to crop the images to the
+            # correct size, if needed
+            roi_yxhw = self._check_img_block_size(img_shape, regions_number, suggest_new_shape=True)
+            roi_yxhw = self._determine_roi(img_shape, roi_yxhw)
+        else:
+            # If a roi is being passed, and the images don't have the correct
+            # shape, we raise an error
+            roi_yxhw = self._determine_roi(img_shape, roi_yxhw)
+            self._check_img_block_size(roi_yxhw[2:], regions_number, suggest_new_shape=False)
+
+        img_stack = self._prepare_image(
+            img_stack,
+            roi_yxhw=roi_yxhw,
+            median_filt_shape=median_filt_shape,
+            low_pass=low_pass,
+            high_pass=high_pass,
+        )
+        img_shape = img_stack.shape[-2:]
+
+        block_size = np.array(img_shape) / regions_number
+        block_stack_size = np.array(
+            [num_imgs, regions_number, block_size[-2], regions_number, block_size[-1]],
+            dtype=np.intp,
+        )
+        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()
+
+        # 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)
+        focus_inds += f_pos[1, :]
+
+        focus_poss = img_pos[0] + focus_step * focus_inds
+
+        # Fitting the plane
+        focus_poss = np.reshape(focus_poss, [regions_number, regions_number])
+        coeffs, fy, fx = self._fit_plane(focus_poss)
+        focus_pos, tg_v, tg_h = coeffs
+
+        # The angular coefficient along x is the tilt around the y axis and vice-versa
+        tilts_vh = np.array([tg_h, tg_v]) / block_size
+
+        focus_ind = np.mean(focus_inds) + 1
+
+        if self.verbose:
+            self.logger.info(
+                "Fitted focus motor position:",
+                focus_pos,
+                "and corresponding image position:",
+                focus_ind,
+            )
+            self.logger.info("Fitted tilts (to be divided by pixel size, and converted to deg): (v, h) %s" % tilts_vh)
+            fig = plt.figure()
+            ax = fig.add_subplot(111, projection="3d")
+            self._add_plot_window(fig, ax=ax)
+            ax.plot_wireframe(fx, fy, focus_poss)
+            regions_half_shape = (regions_number - 1) / 2
+            base_points = np.linspace(-regions_half_shape, regions_half_shape, regions_number)
+            ax.plot(
+                np.zeros((regions_number,)),
+                base_points,
+                np.polyval([tg_v, focus_pos], base_points),
+                "C2",
+            )
+            ax.plot(
+                base_points,
+                np.zeros((regions_number,)),
+                np.polyval([tg_h, focus_pos], base_points),
+                "C2",
+            )
+            ax.scatter(0, 0, focus_pos, marker="o", c="C1")
+            ax.set_title("Images std")
+            plt.show(block=False)
+
+        return focus_pos, focus_ind, tilts_vh