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

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

@@ -1,183 +0,0 @@
-"""
-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/nabu/estimation/distortion.py

@@ -1,112 +0,0 @@
-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/nabu/estimation/focus.py

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