nabu 2024.1.0rc1__py3-none-any.whl → 2024.1.0rc3__py3-none-any.whl

doc/doc_config.py

@@ -0,0 +1,32 @@
+#!/usr/bin/env python
+
+from nabu.resources.nabu_config import nabu_config
+
+
+def generate(file_):
+    def write(content):
+        print(content, file=file_)
+    for section, values in nabu_config.items():
+        if section == "about":
+            continue
+        write("## %s\n" % section)
+        for key, val in values.items():
+            if val["type"] == "unsupported":
+                continue
+            write(val["help"] + "\n")
+            write(
+                "```ini\n%s = %s\n```"
+                % (key, val["default"])
+            )
+
+
+
+if __name__ == "__main__":
+
+    import sys, os
+    print(os.path.abspath(__file__))
+    exit(0)
+
+    fname = "/tmp/test.md"
+    with open(fname, "w") as f:
+        generate(f)

nabu/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "2024.1.0-rc1"
+__version__ = "2024.1.0-rc3"
 __nabu_modules__ = [
     "app",
     "cuda",

nabu/app/bootstrap_stitching.py

@@ -43,7 +43,7 @@ def guess_tomo_objects(my_str: str) -> tuple:
 def bootstrap_stitching():
     args = parse_params_values(
         BootstrapStitchingConfig,
-        parser_description="Initialize a nabu configuration file",
+        parser_description="Initialize a 'nabu-stitching' configuration file",
     )
 
     prefilled_values = {}

nabu/app/cli_configs.py

@@ -329,6 +329,11 @@ StitchingConfig = {
         "help": "Logging level. Can be 'debug', 'info', 'warning', 'error'. Default is 'info'.",
         "default": "info",
     },
+    "--only-create-master-file": {
+        "help": "Will create the master file with all sub files (volumes or scans). It expects the processing to be finished. It can happen if all slurm job have been submitted but you've been kicked out of the cluster of if you need to relaunch manually some failling job slurm for any reason",
+        "default": False,
+        "action": "store_true",
+    },
 }
 
 # Default configuration for "stitching-bootstrap" command

nabu/app/composite_cor.py

@@ -5,8 +5,9 @@ import numpy as np
 import re
 
 from nabu.resources.dataset_analyzer import HDF5DatasetAnalyzer
-from nabu.pipeline.estimators import CompositeCOREstimator
+from nabu.pipeline.estimators import CompositeCOREstimator, estimate_cor
 from nabu.resources.nxflatfield import update_dataset_info_flats_darks
+from nabu.resources.utils import extract_parameters
 from nxtomo.application.nxtomo import NXtomo
 from .. import version
 from .cli_configs import CompositeCorConfig
@@ -84,15 +85,27 @@ def composite_cor_entry_point(args_dict):
         dataset_info = HDF5DatasetAnalyzer(nexus_name, extra_options={"h5_entry": args.entry_name})
         update_dataset_info_flats_darks(dataset_info, flatfield_mode=1)
 
