fibsem 0.2.1a0__py3-none-any.whl

fibsem/__init__.py

@@ -0,0 +1,8 @@
+
+try:
+    import importlib.metadata
+    __version__ = importlib.metadata.version('fibsem')
+except ModuleNotFoundError:
+    __version__ = "unknown"
+
+    

fibsem/_version.py

@@ -0,0 +1,4 @@
+# file generated by setuptools_scm
+# don't change, don't track in version control
+__version__ = version = '0.1.dev1311+gf3ad026.d20230711'
+__version_tuple__ = version_tuple = (0, 1, 'dev1311', 'gf3ad026.d20230711')

fibsem/acquire.py

@@ -0,0 +1,274 @@
+import logging
+
+import numpy as np
+import os
+
+from skimage import exposure
+
+
+from fibsem.structures import (
+    BeamType,
+    ImageSettings,
+    ReferenceImages,
+    FibsemImage,
+    FibsemRectangle,
+)
+from fibsem.microscope import FibsemMicroscope
+
+
+def take_reference_images(
+    microscope: FibsemMicroscope, image_settings: ImageSettings
+) -> tuple[FibsemImage, FibsemImage]:
+    """
+    Acquires a pair of electron and ion reference images using the specified imaging settings and
+    a FibsemMicroscope instance.
+
+    Args:
+        microscope (FibsemMicroscope): A FibsemMicroscope instance for imaging.
+        image_settings (ImageSettings): An ImageSettings object with the desired imaging parameters.
+
+    Returns:
+        A tuple containing a pair of FibsemImage objects, representing the electron and ion reference
+        images acquired using the specified microscope and image settings.
+
+    Notes:
+        - This function temporarily changes the `image_settings.beam_type` to `BeamType.ELECTRON`
+          and then `BeamType.ION` to acquire the electron and ion reference images, respectively.
+          It resets the `image_settings.beam_type` to the original value after acquiring the images.
+        - The `FibsemImage` objects in the returned tuple contain the image data as numpy arrays,
+          as well as other image metadata.
+    """
+    tmp_beam_type = image_settings.beam_type
+    image_settings.beam_type = BeamType.ELECTRON
+    eb_image = new_image(microscope, image_settings)
+    image_settings.beam_type = BeamType.ION
+    ib_image = new_image(microscope, image_settings)
+    image_settings.beam_type = tmp_beam_type  # reset to original beam type
+
+    return eb_image, ib_image
+   
+
+
+def take_set_of_reference_images(
+    microscope: FibsemMicroscope,
+    image_settings: ImageSettings,
+    hfws: tuple[float],
+    label: str = "ref_image",
+) -> ReferenceImages:
+    """
+    Takes a set of reference images at low and high magnification using a FibsemMicroscope.
+    The image settings and half-field widths for the low- and high-resolution images are
+    specified using an ImageSettings object and a tuple of two floats, respectively.
+    The optional label parameter can be used to customize the image labels.
+
+    Args:
+        microscope (FibsemMicroscope): A FibsemMicroscope object to acquire the images from.
+        image_settings (ImageSettings): An ImageSettings object with the desired imaging parameters.
+        hfws (Tuple[float, float]): A tuple of two floats specifying the half-field widths (in microns)
+            for the low- and high-resolution images, respectively.
+        label (str, optional): A label to be included in the image filenames. Defaults to "ref_image".
+
+    Returns:
+        A ReferenceImages object containing the low- and high-resolution electron and ion beam images.
+
+    Notes:
+        This function sets image_settings.save to True before taking the images.
+        The returned ReferenceImages object contains the electron and ion beam images as FibsemImage objects.
+    """
+    # force save
+    image_settings.save = True
+
+    image_settings.hfw = hfws[0]
+    image_settings.label = f"{label}_low_res"
+    low_eb, low_ib = take_reference_images(microscope, image_settings)
+
+    image_settings.hfw = hfws[1]
+    image_settings.label = f"{label}_high_res"
+    high_eb, high_ib = take_reference_images(microscope, image_settings)
+
+    reference_images = ReferenceImages(low_eb, high_eb, low_ib, high_ib)
+
+    return reference_images
+
+
+def auto_gamma(
+    image: FibsemImage,
+    min_gamma: float = 0.15,
+    max_gamma: float = 1.8,
+    scale_factor: float = 0.01,
+    gamma_threshold: int = 45,
+    method: str = "autogamma",
+) -> FibsemImage:
+    """
+    Applies automatic gamma correction to the input `FibsemImage`.
+
+    Args:
+        image (FibsemImage): The input `FibsemImage` to apply gamma correction to.
+        min_gamma (float): The minimum gamma value allowed in the correction. Defaults to 0.15.
+        max_gamma (float): The maximum gamma value allowed in the correction. Defaults to 1.8.
+        scale_factor (float): A scaling factor to adjust the gamma correction range based on the image
+            brightness. Defaults to 0.01.
+        gamma_threshold (int): The maximum threshold of brightness difference from the mid-gray value
+            (i.e., 128) before the gamma value is forced to 1.0. Defaults to 45.
+
+    Returns:
+        A new `FibsemImage` object containing the gamma-corrected image data, with the same metadata
+        as the input image.
+
+    Notes:
+        - This function applies gamma correction to the input image using the `skimage.exposure.adjust_gamma`
+          function, with the gamma value computed based on the mean intensity of the image.
+        - If the difference between the mean image intensity and the mid-gray value (i.e., 128) is greater
+          than the specified `gamma_threshold`, the gamma value is forced to 1.0 to avoid over-correction.
+        - The `FibsemImage` object in the returned list contains the gamma-corrected image data as a
+          numpy array, as well as other image metadata.
+    """
+
+    if method == "autogamma":
+        std = np.std(image.data)  # unused variable?
+        mean = np.mean(image.data)
+        diff = mean - 255 / 2.0
+        gam = np.clip(
+            min_gamma, 1 + diff * scale_factor, max_gamma
+        )
+        if abs(diff) < gamma_threshold:
+            gam = 1.0
+        if image.metadata is not None:
+            logging.debug(
+                f"AUTO_GAMMA | {image.metadata.image_settings.beam_type} | {diff:.3f} | {gam:.3f}"
+            )
+        image_data = exposure.adjust_gamma(image.data, gam)
+
+        image = FibsemImage(data=image_data, metadata=image.metadata)
+    
+    if method == "autoclahe":
+        image = apply_clahe(image)
+
+    return image
+
+
+
+def apply_clahe(
+    image: FibsemImage,
+    which_package: str = "skimage",
+    clip_limit_cv2: float = 15,
+    tile_grid_size: int = 8,
+    clip_limit_skimage: float = 0.02,
+    kernel_size = None
+) -> FibsemImage:
+    """
+    Applies Contrast Limited Adaptive Histogram Equalisation correction to the input `FibsemImage`.
+    image is divided into small blocks called "tiles" (tileSize is 8x8 by default in OpenCV). Then each of these
+    blocks are histogram equalized as usual. So in a small area, histogram would confine to a small region
+    (unless there is noise). If noise is there, it will be amplified. To avoid this, contrast limiting is applied.
+    If any histogram bin is above the specified contrast limit (by default 40 in OpenCV), those pixels are clipped and
+    distributed uniformly to other bins before applying histogram equalization. After equalization, to remove artifacts
+    in tile borders, bilinear interpolation is applied.
+
+    In OpenCV tileGridSize (tile_grid_size) is by default 8x8, clipLimit (clip_limit_cv2) is by default 40
+
+    In skimage kernel_size (int or array_like), is optional. It defines the shape of contextual regions used in the
+    algorithm. By default, kernel_size is 1/8 of image height by 1/8 of its width.
+    clip_limit float, optional. Clipping limit, normalized between 0 and 1 (higher values give more contrast).
+
+    Args:
+        image (FibsemImage): The input `FibsemImage` to apply gamma correction to.
+
+        type (str) Either "skimage" or "OpenCV" to apply the filter from the corresponding library
+
+        clip_limit_cv2 (float): used if which_package=="OpenCV". Defaults to 15. (by default 40 in OpenCV)
+        tile_grid_size (int): used if which_package=='OpenCV'. Defaults to 8x8 pixels.
+
+        clip_limit_skimage (float): used if which_package=="skimage". Defaults to 0.01. Clipping limit, normalised between 0 and 1 (higher values give more contrast).
+        tile_grid_size (int): used if which_package=='skimage'. if None, defaults to kernel_size is 1/8 of image height by 1/8 of its width.
+
+    Returns:
+        A new `FibsemImage` object containing the clahe-enhanced image data, with the same metadata
+        as the input image.
+
+    Notes:
+        - This function applies gamma correction to the input image using either the `cv2.createCLAHE` or `skimage.exposure.equalize_adapthist` function
+        - The `FibsemImage` object in the returned list contains the clahe-enhanced image data as a
+          numpy array, as well as other image metadata.
+    """
+
+    """
+        OpenCV requires 8-bit images for CLAHE, skimage requires either 8-bit images or arrays with values between [0,1]
+        Here, we convert the raw data into an 8-bit image to proceed
+    """
+
+    temp = image.data
+    temp = temp / temp.max()
+    temp = (temp * 2**8).astype(np.uint8)
+
+    if which_package=='OpenCV':
+        import cv2
+        tile_grid_size = int(tile_grid_size)
+        clahe = cv2.createCLAHE(clipLimit=clip_limit_cv2,
+                                tileGridSize=(tile_grid_size,tile_grid_size))
+        image_data = clahe.apply(temp)
+
+    else: # default filter
+        # nbin = 256 default, for 8-bit images
+        image_data = exposure.equalize_adapthist(temp,
+                                                 kernel_size=kernel_size,
+                                                 clip_limit=clip_limit_skimage, nbins=256)
+        import skimage
+        image_data = skimage.img_as_ubyte(image_data)
+
+    return FibsemImage(data=image_data, metadata=image.metadata)
+
+
+
+def new_image(
+    microscope: FibsemMicroscope,
+    settings: ImageSettings,
+) -> FibsemImage:
+    """Apply the given image settings and acquire a new image.
+
+    Args:
+        microscope (FibsemMicroscope): The FibsemMicroscope instance used to acquire the image.
+        settings (ImageSettings): The image settings used to acquire the image.
+
+    Returns:
+        FibsemImage: The acquired image.
+    """
+
+    # set label
+    if settings.beam_type is BeamType.ELECTRON:
+        label = f"{settings.label}_eb"
+
+    if settings.beam_type is BeamType.ION:
+        label = f"{settings.label}_ib"
+
+    # run autocontrast
+    if settings.autocontrast:
+        microscope.autocontrast(beam_type=settings.beam_type)
+
+    # acquire the image
+    image = microscope.acquire_image(
+        image_settings=settings,
+    )
+
+    if settings.gamma_enabled:
+        image = auto_gamma(image)
+
+    # save image
+    if settings.save:
+        filename = os.path.join(settings.save_path, label)
+        image.save(save_path=filename)
+
+    return image
+
+
+def last_image(microscope: FibsemMicroscope, beam_type: BeamType) -> FibsemImage:
+    """_summary_
+
+    Args:
+        microscope (FibsemMicroscope): microscope instance
+        beam_type (BeamType): beam type for image
+
+    Returns:
+        FibsemImage: last image acquired by the microscope
+    """
+    return microscope.last_image(beam_type=beam_type)

