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

build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/nabu/stitching/utils.py

@@ -1,563 +0,0 @@
-from distutils.version import StrictVersion
-from typing import Optional, Union
-import logging
-import functools
-import numpy
-from scipy.ndimage import affine_transform
-from tomoscan.scanbase import TomoScanBase
-from tomoscan.volumebase import VolumeBase
-from nxtomo.utils.transformation import build_matrix, UDDetTransformation
-from silx.utils.enum import Enum as _Enum
-from scipy.fft import rfftn as local_fftn
-from scipy.fft import irfftn as local_ifftn
-from silx.utils.enum import Enum as _Enum
-from nxtomo.utils.transformation import build_matrix, UDDetTransformation
-from tomoscan.scanbase import TomoScanBase
-from .overlap import OverlapStitchingStrategy, ZStichOverlapKernel
-from .alignment import AlignmentAxis1, AlignmentAxis2, PaddedRawData
-from ..misc import fourier_filters
-from ..estimation.alignment import AlignmentBase
-from ..resources.dataset_analyzer import HDF5DatasetAnalyzer
-from ..resources.nxflatfield import update_dataset_info_flats_darks
-
-try:
-    import itk
-except ImportError:
-    has_itk = False
-else:
-    has_itk = True
-
-_logger = logging.getLogger(__name__)
-
-
-try:
-    from skimage.registration import phase_cross_correlation
-except ImportError:
-    _logger.warning(
-        "Unable to load skimage. Please install it if you want to use it for finding shifts from `find_relative_shifts`"
-    )
-    __has_sk_phase_correlation__ = False
-else:
-    __has_sk_phase_correlation__ = True
-
-
-class ShiftAlgorithm(_Enum):
-    """All generic shift search algorithm"""
-
-    NABU_FFT = "nabu-fft"
-    SKIMAGE = "skimage"
-    ITK_IMG_REG_V4 = "itk-img-reg-v4"
-    NONE = "None"
-
-    # In the case of shift search on radio along axis 2 (or axis x in image space) we can benefit from the existing
-    # nabu algorithm such as growing-window or sliding-window
-    CENTERED = "centered"
-    GLOBAL = "global"
-    SLIDING_WINDOW = "sliding-window"
-    GROWING_WINDOW = "growing-window"
-    SINO_COARSE_TO_FINE = "sino-coarse-to-fine"
-    COMPOSITE_COARSE_TO_FINE = "composite-coarse-to-fine"
-
-    @classmethod
-    def from_value(cls, value):
-        if value in ("", None):
-            return ShiftAlgorithm.NONE
-        else:
-            return super().from_value(value=value)
-
-
-def test_overlap_stitching_strategy(overlap_1, overlap_2, stitching_strategies):
-    """
-    stitch the two ovrelap with all the requested strategies.
-    Return a dictionary with stitching strategy as key and a result dict as value.
-    result dict keys are: 'weights_overlap_1', 'weights_overlap_2', 'stiching'
-    """
-    res = {}
-    for strategy in stitching_strategies:
-        s = OverlapStitchingStrategy.from_value(strategy)
-        stitcher = ZStichOverlapKernel(
-            stitching_strategy=s,
-            frame_width=overlap_1.shape[1],
-        )
-        stiched_overlap, w1, w2 = stitcher.stitch(overlap_1, overlap_2, check_input=True)
-        res[s.value] = {
-            "stitching": stiched_overlap,
-            "weights_overlap_1": w1,
-            "weights_overlap_2": w2,
-        }
-    return res
-
-
-def find_frame_relative_shifts(
-    overlap_upper_frame: numpy.ndarray,
-    overlap_lower_frame: numpy.ndarray,
-    estimated_shifts,
-    x_cross_correlation_function=None,
-    y_cross_correlation_function=None,
-    x_shifts_params: Optional[dict] = None,
-    y_shifts_params: Optional[dict] = None,
-):
-    from nabu.stitching.config import (
-        KEY_WINDOW_SIZE,
-        KEY_LOW_PASS_FILTER,
-        KEY_HIGH_PASS_FILTER,
-    )  # avoid cyclic import
-
-    x_cross_correlation_function = ShiftAlgorithm.from_value(x_cross_correlation_function)
-    y_cross_correlation_function = ShiftAlgorithm.from_value(y_cross_correlation_function)
-
-    if x_shifts_params is None:
-        x_shifts_params = {}
-
-    if y_shifts_params is None:
-        y_shifts_params = {}
-
-    # apply filtering if any
-    def _str_to_int(value):
-        if isinstance(value, str):
-            value = value.lstrip("'").lstrip('"')
-            value = value.rstrip("'").rstrip('"')
-            value = int(value)
-        return value
-
-    low_pass = _str_to_int(x_shifts_params.get(KEY_LOW_PASS_FILTER, y_shifts_params.get(KEY_LOW_PASS_FILTER, None)))
-    high_pass = _str_to_int(x_shifts_params.get(KEY_HIGH_PASS_FILTER, y_shifts_params.get(KEY_HIGH_PASS_FILTER, None)))
-    if high_pass is None and low_pass is None:
-        pass
-    else:
-        if low_pass is None:
-            low_pass = 1
-        if high_pass is None:
-            high_pass = 20
-        _logger.info(f"filter image for shift search (low_pass={low_pass}, high_pass={high_pass})")
-        img_filter = fourier_filters.get_bandpass_filter(
-            overlap_upper_frame.shape[-2:],
-            cutoff_lowpass=low_pass,
-            cutoff_highpass=high_pass,
-            use_rfft=True,
-            data_type=overlap_upper_frame.dtype,
-        )
-        overlap_upper_frame = local_ifftn(
-            local_fftn(overlap_upper_frame, axes=(-2, -1)) * img_filter, axes=(-2, -1)
-        ).real
-        overlap_lower_frame = local_ifftn(
-            local_fftn(overlap_lower_frame, axes=(-2, -1)) * img_filter, axes=(-2, -1)
-        ).real
-
-    # compute shifts
-    initial_shifts = numpy.array(estimated_shifts).copy()
-    extra_shifts = numpy.array([0.0, 0.0])
-
-    def skimage_proxy(img1, img2):
-        if not __has_sk_phase_correlation__:
-            raise ValueError("scikit-image not installed. Cannot do phase correlation from it")
-        else:
-            found_shift, _, _ = phase_cross_correlation(reference_image=img1, moving_image=img2, space="real")
-            return -found_shift
-
-    shift_methods = {
-        ShiftAlgorithm.NABU_FFT: functools.partial(
-            find_shift_correlate, img1=overlap_upper_frame, img2=overlap_lower_frame
-        ),
-        ShiftAlgorithm.SKIMAGE: functools.partial(skimage_proxy, img1=overlap_upper_frame, img2=overlap_lower_frame),
-        ShiftAlgorithm.ITK_IMG_REG_V4: functools.partial(
-            find_shift_with_itk, img1=overlap_upper_frame, img2=overlap_lower_frame
-        ),
-        ShiftAlgorithm.NONE: functools.partial(lambda: (0.0, 0.0)),
-    }
-
-    res_algo = {}
-    for shift_alg in set((x_cross_correlation_function, y_cross_correlation_function)):
-        if shift_alg not in shift_methods:
-            raise ValueError(f"requested image alignment function not handled ({shift_alg})")
-        try:
-            res_algo[shift_alg] = shift_methods[shift_alg]()
-        except Exception as e:
-            _logger.error(f"Failed to find shift from {shift_alg.value}. Error is {e}")
-            res_algo[shift_alg] = (0, 0)
-
-    extra_shifts = (
-        res_algo[y_cross_correlation_function][0],
-        res_algo[x_cross_correlation_function][1],
-    )
-
-    final_rel_shifts = numpy.array(extra_shifts) + initial_shifts
-    return tuple([int(shift) for shift in final_rel_shifts])
-
-
-def find_volumes_relative_shifts(
-    upper_volume: VolumeBase,
-    lower_volume: VolumeBase,
-    estimated_shifts,
-    dim_axis_1: int,
-    dtype,
-    flip_ud_upper_frame: bool = False,
-    flip_ud_lower_frame: bool = False,
-    slice_for_shift: Union[int, str] = "middle",
-    x_cross_correlation_function=None,
-    y_cross_correlation_function=None,
-    x_shifts_params: Optional[dict] = None,
-    y_shifts_params: Optional[dict] = None,
-    alignment_axis_2="center",
-    alignment_axis_1="center",
-):
-    """
-
-    :param int dim_axis_1: axis 1 dimension (to handle axis 1 alignment)
-    """
-    if y_shifts_params is None:
-        y_shifts_params = {}
-
-    if x_shifts_params is None:
-        x_shifts_params = {}
-
-    alignment_axis_2 = AlignmentAxis2.from_value(alignment_axis_2)
-    alignment_axis_1 = AlignmentAxis1.from_value(alignment_axis_1)
-    assert dim_axis_1 > 0, "dim_axis_1 <= 0"
-
-    if isinstance(slice_for_shift, str):
-        if slice_for_shift == "first":
-            slice_for_shift = 0
-        elif slice_for_shift == "last":
-            slice_for_shift = dim_axis_1
-        elif slice_for_shift == "middle":
-            slice_for_shift = dim_axis_1 // 2
-        else:
-            raise ValueError("invalid slice provided to search shift", slice_for_shift)
-
-    def get_slice_along_axis_1(volume: VolumeBase, index: int):
-        assert isinstance(index, int), f"index should be an int, {type(index)} provided"
-        volume_shape = volume.get_volume_shape()
-        if alignment_axis_1 is AlignmentAxis1.BACK:
-            front_empty_width = dim_axis_1 - volume_shape[1]
-            if index < front_empty_width:
-                return PaddedRawData.get_empty_frame(shape=(volume_shape[0], volume_shape[2]), dtype=dtype)
-            else:
-                return volume.get_slice(index=index - front_empty_width, axis=1)
-        elif alignment_axis_1 is AlignmentAxis1.FRONT:
-            if index >= volume_shape[1]:
-                return PaddedRawData.get_empty_frame(shape=(volume_shape[0], volume_shape[2]), dtype=dtype)
-            else:
-                return volume.get_slice(index=index, axis=1)
-        elif alignment_axis_1 is AlignmentAxis1.CENTER:
-            front_empty_width = (dim_axis_1 - volume_shape[1]) // 2
-            back_empty_width = dim_axis_1 - front_empty_width
-            if index < front_empty_width or index > back_empty_width:
-                return PaddedRawData.get_empty_frame(shape=(volume_shape[0], volume_shape[2]), dtype=dtype)
-            else:
-                return volume.get_slice(index=index - front_empty_width, axis=1)
-        else:
-            raise TypeError(f"unmanaged alignment mode {alignment_axis_1.value}")
-
-    upper_frame = get_slice_along_axis_1(upper_volume, index=slice_for_shift)
-    lower_frame = get_slice_along_axis_1(lower_volume, index=slice_for_shift)
-    if flip_ud_upper_frame:
-        upper_frame = numpy.flipud(upper_frame.copy())
-    if flip_ud_lower_frame:
-        lower_frame = numpy.flipud(lower_frame.copy())
-
-    from nabu.stitching.config import KEY_WINDOW_SIZE  # avoid cyclic import
-
-    w_window_size = int(y_shifts_params.get(KEY_WINDOW_SIZE, 400))
-    start_overlap = max(estimated_shifts[0] // 2 - w_window_size // 2, 0)
-    end_overlap = min(estimated_shifts[0] // 2 + w_window_size // 2, min(upper_frame.shape[0], lower_frame.shape[0]))
-
-    if start_overlap == 0:
-        overlap_upper_frame = upper_frame[-end_overlap:]
-    else:
-        overlap_upper_frame = upper_frame[-end_overlap:-start_overlap]
-    overlap_lower_frame = lower_frame[start_overlap:end_overlap]
-
-    # align if necessary
-    if overlap_upper_frame.shape[1] != overlap_lower_frame.shape[1]:
-        overlap_frame_width = min(overlap_upper_frame.shape[1], overlap_lower_frame.shape[1])
-        if alignment_axis_2 is AlignmentAxis2.CENTER:
-            upper_frame_left_pos = overlap_upper_frame.shape[1] // 2 - overlap_frame_width // 2
-            upper_frame_right_pos = upper_frame_left_pos + overlap_frame_width
-            overlap_upper_frame = overlap_upper_frame[:, upper_frame_left_pos:upper_frame_right_pos]
-
-            lower_frame_left_pos = overlap_lower_frame.shape[1] // 2 - overlap_frame_width // 2
-            lower_frame_right_pos = lower_frame_left_pos + overlap_frame_width
-            overlap_lower_frame = overlap_lower_frame[:, lower_frame_left_pos:lower_frame_right_pos]
-        elif alignment_axis_2 is AlignmentAxis2.LEFT:
-            overlap_upper_frame = overlap_upper_frame[:, :overlap_frame_width]
-            overlap_lower_frame = overlap_lower_frame[:, :overlap_frame_width]
-        elif alignment_axis_2 is AlignmentAxis2.RIGTH:
-            overlap_upper_frame = overlap_upper_frame[:, -overlap_frame_width:]
-            overlap_lower_frame = overlap_lower_frame[:, -overlap_frame_width:]
-        else:
-            raise ValueError(f"Alignement {alignment_axis_2.value} is not handled")
-
-    if not overlap_upper_frame.shape == overlap_lower_frame.shape:
-        raise ValueError(f"Fail to get consistant overlap ({overlap_upper_frame.shape} vs {overlap_lower_frame.shape})")
-
-    return find_frame_relative_shifts(
-        overlap_upper_frame=overlap_upper_frame,
-        overlap_lower_frame=overlap_lower_frame,
-        estimated_shifts=estimated_shifts,
-        x_cross_correlation_function=x_cross_correlation_function,
-        y_cross_correlation_function=y_cross_correlation_function,
-        x_shifts_params=x_shifts_params,
-        y_shifts_params=y_shifts_params,
-    )
-
-
-from nabu.pipeline.estimators import estimate_cor
-
-
-def find_projections_relative_shifts(
-    upper_scan: TomoScanBase,
-    lower_scan: TomoScanBase,
-    estimated_shifts,
-    flip_ud_upper_frame: bool = False,
-    flip_ud_lower_frame: bool = False,
-    projection_for_shift: Union[int, str] = "middle",
-    invert_order: bool = False,
-    x_cross_correlation_function=None,
-    y_cross_correlation_function=None,
-    x_shifts_params: Optional[dict] = None,
-    y_shifts_params: Optional[dict] = None,
-) -> tuple:
-    """
-    deduce the relative shift between the two scans.
-    Expected behavior:
-    * compute expected overlap area from z_translations and (sample) pixel size
-    * call an (optional) cross correlation function from the overlap area to compute the x shift and polish the y shift from `projection_for_shift`
-
-    :param TomoScanBase scan_0:
-    :param TomoScanBase scan_1:
-    :param int axis_0_overlap_px: overlap between the two scans in pixel
-    :param Union[int,str] projection_for_shift: index fo the projection to use (in projection space or in scan space ?. For now in projection) or str. If str must be in (`middle`, `first`, `last`)
-    :param str x_cross_correlation_function: optional method to refine x shift from computing cross correlation. For now valid values are: ("skimage", "nabu-fft")
-    :param str y_cross_correlation_function: optional method to refine y shift from computing cross correlation. For now valid values are: ("skimage", "nabu-fft")
-    :param int minimal_overlap_area_for_cross_correlation: if first approximated overlap shift found from z_translation is lower than this value will fall back on taking the full image for the cross correlation and log a warning
-    :param bool invert_order: are projections inverted between the two scans (case if rotation angle are inverted)
-    :param tuple estimated_shifts: 'a priori' shift estimation
-    :return: relative shift of scan_1 with scan_0 as reference: (y_shift, x_shift)
-    :rtype: tuple
-
-    :warning: this function will flip left-right and up-down frames by default. So it will return shift according to this information
-    """
-    if x_shifts_params is None:
-        x_shifts_params = {}
-    if y_shifts_params is None:
-        y_shifts_params = {}
-    if estimated_shifts[0] < 0:
-        raise ValueError("y_overlap_px is expected to be stricktly positive")
-
-    x_cross_correlation_function = ShiftAlgorithm.from_value(x_cross_correlation_function)
-    y_cross_correlation_function = ShiftAlgorithm.from_value(y_cross_correlation_function)
-
-    # { handle specific use case (finding shift on scan) - when using nabu COR algorithms (for axis 2)
-    if x_cross_correlation_function in (
-        ShiftAlgorithm.SINO_COARSE_TO_FINE,
-        ShiftAlgorithm.COMPOSITE_COARSE_TO_FINE,
-        ShiftAlgorithm.CENTERED,
-        ShiftAlgorithm.GLOBAL,
-        ShiftAlgorithm.GROWING_WINDOW,
-        ShiftAlgorithm.SLIDING_WINDOW,
-    ):
-        cor_options = x_shifts_params.copy()
-        cor_options.pop("img_reg_method", None)
-        # remove all none numeric options because estimate_cor will call 'literal_eval' on them
-
-        upper_scan_dataset_info = HDF5DatasetAnalyzer(
-            location=upper_scan.master_file, extra_options={"hdf5_entry": upper_scan.entry}
-        )
-        update_dataset_info_flats_darks(upper_scan_dataset_info, flatfield_mode=1)
-
-        upper_scan_pos = estimate_cor(
-            method=x_cross_correlation_function.value,
-            dataset_info=upper_scan_dataset_info,
-            cor_options=cor_options,
-        )
-        lower_scan_dataset_info = HDF5DatasetAnalyzer(
-            location=lower_scan.master_file, extra_options={"hdf5_entry": lower_scan.entry}
-        )
-        update_dataset_info_flats_darks(lower_scan_dataset_info, flatfield_mode=1)
-        lower_scan_pos = estimate_cor(
-            method=x_cross_correlation_function.value,
-            dataset_info=lower_scan_dataset_info,
-            cor_options=cor_options,
-        )
-
-        estimated_shifts = tuple(
-            [
-                estimated_shifts[0],
-                (lower_scan_pos - upper_scan_pos),
-            ]
-        )
-        x_cross_correlation_function = ShiftAlgorithm.NONE
-
-    # } else we will compute shift from the flat projections
-
-    def get_flat_fielded_proj(
-        scan: TomoScanBase, proj_index: int, reverse: bool, transformation_matrix: Optional[numpy.ndarray]
-    ):
-        first_proj_idx = sorted(lower_scan.projections.keys(), reverse=reverse)[proj_index]
-        ff = scan.flat_field_correction(
-            (scan.projections[first_proj_idx],),
-            (first_proj_idx,),
-        )[0]
-        assert ff.ndim == 2, f"expects a single 2D frame. Get something with {ff.ndim} dimensions"
-        if transformation_matrix is not None:
-            assert (
-                transformation_matrix.ndim == 2
-            ), f"expects a 2D transformation matrix. Get a {transformation_matrix.ndim} D"
-            if numpy.isclose(transformation_matrix[2, 2], -1):
-                transformation_matrix[2, :] = 0
-                transformation_matrix[0, 2] = 0
-                transformation_matrix[2, 2] = 1
-                ff = numpy.flipud(ff)
-        return ff
-
-    if isinstance(projection_for_shift, str):
-        if projection_for_shift.lower() == "first":
-            projection_for_shift = 0
-        elif projection_for_shift.lower() == "last":
-            projection_for_shift = -1
-        elif projection_for_shift.lower() == "middle":
-            projection_for_shift = len(upper_scan.projections) // 2
-        else:
-            try:
-                projection_for_shift = int(projection_for_shift)
-            except ValueError:
-                raise ValueError(
-                    f"{projection_for_shift} cannot be cast to an int and is not one of the possible ('first', 'last', 'middle')"
-                )
-    elif not isinstance(projection_for_shift, (int, numpy.number)):
-        raise TypeError(
-            f"projection_for_shift is expected to be an int. Not {type(projection_for_shift)} - {projection_for_shift}"
-        )
-
-    upper_scan_transformations = list(upper_scan.get_detector_transformations(tuple()))
-    if flip_ud_upper_frame:
-        upper_scan_transformations.append(UDDetTransformation())
-    upper_scan_trans_matrix = build_matrix(upper_scan_transformations)
-    lower_scan_transformations = list(lower_scan.get_detector_transformations(tuple()))
-    if flip_ud_lower_frame:
-        lower_scan_transformations.append(UDDetTransformation())
-    lower_scan_trans_matrix = build_matrix(lower_scan_transformations)
-    upper_proj = get_flat_fielded_proj(
-        upper_scan,
-        projection_for_shift,
-        reverse=False,
-        transformation_matrix=upper_scan_trans_matrix,
-    )
-    lower_proj = get_flat_fielded_proj(
-        lower_scan,
-        projection_for_shift,
-        reverse=invert_order,
-        transformation_matrix=lower_scan_trans_matrix,
-    )
-
-    from nabu.stitching.config import KEY_WINDOW_SIZE  # avoid cyclic import
-
-    w_window_size = int(y_shifts_params.get(KEY_WINDOW_SIZE, 400))
-    start_overlap = max(estimated_shifts[0] // 2 - w_window_size // 2, 0)
-    end_overlap = min(estimated_shifts[0] // 2 + w_window_size // 2, min(upper_proj.shape[0], lower_proj.shape[0]))
-    if start_overlap == 0:
-        overlap_upper_frame = upper_proj[-end_overlap:]
-    else:
-        overlap_upper_frame = upper_proj[-end_overlap:-start_overlap]
-    overlap_lower_frame = lower_proj[start_overlap:end_overlap]
-    if not overlap_upper_frame.shape == overlap_lower_frame.shape:
-        raise ValueError(f"Fail to get consistant overlap ({overlap_upper_frame.shape} vs {overlap_lower_frame.shape})")
-
-    return find_frame_relative_shifts(
-        overlap_upper_frame=overlap_upper_frame,
-        overlap_lower_frame=overlap_lower_frame,
-        estimated_shifts=estimated_shifts,
-        x_cross_correlation_function=x_cross_correlation_function,
-        y_cross_correlation_function=y_cross_correlation_function,
-        x_shifts_params=x_shifts_params,
-        y_shifts_params=y_shifts_params,
-    )
-
-
-def find_shift_correlate(img1, img2, padding_mode="reflect"):
-    alignment = AlignmentBase()
-    cc = alignment._compute_correlation_fft(
-        img1,
-        img2,
-        padding_mode,
-    )
-
-    img_shape = img1.shape[-2:]
-    cc_vs = numpy.fft.fftfreq(img_shape[-2], 1 / img_shape[-2])
-    cc_hs = numpy.fft.fftfreq(img_shape[-1], 1 / img_shape[-1])
-
-    (f_vals, fv, fh) = alignment.extract_peak_region_2d(cc, cc_vs=cc_vs, cc_hs=cc_hs)
-    shifts_vh = alignment.refine_max_position_2d(f_vals, fv, fh)
-    return -shifts_vh
-
-
-def find_shift_with_itk(img1: numpy.ndarray, img2: numpy.ndarray) -> tuple:
-    # created from https://examples.itk.org/src/registration/common/perform2dtranslationregistrationwithmeansquares/documentation
-    # return (y_shift, x_shift). For now shift are integers as only integer shift are handled.
-    if not img1.dtype == img2.dtype:
-        raise ValueError("the two images are expected to have the same type")
-    if not img1.ndim == img2.ndim == 2:
-        raise ValueError("the two images are expected to 2D numpy arrays")
-
-    if not has_itk:
-        _logger.warning("itk is not installed. Please install it to find shift with it")
-        return (0, 0)
-
-    if StrictVersion(itk.Version.GetITKVersion()) < StrictVersion("4.9.0"):
-        _logger.error("ITK 4.9.0 is required to find shift with it.")
-        return (0, 0)
-
-    pixel_type = itk.ctype("float")
-    img1 = numpy.ascontiguousarray(img1, dtype=numpy.float32)
-    img2 = numpy.ascontiguousarray(img2, dtype=numpy.float32)
-
-    dimension = 2
-    image_type = itk.Image[pixel_type, dimension]
-
-    fixed_image = itk.PyBuffer[image_type].GetImageFromArray(img1)
-    moving_image = itk.PyBuffer[image_type].GetImageFromArray(img2)
-
-    transform_type = itk.TranslationTransform[itk.D, dimension]
-    initial_transform = transform_type.New()
-
-    optimizer = itk.RegularStepGradientDescentOptimizerv4.New(
-        LearningRate=4,
-        MinimumStepLength=0.001,
-        RelaxationFactor=0.5,
-        NumberOfIterations=200,
-    )
-
-    metric = itk.MeanSquaresImageToImageMetricv4[image_type, image_type].New()
-
-    registration = itk.ImageRegistrationMethodv4.New(
-        FixedImage=fixed_image,
-        MovingImage=moving_image,
-        Metric=metric,
-        Optimizer=optimizer,
-        InitialTransform=initial_transform,
-    )
-
-    moving_initial_transform = transform_type.New()
-    initial_parameters = moving_initial_transform.GetParameters()
-    initial_parameters[0] = 0
-    initial_parameters[1] = 0
-    moving_initial_transform.SetParameters(initial_parameters)
-    registration.SetMovingInitialTransform(moving_initial_transform)
-
-    identity_transform = transform_type.New()
-    identity_transform.SetIdentity()
-    registration.SetFixedInitialTransform(identity_transform)
-
-    registration.SetNumberOfLevels(1)
-    registration.SetSmoothingSigmasPerLevel([0])
-    registration.SetShrinkFactorsPerLevel([1])
-
-    registration.Update()
-
-    transform = registration.GetTransform()
-    final_parameters = transform.GetParameters()
-    translation_along_x = final_parameters.GetElement(0)
-    translation_along_y = final_parameters.GetElement(1)
-
-    return numpy.round(translation_along_y), numpy.round(translation_along_x)