-        if "near_pos" not in args.cor_options:
-            scan = NXtomo()
-            scan.load(file_path=nexus_name, data_path=args.entry_name)
-            estimated_near = scan.instrument.detector.estimated_cor_from_motor
-
-            cor_options = args.cor_options + f" ; near_pos = {estimated_near} "
-
-        else:
-            cor_options = args.cor_options
+        ### JL start ###
+        # Extract CoR parameters from configuration file
+        try:
+            cor_options = extract_parameters(args.cor_options, sep=";")
+        except Exception as exc:
+            msg = "Could not extract parameters from cor_options: %s" % (str(exc))
+            raise ValueError(msg)
+        ### JL end ###
+
+        # JL start ###
+        #: next bit will be done in estimate
+        # if "near_pos" not in args.cor_options:
+        #    scan = NXtomo()
+        #    scan.load(file_path=nexus_name, data_path=args.entry_name)
+        #    estimated_near = scan.instrument.detector.estimated_cor_from_motor
+        #
+        #    cor_options = args.cor_options + f" ; near_pos = {estimated_near} "
+        #
+        # else:
+        #    cor_options = args.cor_options
+        ### JL end ###
 
         cor_finder = CompositeCOREstimator(
             dataset_info,

nabu/app/multicor.py

@@ -1,5 +1,4 @@
 from os import remove
-from typing import overload
 import numpy as np
 from .. import version
 from .reconstruct import get_reconstructor

nabu/app/reduce_dark_flat.py

@@ -10,7 +10,7 @@ from .. import version
 from tomoscan.framereducer.method import ReduceMethod
 from tomoscan.scanbase import TomoScanBase
 from tomoscan.esrf.scan.edfscan import EDFTomoScan
-from tomoscan.scanfactory import ScanFactory
+from tomoscan.factory import Factory
 from silx.io.url import DataUrl
 
 
@@ -153,6 +153,9 @@ def reduce_dark_flat(
 
 
 def main(argv=None):
+    """
+    Compute reduce dark(s) and flat(s) of a dataset
+    """
     if argv is None:
         argv = sys.argv[1:]
 
@@ -163,7 +166,7 @@ def main(argv=None):
         user_args=argv,
     )
 
-    scan = ScanFactory.create_scan_object(args["dataset"], entry=args["entry"])
+    scan = Factory.create_scan_object(args["dataset"], entry=args["entry"])
     exit(
         reduce_dark_flat(
             scan=scan,

nabu/app/stitching.py

@@ -31,7 +31,21 @@ def main():
 
     stitching_config = dict_to_config_obj(conf_dict)
     stitching_config.settle_inputs()
-    if stitching_config.slurm_config.partition in (None, ""):
+    if args["only_create_master_file"]:
+        # option to ease creation of the master in the following cases:
+        # * user has submitted all the job but has been quicked out of the cluster
+        # * only a few slurm job for some random version (cluster update...) and user want to retriger only those job and process the aggragation only. On those cases no need to redo it all.
+        tomo_objs = []
+        for _, sub_config in split_stitching_configuration_to_slurm_job(stitching_config, yield_configuration=True):
+            tomo_objs.append(sub_config.get_output_object().get_identifier().to_str())
+
+        post_processing = StitchingPostProcAggregation(
+            existing_objs_ids=tomo_objs,
+            stitching_config=stitching_config,
+        )
+        post_processing.process()
+
+    elif stitching_config.slurm_config.partition in (None, ""):
         # case 1: run locally
         _logger.info(f"run stitching locally with {stitching_config}")
 
@@ -60,7 +74,7 @@ def main():
         # 2.2 wait for future to be done and concatenate the result
         post_processing = StitchingPostProcAggregation(
             futures=futures,
-            stitching_config=stitching_config.to_dict(),
+            stitching_config=stitching_config,
         )
         post_processing.process()
 

nabu/estimation/cor.py

@@ -133,7 +133,9 @@ class CenterOfRotation(AlignmentBase):
 
         if isinstance(self.cor_options.get("near_pos", None), (int, float)):
             near_pos = self.cor_options["near_pos"]
-            if np.abs(near_pos - estimated_cor) / near_pos > 0.2:
+            if (
+                np.abs(near_pos - estimated_cor) / near_pos > 0.2
+            ):  # For comparison, near_pos is RELATIVE (as estimated_cor is).
                 validity_check_result = cor_result_validity["questionable"]
             else:
                 validity_check_result = cor_result_validity["sound"]
@@ -266,8 +268,8 @@ class CenterOfRotationSlidingWindow(CenterOfRotation):
         )
         img_shape = img_2.shape
 
-        near_pos = self.cor_options.get("near_pos", "ignore")
-        if near_pos == "ignore":
+        near_pos = self.cor_options.get("near_pos", None)
+        if near_pos is None:
             if window_width is None:
                 if side.lower() == "center":
                     window_width = round(img_shape[-1] / 4.0 * 3.0)
@@ -280,7 +282,8 @@ class CenterOfRotationSlidingWindow(CenterOfRotation):
             # number of pixels where the window will "slide".
             n = img_shape[-1] - window_width
         else:
-            offset = min(img_shape[-1] - near_pos, near_pos)  # distance to closest edge.
+            abs_pos = near_pos + img_shape[-1] // 2
+            offset = min(img_shape[-1] - abs_pos, abs_pos)  # distance to closest edge.
 
             window_fraction = 0.8  # Hard-coded ?
             window_shift = int(np.floor(offset * window_fraction))
@@ -288,7 +291,7 @@ class CenterOfRotationSlidingWindow(CenterOfRotation):
 
             sliding_shift = int(np.floor(offset * (1 - window_fraction))) - 1
             n = 2 * sliding_shift + 1
-            win_1_start_seed = near_pos - window_shift - sliding_shift
+            win_1_start_seed = abs_pos - window_shift - sliding_shift
 
         if side.lower() == "right":
             win_2_start = 0
@@ -904,39 +907,19 @@ class CenterOfRotationFourierAngles(CenterOfRotation):
     """
 
     _default_cor_options = {
-        "crop_around_cor": True,
+        "crop_around_cor": False,
+        "side": "center",
         "near_pos": None,
+        "near_std": 100,
         "near_width": 20,
-        "near_weight": 0.1,
         "near_shape": "tukey",
-        "near_std": 100,
+        "near_weight": 0.1,
         "near_alpha": 0.5,
         "shift_sino": True,
-        "use_paganin": True,
         "near_step": 0.5,
-        "side": "center",
         "refine": False,
     }
 
-    # def __hash__(self):
-    #    if self.cor_options["near_shape"] == "tukey":
-    #        cor_shape = (
-    #            self.cor_options["near_shape"],
-    #            self.cor_options["near_std"],
-    #            self.cor_options["near_alpha"],
-    #        )
-    #    else:
-    #        cor_shape = (self.cor_options["near_shape"], self.cor_options["near_std"])
-    #    return hash(
-    #        (
-    #            self.cor_options["use_paganin"],
-    #            self.cor_options["crop_around_cor"],
-    #            self.cor_options["near_weight"],
-    #            self.cor_options["near_width"],
-    #            cor_shape,
-    #        )
-    #    )
-
     def _freq_radio(self, sinos, ifrom, ito):
         size = (sinos.shape[0] + sinos.shape[0] % 2) // 2
         fs = np.empty((size, sinos.shape[1]))
@@ -972,11 +955,11 @@ class CenterOfRotationFourierAngles(CenterOfRotation):
         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, near_pos, near_std):
+    def _px(self, detector_width, abs_pos, near_std):
         sym_range = None
-        if near_pos is not None:
+        if abs_pos is not None:
             if self.cor_options["crop_around_cor"]:
-                sym_range = int(near_pos - near_std * 2), int(near_pos + near_std * 2)
+                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:
@@ -1012,7 +995,7 @@ class CenterOfRotationFourierAngles(CenterOfRotation):
 
         for j, x in enumerate(px):
             i = int(np.floor(x))
-            if x - i > 0.4:  # Specific to near_step = 0.5?
+            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:
@@ -1022,24 +1005,36 @@ class CenterOfRotationFourierAngles(CenterOfRotation):
                 f_coef[j] = np.sum(np.abs(f_left - f_right))
         return f_coef
 
-    def _cor_correlation(self, px, near_pos, near_std):
-        if near_pos is not None:
+    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((near_pos, near_std, -weight, 1), px)
+                coef = self.sinlet((abs_pos, near_std, -weight, 1), px)
             elif signal == "gaussian":
-                coef = self.gaussian((near_pos, near_std, -weight, 1), px)
+                coef = self.gaussian((abs_pos, near_std, -weight, 1), px)
             elif signal == "tukey":
-                coef = self.tukey((near_pos, near_std * 2, alpha, -weight, 1), px)
+                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):
+    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]
 
@@ -1048,28 +1043,38 @@ class CenterOfRotationFourierAngles(CenterOfRotation):
             self.logger.warning("Not enough angles, estimator skipped")
             return None
 
-        # self.cor_options = self._default_cor_options.update(self.cor_options)
-        # Convert near_pos (which is relative) to absolute.
-        near_pos = self.cor_options.get("near_pos")
+        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 == "ignore":
+        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.")
-            near_pos = detector_width // 2
+            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 near_pos is not None:
+        if abs_pos is not None:
             near_std = self.cor_options["near_std"]
 
-        px = self._px(detector_width, near_pos, 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, near_pos, near_std)
+        coef_p = self._cor_correlation(px, abs_pos, near_std)
         coef = coef_f * coef_p
 
         if len(px) > 0:
@@ -1090,12 +1095,21 @@ class CenterOfRotationFourierAngles(CenterOfRotation):
 class CenterOfRotationOctaveAccurate(AlignmentBase):
     """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 other COR estimators (sliding, growing...)
+    The Nabu standard `find_shift` has the same API as the other COR estimators (sliding, growing...)
 
     The class inherits directly from AlignmentBase.
     """
 
-    def cut(self, im, nrows, ncols, new_center_row=None, new_center_col=None):
+    _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
         NO CHECKING of validity indices sub-matrix!
@@ -1143,7 +1157,7 @@ class CenterOfRotationOctaveAccurate(AlignmentBase):
 
         return im[rb:re, cb:ce]
 
-    def checkifpart(self, rapp, rapp_hist):
+    def _checkifpart(self, rapp, rapp_hist):
         res = 0
         for k in range(rapp_hist.shape[0]):
             if np.allclose(rapp, rapp_hist[k, :]):
@@ -1151,7 +1165,7 @@ class CenterOfRotationOctaveAccurate(AlignmentBase):
                 return res
         return res
 
-    def interpolate(self, input, shift, mode="mean", interpolation_method="linear"):
+    def _interpolate(self, input, shift, mode="mean", interpolation_method="linear"):
         """Applies to the input a translation by a vector `shift`. Based on
         `scipy.ndimage.affine_transform` function.
         JL: This Octave function was initially used in the refine clause of the local_correlation (Octave find_shift).
@@ -1218,7 +1232,7 @@ class CenterOfRotationOctaveAccurate(AlignmentBase):
 
         return affine_transform(input, matrix, mode=mode, order=order)
 
-    def local_correlation(
+    def _local_correlation(
         self,
         z1,
         z2,
@@ -1227,7 +1241,6 @@ class CenterOfRotationOctaveAccurate(AlignmentBase):
         refine=None,
         pmcc=False,
         normalize=True,
-        verbose=False,
     ):
         """Returns the 2D shift in pixels between two images.
         It looks for a local optimum around the initial shift cor_estimate
@@ -1261,8 +1274,6 @@ class CenterOfRotationOctaveAccurate(AlignmentBase):
         normalize: Boolean (default is True)
             Set mean of each image to 1 if True.
 
-        verbose: Boolean (default is False)
-
         Returns
         -------
         c = [row,column] (or [NaN,NaN] if unsuccessful.)
@@ -1361,7 +1372,7 @@ class CenterOfRotationOctaveAccurate(AlignmentBase):
                     if pmcc:
                         z2p = z2[z2beg[0] - k : z2end[0] - k, z2beg[1] - l : z2end[1] - l].flatten()
                         std_z2p = z2p.std()
-                        cc[k, l] = -np.cov(z1p, z2p) / (std_z1p * std_z2p)
+                        cc[k, l] = -np.cov(z1p, z2p, rowvar=True)[1, 0] / (std_z1p * std_z2p)
                     else:
                         if normalize == 2:
                             z2p = z2[z2beg[0] - k : z2end[0] - k, z2beg[1] - l : z2end[1] - l].flatten()
@@ -1388,25 +1399,25 @@ class CenterOfRotationOctaveAccurate(AlignmentBase):
             if not shiftfound:
                 cor_estimate = c
                 # Check that new shift estimate was not already done (avoid eternal loop)
-                if self.checkifpart(cor_estimate, rapp_hist):
-                    if verbose:
+                if self._checkifpart(cor_estimate, rapp_hist):
+                    if self.verbose:
                         self.logger.info(f"Stuck in loop?")
                     refine = True
                     shiftfound = True
                     c = np.array([np.nan, np.nan])
                 else:
                     rapp_hist.append(cor_estimate)
-                    if verbose:
+                    if self.verbose:
                         self.logger.info(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 verbose:
+                        if self.verbose:
                             self.logger.info(f"Edge of image reached")
                         refine = False
                         shiftfound = True
                         c = np.array([np.nan, np.nan])
             elif len(rapp_hist) > 0:
-                if verbose:
+                if self.verbose:
                     self.logger.info("\n")
 
         ####################################
@@ -1450,16 +1461,86 @@ class CenterOfRotationOctaveAccurate(AlignmentBase):
         roi_yxhw=None,
         median_filt_shape=None,
         padding_mode=None,
-        high_pass=None,
         low_pass=0.01,
-        limz=0.5,  # maximum vertical drift before warning
+        high_pass=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={limz}."
+            f"Estimation of the COR with following options: high_pass={high_pass}, low_pass={low_pass}, limz={self.cor_options['limz']}."
         )
-        # Retrieve cor_options
-        # self._set_cor_options(cor_options)
-        # self.logger.info(f"cor_options are :{self.cor_options}")
 
         self._check_img_pair_sizes(img_1, img_2)
 
@@ -1491,7 +1572,7 @@ 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 * limz:
+        if np.abs(shift[0]) > 10 * self.cor_options["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.")
@@ -1502,20 +1583,35 @@ class CenterOfRotationOctaveAccurate(AlignmentBase):
         cutsize = img_shape[1] // 2
         oldshift = np.round(shift).astype(int)
         if (img_shape[0] > cutsize) or (img_shape[1] > cutsize):
-            im0 = self.cut(img_1, min(img_shape[0], cutsize), min(img_shape[1], cutsize))
-            im1 = self.cut(
+            im0 = self._cut(img_1, min(img_shape[0], cutsize), min(img_shape[1], cutsize))
+            im1 = self._cut(
                 np.roll(img_2, oldshift, axis=(0, 1)), min(img_shape[0], cutsize), min(img_shape[1], cutsize)
             )
-            shift = oldshift + self.local_correlation(im0, im1)
+            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"],
+            )
         else:
-            shift = self.local_correlation(img_1, img_2, [], cor_estimate=oldshift)
+            shift = self._local_correlation(
+                img_1,
+                img_2,
+                maxsize=self.cor_options["maxsize"],
+                cor_estimate=oldshift,
+                refine=self.cor_options["refine"],
+                pmcc=self.cor_options["pmcc"],
+                normalize=self.cor_options["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!!!")
 
         offset = shift[1] / 2
 
-        if np.abs(shift[0]) > limz:
+        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.")