fibsem/alignment.py

@@ -0,0 +1,390 @@
+import logging
+
+import numpy as np
+
+from scipy import fftpack
+
+from fibsem import acquire, calibration, utils, validation
+from fibsem.imaging import masks
+from fibsem.imaging import utils as image_utils
+from fibsem.structures import (
+    BeamType,
+    ImageSettings,
+    MicroscopeSettings,
+    ReferenceImages,
+    FibsemImage,
+    FibsemRectangle,
+)
+from fibsem.microscope import FibsemMicroscope
+from typing import Union
+
+
+def auto_eucentric_correction(
+    microscope: FibsemMicroscope,
+    settings: MicroscopeSettings,
+    image_settings: ImageSettings,
+    tilt_degrees: int = 25,
+    xcorr_limit: int = 250,
+) -> None:
+
+    raise NotImplementedError
+
+    image_settings.save = False
+    image_settings.beam_type = BeamType.ELECTRON
+    calibration.auto_charge_neutralisation(
+        microscope.connection, image_settings
+    )  # TODO: need to change this function
+
+    for hfw in [400e-6, 150e-6, 80e-6, 80e-6]:
+        image_settings.hfw = hfw
+
+        correct_stage_eucentric_alignment(
+            microscope,
+            settings,
+            image_settings,
+            tilt_degrees=tilt_degrees,
+            xcorr_limit=xcorr_limit,
+        )
+
+
+def beam_shift_alignment(
+    microscope: FibsemMicroscope,
+    image_settings: ImageSettings,
+    ref_image: FibsemImage,
+    reduced_area: FibsemRectangle = None,
+):
+    """Aligns the images by adjusting the beam shift instead of moving the stage.
+
+    This method uses cross-correlation between the reference image and a new image to calculate the
+    optimal beam shift for alignment. This approach offers increased precision, but a lower range
+    compared to stage movement.
+
+    NOTE: Only shift the ion beam, never the electron beam.
+
+    Args:
+        microscope (FibsemMicroscope): An OpenFIBSEM microscope client.
+        image_settings (acquire.ImageSettings): Settings for taking the image.
+        ref_image (FibsemImage): The reference image to align to.
+        reduced_area (FibseRectangle): The reduced area to image with.
+
+    Raises:
+        ValueError: If `image_settings.beam_type` is not set to `BeamType.ION`.
+
+    """
+    image_settings.reduced_area = reduced_area
+    new_image = acquire.new_image(
+        microscope, settings=image_settings
+    )
+    dx, dy, _ = shift_from_crosscorrelation(
+        ref_image, new_image, lowpass=50, highpass=4, sigma=5, use_rect_mask=True
+    )
+
+    # adjust beamshift 
+    microscope.beam_shift(dx, dy, image_settings.beam_type)
+
+
+def correct_stage_drift(
+    microscope: FibsemMicroscope,
+    settings: MicroscopeSettings,
+    reference_images: ReferenceImages,
+    alignment: tuple[BeamType, BeamType] = (BeamType.ELECTRON, BeamType.ELECTRON),
+    rotate: bool = False,
+    use_ref_mask: bool = False,
+    mask_scale: int = 4,
+    xcorr_limit: Union[tuple[int, int], None] = None,
+    constrain_vertical: bool = False,
+) -> bool:
+    """Corrects the stage drift by aligning low- and high-resolution reference images
+    using cross-correlation.
+
+    Args:
+        microscope (FibsemMicroscope): The microscope used for image acquisition.
+        settings (MicroscopeSettings): The settings used for image acquisition.
+        reference_images (ReferenceImages): A container of low- and high-resolution
+            reference images.
+        alignment (tuple[BeamType, BeamType], optional): A tuple of two `BeamType`
+            objects, specifying the beam types used for the alignment of low- and
+            high-resolution images, respectively. Defaults to (BeamType.ELECTRON,
+            BeamType.ELECTRON).
+        rotate (bool, optional): Whether to rotate the reference images before
+            alignment. Defaults to False.
+        use_ref_mask (bool, optional): Whether to apply a mask to the reference images
+            before alignment. Defaults to False.
+        mask_scale (int, optional): The scale factor used for creating the mask. Defaults
+            to 4.
+        xcorr_limit (tuple[int, int] | None, optional): A tuple of two integers that
+            represent the minimum and maximum cross-correlation values allowed for the
+            alignment. If not specified, the values are set to (None, None), which means
+            there are no limits. Defaults to None.
+        constrain_vertical (bool, optional): Whether to constrain the alignment to the
+            vertical axis. Defaults to False.
+
+    Returns:
+        bool: True if the stage drift correction was successful, False otherwise.
+    """
+
+    # set reference images
+    if alignment[0] is BeamType.ELECTRON:
+        ref_lowres, ref_highres = (
+            reference_images.low_res_eb,
+            reference_images.high_res_eb,
+        )
+    if alignment[0] is BeamType.ION:
+        ref_lowres, ref_highres = (
+            reference_images.low_res_ib,
+            reference_images.high_res_ib,
+        )
+
+    if xcorr_limit is None:
+        xcorr_limit = (None, None)
+
+    # rotate reference
+    if rotate:
+        ref_lowres = image_utils.rotate_image(ref_lowres)
+        ref_highres = image_utils.rotate_image(ref_highres)
+
+    # align lowres, then highres
+    for i, ref_image in enumerate([ref_lowres, ref_highres]):
+
+        if use_ref_mask:
+            ref_mask = masks.create_lamella_mask(
+                ref_image,
+                settings.protocol["lamella"],
+                scale=mask_scale,
+                use_trench_height=True,
+            )  # TODO: refactor, liftout specific
+        else:
+            ref_mask = None
+
+        # take new images
+        # set new image settings (same as reference)
+        # settings.image = utils.match_image_settings(
+        #     ref_image, settings.image, beam_type=alignment[1]
+        # )
+        settings.image = ImageSettings.fromFibsemImage(ref_image)
+        settings.image.beam_type = alignment[1]
+        new_image = acquire.new_image(microscope, settings.image)
+
+        # crosscorrelation alignment
+        ret = align_using_reference_images(
+            microscope,
+            settings,
+            ref_image,
+            new_image,
+            ref_mask=ref_mask,
+            xcorr_limit=xcorr_limit[i],
+            constrain_vertical=constrain_vertical,
+        )
+
+        if ret is False:
+            break  # cross correlation has failed...
+
+    return ret
+
+
+def align_using_reference_images(
+    microscope: FibsemMicroscope,
+    settings: MicroscopeSettings,
+    ref_image: FibsemImage,
+    new_image: FibsemImage,
+    ref_mask: np.ndarray = None,
+    xcorr_limit: int = None,
+    constrain_vertical: bool = False,
+) -> bool:
+    """
+    Uses cross-correlation to align a new image to a reference image.
+
+    Args:
+        microscope: A FibsemMicroscope instance representing the microscope being used.
+        settings: A MicroscopeSettings instance representing the settings for the imaging session.
+        ref_image: A FibsemImage instance representing the reference image to which the new image will be aligned.
+        new_image: A FibsemImage instance representing the new image that will be aligned to the reference image.
+        ref_mask: A numpy array representing a mask to apply to the reference image during alignment. Default is None.
+        xcorr_limit: An integer representing the limit for the cross-correlation coefficient. If the coefficient is below
+            this limit, alignment will fail. Default is None.
+        constrain_vertical: A boolean indicating whether to constrain movement to the vertical axis. If True, movement
+            will be restricted to the vertical axis, which is useful for eucentric movement. If False, movement will be
+            allowed on both the X and Y axes. Default is False.
+
+    Returns:
+        A boolean indicating whether the alignment was successful. True if the alignment was successful, False otherwise.
+    """
+    # get beam type
+    ref_beam_type = BeamType[ref_image.metadata.image_settings.beam_type.name.upper()]
+    new_beam_type = BeamType[new_image.metadata.image_settings.beam_type.name.upper()]
+
+    logging.info(
+        f"aligning {ref_beam_type.name} reference image to {new_beam_type.name}."
+    )
+    sigma = 6
+    hp_px = 8
+    lp_px = 128  # MAGIC_NUMBER
+
+    dx, dy, xcorr = shift_from_crosscorrelation(
+        ref_image,
+        new_image,
+        lowpass=lp_px,
+        highpass=hp_px,
+        sigma=sigma,
+        use_rect_mask=True,
+        ref_mask=ref_mask,
+        xcorr_limit=xcorr_limit,
+    )
+
+    shift_within_tolerance = (
+        validation.check_shift_within_tolerance(  # TODO: Abstract validation.py
+            dx=dx, dy=dy, ref_image=ref_image, limit=0.5
+        )
+    )
+
+    if shift_within_tolerance:
+
+        # vertical constraint = eucentric movement
+        if constrain_vertical:
+            microscope.eucentric_move(
+                settings=settings, dy=-dy
+            )  # FLAG_TEST
+        else:
+            # move the stage
+            microscope.stable_move(
+                settings=settings,
+                dx=dx,
+                dy=-dy,
+                beam_type=new_beam_type,
+            )
+
+    return shift_within_tolerance
+
+
+def shift_from_crosscorrelation(
+    ref_image: FibsemImage,
+    new_image: FibsemImage,
+    lowpass: int = 128,
+    highpass: int = 6,
+    sigma: int = 6,
+    use_rect_mask: bool = False,
+    ref_mask: np.ndarray = None,
+    xcorr_limit: int = None,
+) -> tuple[float, float, np.ndarray]:
+    """Calculates the shift between two images by cross-correlating them and finding the position of maximum correlation.
+
+    Args:
+        ref_image (FibsemImage): The reference image.
+        new_image (FibsemImage): The new image to align to the reference.
+        lowpass (int, optional): The low-pass filter frequency (in pixels) for the bandpass filter used to
+            enhance the correlation signal. Defaults to 128.
+        highpass (int, optional): The high-pass filter frequency (in pixels) for the bandpass filter used to
+            enhance the correlation signal. Defaults to 6.
+        sigma (int, optional): The standard deviation (in pixels) of the Gaussian filter used to create the bandpass
+            mask. Defaults to 6.
+        use_rect_mask (bool, optional): Whether to use a rectangular mask for the correlation. If True, the correlation
+            is performed only inside a rectangle that covers most of the image, to reduce the effect of noise at the
+            edges. Defaults to False.
+        ref_mask (np.ndarray, optional): A mask to apply to the reference image before correlation. If not None,
+            it should be a binary array with the same shape as the images. Pixels with value 0 will be ignored in the
+            correlation. Defaults to None.
+        xcorr_limit (int, optional): If not None, the correlation map will be circularly masked to a square
+            with sides of length 2 * xcorr_limit + 1, centred on the maximum correlation peak. This can be used to
+            limit the search range and improve the accuracy of the shift. Defaults to None.
+
+    Returns:
+        A tuple (x_shift, y_shift, xcorr), where x_shift and y_shift are the shifts along x and y (in meters),
+        and xcorr is the cross-correlation map between the images.
+    """
+    # get pixel_size
+    pixelsize_x = new_image.metadata.pixel_size.x
+    pixelsize_y = new_image.metadata.pixel_size.y
+
+    # normalise both images
+    ref_data_norm = image_utils.normalise_image(ref_image)
+    new_data_norm = image_utils.normalise_image(new_image)
+
+    # cross-correlate normalised images
+    if use_rect_mask:
+        rect_mask = masks._mask_rectangular(new_data_norm.shape)
+        ref_data_norm = rect_mask * ref_data_norm
+        new_data_norm = rect_mask * new_data_norm
+
+    if ref_mask is not None:
+        ref_data_norm = ref_mask * ref_data_norm  # mask the reference
+
+    # bandpass mask
+    bandpass = masks.create_bandpass_mask(
+        shape=ref_data_norm.shape, lp=lowpass, hp=highpass, sigma=sigma
+    )
+
+    # crosscorrelation
+    xcorr = crosscorrelation_v2(ref_data_norm, new_data_norm, bandpass=bandpass)
+
+    # limit xcorr range
+    if xcorr_limit:
+        xcorr = masks.apply_circular_mask(xcorr, xcorr_limit)
+
+    # calculate maximum crosscorrelation
+    maxX, maxY = np.unravel_index(np.argmax(xcorr), xcorr.shape)  # TODO: backwards
+    cen = np.asarray(xcorr.shape) / 2
+    err = np.array(cen - [maxX, maxY], int)
+
+    # calculate shift in metres
+    x_shift = err[1] * pixelsize_x
+    y_shift = err[0] * pixelsize_y  # this could be the issue?
+
+    logging.debug(f"cross-correlation:")
+    logging.debug(f"pixelsize: x: {pixelsize_x:.2e}, y: {pixelsize_y:.2e}")
+    logging.debug(f"maxX: {maxX}, {maxY}, centre: {cen}")
+    logging.debug(f"x: {err[1]}px, y: {err[0]}px")
+    logging.debug(f"x: {x_shift:.2e}m, y: {y_shift:.2e} meters")
+
+    # metres
+    return x_shift, y_shift, xcorr
+
+
+def crosscorrelation_v2(
+    img1: np.ndarray, img2: np.ndarray, bandpass: np.ndarray = None
+) -> np.ndarray:
+    """
+    Cross-correlate two images using Fourier convolution matching.
+
+    Args:
+        img1 (np.ndarray): The reference image.
+        img2 (np.ndarray): The new image to be cross-correlated with the reference.
+        bandpass (np.ndarray, optional): A bandpass mask to apply to both images before cross-correlation. Defaults to None.
+
+    Returns:
+        np.ndarray: The cross-correlation map between the two images.
+    """
+    if img1.shape != img2.shape:
+        err = (
+            f"Image 1 {img1.shape} and Image 2 {img2.shape} need to have the same shape"
+        )
+        logging.error(err)
+        raise ValueError(err)
+
+    if bandpass is None:
+        bandpass = np.ones_like(img1)
+
+    n_pixels = img1.shape[0] * img1.shape[1]
+
+    img1ft = np.fft.ifftshift(bandpass * np.fft.fftshift(np.fft.fft2(img1)))
+    tmp = img1ft * np.conj(img1ft)
+    img1ft = n_pixels * img1ft / np.sqrt(tmp.sum())
+
+    img2ft = np.fft.ifftshift(bandpass * np.fft.fftshift(np.fft.fft2(img2)))
+    img2ft[0, 0] = 0
+    tmp = img2ft * np.conj(img2ft)
+
+    img2ft = n_pixels * img2ft / np.sqrt(tmp.sum())
+
+    # import matplotlib.pyplot as plt
+    # fig, ax = plt.subplots(1, 2, figsize=(15, 15))
+    # ax[0].imshow(np.fft.ifft2(img1ft).real)
+    # ax[1].imshow(np.fft.ifft2(img2ft).real)
+    # plt.show()
+
+    # plt.title("Power Spectra")
+    # plt.imshow(np.log(np.abs(np.fft.fftshift(np.fft.fft2(img1)))))
+    # plt.show()
+
+    xcorr = np.real(np.fft.fftshift(np.fft.ifft2(img1ft * np.conj(img2ft))))
+
+    return xcorr