microeye 2.3.9__tar.gz → 2.3.11__tar.gz

{microeye-2.3.9/src/microeye.egg-info → microeye-2.3.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: microeye
-Version: 2.3.9
+Version: 2.3.11
 Summary: A python toolkit for fluorescence microscopy         that features hardware control, data analysis and vizualization         for super-resolution single-molecule localization microscopy and         single-partical tracking.
 Home-page: https://github.com/samhitech/microEye
 Author: Mohammad Nour Alsamsam
@@ -32,6 +32,7 @@ Requires-Dist: pyfiglet==1.0.2
 Requires-Dist: pyflakes==3.2.0
 Requires-Dist: pyjokes==0.6.0
 Requires-Dist: PyOpenGL==3.1.7
+Requires-Dist: pypylon==4.2.0
 Requires-Dist: pyqtdarktheme==2.1.0
 Requires-Dist: pyqtgraph==0.13.7
 Requires-Dist: pyserial==3.5
@@ -71,11 +72,11 @@ The **`microEye`** is a Python toolkit for fluorescence microscopy that supports
 This toolkit is compatible with the [hardware](#hardware) used in our microscope. For further details, refer to the [miEye microscope paper](https://doi.org/10.1016/j.ohx.2022.e00368) and [OSF project](http://doi.org/10.17605/osf.io/j2fqy).
 
 ```bash
- __  __ _            ___               ___   ____ ___ 
-|  \/  (_)__ _ _ ___| __|  _ ___  __ _|_  ) |__ // _ \
-| |\/| | / _| '_/ _ \ _| || / -_) \ V // / _ |_ \\_, /
-|_|  |_|_\__|_| \___/___\_, \___|  \_//___(_)___(_)_/ 
-                        |__/
+   __  ____              ____                ___    ____  ______
+  /  |/  (_)__________  / __/_ _____   _  __|_  |  |_  / <  <  /
+ / /|_/ / / __/ __/ _ \/ _// // / -_) | |/ / __/_ _/_ <_ / // /
+/_/  /_/_/\__/_/  \___/___/\_, /\__/  |___/____(_)____(_)_//_/
+                          /___/
 ```
 
 ![Package Health](https://snyk.io/advisor/python/microEye/badge.svg)

{microeye-2.3.9 → microeye-2.3.11}/README.md

@@ -7,11 +7,11 @@ The **`microEye`** is a Python toolkit for fluorescence microscopy that supports
 This toolkit is compatible with the [hardware](#hardware) used in our microscope. For further details, refer to the [miEye microscope paper](https://doi.org/10.1016/j.ohx.2022.e00368) and [OSF project](http://doi.org/10.17605/osf.io/j2fqy).
 
 ```bash
- __  __ _            ___               ___   ____ ___ 
-|  \/  (_)__ _ _ ___| __|  _ ___  __ _|_  ) |__ // _ \
-| |\/| | / _| '_/ _ \ _| || / -_) \ V // / _ |_ \\_, /
-|_|  |_|_\__|_| \___/___\_, \___|  \_//___(_)___(_)_/ 
-                        |__/
+   __  ____              ____                ___    ____  ______
+  /  |/  (_)__________  / __/_ _____   _  __|_  |  |_  / <  <  /
+ / /|_/ / / __/ __/ _ \/ _// // / -_) | |/ / __/_ _/_ <_ / // /
+/_/  /_/_/\__/_/  \___/___/\_, /\__/  |___/____(_)____(_)_//_/
+                          /___/
 ```
 
 ![Package Health](https://snyk.io/advisor/python/microEye/badge.svg)

{microeye-2.3.9 → microeye-2.3.11}/src/microEye/_version.py

@@ -1,2 +1,2 @@
-version_info = (2, 3, 9)
+version_info = (2, 3, 11)
 __version__ = '.'.join(map(str, version_info))

{microeye-2.3.9 → microeye-2.3.11}/src/microEye/analysis/filters/spatial.py

@@ -117,54 +117,58 @@ class DoG_Filter(SpatialFilter):
         }
 
 
-# class GaussFilter(SpatialFilter):
-#     def __init__(self, sigma=1) -> None:
-#         '''Gaussian filter initialization.'''
-#         params = {'sigma': sigma}
-#         super().__init__(name='Gaussian Filter', parameters=params)
-#         self.set_params(sigma)
-
-#     def set_params(self, sigma):
-#         '''Set the sigma parameter for the Gaussian filter.'''
-#         self._show_filter = False
-#         self.parameters['sigma'] = sigma
-#         self.gauss = GaussFilter.gaussian_kernel(
-#             max(3, math.ceil(3 * sigma + 1)), sigma
-#         )
-
-#     def gaussian_kernel(dim, sigma):
-#         x = cv2.getGaussianKernel(dim, sigma)
-#         kernel = x.dot(x.T)
-#         return kernel
-
-#     def run(self, image: np.ndarray) -> np.ndarray:
-#         return cv2.normalize(
-#             signal.convolve2d(image, np.rot90(self.gauss), mode='same'),
-#             None,
-#             0,
-#             255,
-#             cv2.NORM_MINMAX,
-#             cv2.CV_8U,
-#         )
-
-#     def get_tree_parameters(self):
-#         '''Return the parameters for the pyqtgraph tree view.'''
-#         return {
-#             'name': self.name,
-#             'type': 'group',
-#             'visible': False,
-#             'children': [
-#                 {
-#                     'name': 'Sigma',
-#                     'type': 'float',
-#                     'value': self.parameters['sigma'],
-#                     'limits': [0.0, 100.0],
-#                     'step': 0.1,
-#                     'decimals': 2,
-#                     'tip': 'Standard deviation (\u03c3) for the filter',
-#                 },
-#             ],
-#         }
+class PointGaussFilter(SpatialFilter):
+    def __init__(self, sigma=1) -> None:
+        '''Gaussian filter initialization.'''
+        params = {'sigma': sigma}
+        super().__init__(name='Point Gaussian Filter', parameters=params)
+        self.set_params(sigma)
+
+        self.point_kernel = np.array([[-1, -1, -1], [-1, 8, -1], [-1, -1, -1]])
+
+    def set_params(self, sigma):
+        '''Set the sigma parameter for the Gaussian filter.'''
+        self._show_filter = False
+        self.parameters['sigma'] = sigma
+        self.gauss = PointGaussFilter.gaussian_kernel(
+            max(3, math.ceil(3 * sigma + 1)), sigma
+        )
+
+    def gaussian_kernel(dim, sigma):
+        x = cv2.getGaussianKernel(dim, sigma)
+        kernel = x.dot(x.T)
+        return kernel
+
+    def run(self, image: np.ndarray) -> np.ndarray:
+        point = signal.fftconvolve(image, np.rot90(self.point_kernel), mode='same')
+
+        return cv2.normalize(
+            signal.fftconvolve(point, np.rot90(self.gauss), mode='same'),
+            None,
+            0,
+            255,
+            cv2.NORM_MINMAX,
+            cv2.CV_8U,
+        )
+
+    def get_tree_parameters(self):
+        '''Return the parameters for the pyqtgraph tree view.'''
+        return {
+            'name': self.name,
+            'type': 'group',
+            'visible': False,
+            'children': [
+                {
+                    'name': 'Sigma',
+                    'type': 'float',
+                    'value': self.parameters['sigma'],
+                    'limits': [0.0, 100.0],
+                    'step': 0.1,
+                    'decimals': 2,
+                    'tip': 'Standard deviation (\u03c3) for the filter',
+                },
+            ],
+        }
 
 
 class FourierFilter(SpatialFilter):

{microeye-2.3.9 → microeye-2.3.11}/src/microEye/analysis/fitting/processing.py

@@ -249,7 +249,14 @@ def shift_correction(interpx, interpy, frame_bins, datax, datay):
         datay[mask] -= shift_y
 
 
-def plot_drift(frames_new, interpx, interpy, title='Drift Cross-Correlation'):
+def plot_drift(
+    frames_new,
+    interpx,
+    interpy,
+    error_x=None,
+    error_y=None,
+    title='Drift Cross-Correlation',
+):
     print('Shift Plot ...', end='\r')
 
     # plot results
@@ -272,8 +279,29 @@ def plot_drift(frames_new, interpx, interpy, title='Drift Cross-Correlation'):
     # setting vertical range
     # plt.setYRange(0, 1)
 
-    plt.plot(frames_new, interpx, pen='r', symbol=None, symbolBrush=0.2, name='x-drift')
-    plt.plot(frames_new, interpy, pen='y', symbol=None, symbolBrush=0.2, name='y-drift')
+    # Plot x-drift with error bars
+    if error_x is not None:
+        err_x = pg.ErrorBarItem(
+            x=frames_new, y=interpx, top=error_x, bottom=error_x, beam=0.5,
+            pen=pg.mkPen(color=(255, 0, 0, 24)) # red color with transparency
+        )
+        plt.addItem(err_x)
+
+    # Plot y-drift with error bars
+    if error_y is not None:
+        err_y = pg.ErrorBarItem(
+            x=frames_new, y=interpy, top=error_y, bottom=error_y, beam=0.5,
+            pen=pg.mkPen(color=(255, 255, 0, 24)) # yellow color with transparency
+        )
+        plt.addItem(err_y)
+
+    # Plot x and y drift curves
+    x_curve = plt.plot(
+        frames_new, interpx, pen='r', symbol=None, symbolBrush=0.2, name='x-drift'
+    )
+    y_curve = plt.plot(
+        frames_new, interpy, pen='y', symbol=None, symbolBrush=0.2, name='y-drift'
+    )
 
     print('Done ...', end='\r')
 
@@ -285,10 +313,9 @@ def plot_animation_stats(
 
     # Calculate bin edges from centers
     bin_width = frame_bin_centers[1] - frame_bin_centers[0]
-    bin_edges = np.concatenate([
-        frame_bin_centers - bin_width/2,
-        [frame_bin_centers[-1] + bin_width/2]
-    ])
+    bin_edges = np.concatenate(
+        [frame_bin_centers - bin_width / 2, [frame_bin_centers[-1] + bin_width / 2]]
+    )
 
     # plot results
     plt = pg.plot()

microeye-2.3.11/src/microEye/analysis/fitting/rcc.py

@@ -0,0 +1,183 @@
+import cv2
+import numba as nb
+import numpy as np
+
+from microEye.analysis.fitting.pyfit3Dcspline.CPU.CPUmleFit_LM import (
+    kernel_MLEFit_LM_Sigma,
+)
+
+
+def cross_correlation(image1, image2):
+    """
+    Compute the cross-correlation of two images using FFT.
+    Equivalent to MATLAB's CrossCorrelation function.
+    """
+    f1 = np.fft.fft2(image1)
+    f2 = np.fft.fft2(image2)
+    corr = np.fft.fftshift(np.real(np.fft.ifft2(f1 * np.conj(f2))))
+    return corr
+
+
+@nb.njit
+def _process_single_image(image, reference, pixelSize, box):
+    with nb.objmode(result='float32[:]'):
+        xcorr = cross_correlation(image, reference)
+        y_max_, x_max_ = np.unravel_index(xcorr.argmax(), xcorr.shape)
+
+        halfBoxSize = int(box / 2)
+
+        xcorr = xcorr[
+            y_max_ - halfBoxSize : y_max_ + halfBoxSize + 1,
+            x_max_ - halfBoxSize : x_max_ + halfBoxSize + 1,
+        ]
+
+        result, crb, ll = kernel_MLEFit_LM_Sigma(
+            xcorr.flatten().astype(np.float32), 1.0, int(box + 1), 60, None
+        )
+
+        result[0] += x_max_ - halfBoxSize
+        result[1] += y_max_ - halfBoxSize
+
+    shift = result[0:2] * pixelSize
+
+    return shift
+
+
+@nb.njit(parallel=True, cache=True)
+def rcc_shift_estimation(sub_images, pixelSize, box=12):
+    n_bins = sub_images.shape[0]
+    total_pairs = n_bins * (n_bins - 1) // 2
+
+    # Pre-compute all (i,j) pairs and their corresponding linear indices
+    pairs = []
+    for i in range(n_bins - 1):
+        for j in range(i + 1, n_bins):
+            pairs.append((i, j))
+
+    imshift = np.zeros((total_pairs, 2), dtype=np.float32)
+    A = np.zeros((total_pairs, n_bins - 1), dtype=np.float32)
+
+    # Process reference image once
+    origins = {}
+    for i in nb.prange(n_bins - 1):
+        yorigin, xorigin = _process_single_image(
+            sub_images[i], sub_images[i], pixelSize, box
+        )
+        origins[i] = (yorigin, xorigin)
+
+    # Process all pairs
+    for idx in nb.prange(len(pairs)):
+        i, j = pairs[idx]
+        y, x = _process_single_image(sub_images[i], sub_images[j], pixelSize, box)
+        yorigin, xorigin = origins[i]
+        imshift[idx, 0] = xorigin - x
+        imshift[idx, 1] = yorigin - y
+        A[idx, i:j] = 1
+
+    return imshift, A
+
+
+def rcc_solve(imshift, A, n_bins, rmax=10.0):
+    # imshift: (N, 2) or (N, 3)
+    # A: (N, n_bins-1)
+    # use_z: if True, expects imshift.shape[1] == 3
+
+    # Initial solve
+    drift = np.matmul(np.linalg.pinv(A), imshift)
+    error = np.matmul(A, drift) - imshift
+
+    # Compute error magnitude
+    rowerr = np.zeros((A.shape[0], 2))
+    if error.shape[1] == 3:
+        rowerr[:, 0] = np.sqrt(error[:, 0] ** 2 + error[:, 1] ** 2 + error[:, 2] ** 2)
+    else:
+        rowerr[:, 0] = np.sqrt(error[:, 0] ** 2 + error[:, 1] ** 2)
+    rowerr[:, 1] = np.arange(A.shape[0])
+
+    # Sort by error (descending)
+    rowerr = np.flipud(np.sort(rowerr, axis=0))
+
+    # Outlier rejection
+    mask = rowerr[:, 0] > rmax
+    index = rowerr[mask, 1].astype(np.int64)
+
+    # Remove outliers (one by one, check rank)
+    for idx in range(len(index)):
+        flag = int(index[idx])
+        tmp = np.delete(A, flag, axis=0)
+        if np.linalg.matrix_rank(tmp, tol=1) == (n_bins - 1):
+            A = np.delete(A, flag, axis=0)
+            imshift = np.delete(imshift, flag, axis=0)
+            index[index > flag] -= 1
+
+    # Final solve and cumulative sum
+    return np.cumsum(np.matmul(np.linalg.pinv(A), imshift), axis=0)
+
+
+@nb.njit(parallel=True, cache=True)
+def dcc_shift_estimation(sub_images, pixelSize, box=12):
+    n_bins = sub_images.shape[0]
+
+    imshift = np.zeros((n_bins - 1, 2), dtype=np.float32)
+
+    yorigin, xorigin = _process_single_image(
+        sub_images[0], sub_images[0], pixelSize, box
+    )
+    # Process
+    for i in range(1, n_bins):
+        y, x = _process_single_image(sub_images[0], sub_images[i], pixelSize, box)
+        imshift[i - 1, 0] = xorigin - x
+        imshift[i - 1, 1] = yorigin - y
+
+    return imshift
+
+@nb.njit(parallel=True, cache=True)
+def mcc_shift_estimation(sub_images, pixelSize, box=12):
+    n_bins = sub_images.shape[0]
+    total_pairs = n_bins * (n_bins - 1) // 2
+
+    # Pre-compute all (i,j) pairs and their corresponding linear indices
+    pairs = []
+    for i in range(n_bins - 1):
+        for j in range(i + 1, n_bins):
+            pairs.append((i, j))
+
+    imshift = np.zeros((total_pairs, 2), dtype=np.float32)
+    drift = np.zeros((n_bins, 2), dtype=np.float32)
+
+    # Process reference image once
+    origins = {}
+    for i in nb.prange(n_bins - 1):
+        yorigin, xorigin = _process_single_image(
+            sub_images[i], sub_images[i], pixelSize, box
+        )
+        origins[i] = (yorigin, xorigin)
+
+    # Process all pairs
+    for idx in nb.prange(len(pairs)):
+        i, j = pairs[idx]
+        y, x = _process_single_image(sub_images[i], sub_images[j], pixelSize, box)
+        yorigin, xorigin = origins[i]
+        imshift[idx, 0] = xorigin - x
+        imshift[idx, 1] = yorigin - y
+
+    # For each bin, sum the shifts as per MCC
+    for i in nb.prange(n_bins):
+        # Subtract shifts to later bins
+        for j in range(i + 1, n_bins):
+            idx = (i * (2 * n_bins - i - 1)) // 2 + (j - i - 1)
+            drift[i, 0] -= imshift[idx, 0]
+            drift[i, 1] -= imshift[idx, 1]
+        # Add shifts from earlier bins
+        for j in range(i):
+            idx = (j * (2 * n_bins - j - 1)) // 2 + (i - j - 1)
+            drift[i, 0] += imshift[idx, 0]
+            drift[i, 1] += imshift[idx, 1]
+
+
+    drift /= n_bins
+
+    drift[:, 0] -= drift[0, 0]
+    drift[:, 1] -= drift[0, 1]
+
+    return drift

{microeye-2.3.9 → microeye-2.3.11}/src/microEye/analysis/fitting/results.py

@@ -6,6 +6,12 @@ from numpy.core._exceptions import _ArrayMemoryError
 from scipy.interpolate import interp1d
 
 from microEye.analysis.fitting.processing import *
+from microEye.analysis.fitting.rcc import (
+    dcc_shift_estimation,
+    mcc_shift_estimation,
+    rcc_shift_estimation,
+    rcc_solve,
+)
 from microEye.analysis.rendering import BaseRenderer, Projection, RenderModes
 
 UNIQUE_COLUMNS = [
@@ -584,10 +590,16 @@ class FittingResults:
             sub_images.append(image)
             print(f'Bins: {f + 1:d}/{n_bins:d}', end='\r')
 
-        return np.array(sub_images), np.array(frames), np.array(locs_per_bin),
+        return (
+            np.array(sub_images),
+            np.array(frames),
+            np.array(locs_per_bin),
+        )
 
-    def drift_cross_correlation(self, n_bins=10, pixelSize=10, upsampling=100):
-        '''Corrects the XY drift using cross-correlation measurments
+    def drift_cross_correlation(
+        self, n_bins=10, pixelSize=10, upsampling=100, rmax=20, method='phase'
+    ):
+        """Corrects the XY drift using cross-correlation measurments
 
         Parameters
         ----------
@@ -598,12 +610,31 @@ class FittingResults:
         upsampling : int, optional
             phase_cross_correlation upsampling (check skimage.registration),
             by default 100
+        rmax : int, optional
+            Maximum error for redundant cross-correlation, by default 20, should be
+            0.2 of projected pixel size.
+        method : str, optional
+            Drift estimation method, by default 'phase'
+            Options: 'rcc', 'mcc', 'dcc', 'phase'
+
+            - 'rcc' - redundant cross-correlation [1]
+            - 'mcc' - mean cross-correlation [1]
+            - 'dcc' - drift cross-correlation [1]
+            - 'phase' - phase cross-correlation
 
         Returns
         -------
         tuple(FittingResults, np.ndarray)
             returns the drift corrected fittingResults and recontructed image
-        '''
+
+
+        References
+        ----------
+        [1] Yina Wang, Joerg Schnitzbauer, Zhe Hu, Xueming Li, Yifan Cheng,
+            Zhen-Li Huang, and Bo Huang, "Localization events-based sample
+            drift correction for localization microscopy with redundant
+            cross-correlation algorithm," Opt. Express 22, 15982-15991 (2014)
+        """
         unique_frames = np.unique(self.data[DataColumns.FRAME])
         if len(unique_frames) < 2:
             print('Drift cross-correlation failed: no frame info.')
@@ -625,9 +656,7 @@ class FittingResults:
         )
         max_frame = np.max(self.data[DataColumns.FRAME])
 
-        # grouped_data = []
         sub_images = []
-        shifts = []
         frames = []
 
         for f in range(0, n_bins):
@@ -647,23 +676,46 @@ class FittingResults:
             sub_images.append(image)
             print(f'Bins: {f + 1:d}/{n_bins:d}', end='\r')
 
+        sub_images = np.array(sub_images)
+
         print('Shift Estimation ...', end='\r')
         try:
-            shifts = shift_estimation(np.array(sub_images), pixelSize, upsampling)
+            if method == 'rcc':
+                imshift, A = rcc_shift_estimation(sub_images, pixelSize)
+
+                print('Shift Optimization ...', end='\r')
+                drift = rcc_solve(imshift, A, n_bins, rmax=rmax)
+            elif method == 'mcc':
+                drift = mcc_shift_estimation(sub_images, pixelSize)
+            elif method == 'dcc':
+                drift = dcc_shift_estimation(sub_images, pixelSize)
+            elif method == 'phase':
+                drift = shift_estimation(np.array(sub_images), pixelSize, upsampling)
+            else:
+                raise ValueError(f'Unknown drift estimation method: {method}')
         except _ArrayMemoryError as e:
             print(f'Drift cross-correlation failed: {e}')
             return
 
-        shifts = np.c_[shifts, np.array(frames)]
         print('Shift Correction ...', end='\r')
 
+        frames_interp = np.concatenate(([0], np.array(frames), [max_frame - 1]))
+
+        # Prepare drift arrays with padding zeros at start and last value at end
+        base = [
+            0,
+        ] * (1 if method in ['mcc', 'phase'] else 2)
+
+        drift_x = np.concatenate((base, drift[:, 0], [drift[-1, 0]]))
+        drift_y = np.concatenate((base, drift[:, 1], [drift[-1, 1]]))
+
         # An one-dimensional interpolation is applied
         # to drift traces in X and Y dimensions separately.
         interpy = interp1d(
-            shifts[:, -1], shifts[:, 0], kind='quadratic', fill_value='extrapolate'
+            frames_interp, drift_x, kind='cubic', fill_value='extrapolate'
         )
         interpx = interp1d(
-            shifts[:, -1], shifts[:, 1], kind='quadratic', fill_value='extrapolate'
+            frames_interp, drift_y, kind='cubic', fill_value='extrapolate'
         )
         # And this interpolation is used to get the shift at every frame-point
         frames_new = np.arange(0, max_frame, 1)
@@ -848,6 +900,9 @@ class FittingResults:
         drift_x = np.mean(fiducial_markers[:, :, 0], axis=0)
         drift_y = np.mean(fiducial_markers[:, :, 1], axis=0)
 
+        error_bar_x = np.std(fiducial_markers[:, :, 0], axis=0)
+        error_bar_y = np.std(fiducial_markers[:, :, 1], axis=0)
+
         print('Drift correction ...                 ', end='\r')
         ids = np.cumsum(np.bincount(self.data[DataColumns.FRAME].astype(np.int64)))
 
@@ -863,7 +918,7 @@ class FittingResults:
 
         # drift_corrected = FittingResults.fromDataFrame(df, self.pixelSize)
 
-        return self, (unique_frames, drift_x, drift_y)
+        return self, (unique_frames, drift_x, drift_y, error_bar_x, error_bar_y)
 
     def zero_coordinates(self):
         # Use vectorized operations with optional masking

{microeye-2.3.9 → microeye-2.3.11}/src/microEye/analysis/viewer/localizations.py

@@ -488,10 +488,11 @@ class LocalizationsView(QtWidgets.QWidget):
         def work_func(**kwargs):
             try:
                 return self.currentResults.toAnimation(
-                    self.frame_bins.value(), self.xy_binsize.value(),
+                    self.frame_bins.value(),
+                    self.xy_binsize.value(),
                     z_pixel_size=self.z_binsize.value(),
                     projection=Projection(self.projection_cbox.currentData()),
-                    renderMode=RenderModes(self.render_cbox.currentData())
+                    renderMode=RenderModes(self.render_cbox.currentData()),
                 )
             except Exception:
                 traceback.print_exc()
@@ -668,16 +669,24 @@ class LocalizationsView(QtWidgets.QWidget):
         self.drift_cross_up = create_spin_box(
             min_value=0, max_value=1000, initial_value=100
         )
+        self.drift_rmax = create_spin_box(min_value=0, max_value=1000, initial_value=23)
 
         self.drift_cross_args.addWidget(self.drift_cross_bins)
         self.drift_cross_args.addWidget(self.drift_cross_px)
         self.drift_cross_args.addWidget(self.drift_cross_up)
+        self.drift_cross_args.addWidget(self.drift_rmax)
+
+        self.cross_method_cbox = QtWidgets.QComboBox()
+        self.cross_method_cbox.addItem('Phase', 'phase')
+        self.cross_method_cbox.addItem('Direct', 'dcc')
+        self.cross_method_cbox.addItem('Mean', 'mcc')
+        self.cross_method_cbox.addItem('Redundant', 'rcc')
 
         self.drift_cross_btn = QtWidgets.QPushButton(
-            'Drift cross-correlation', clicked=lambda: self.drift_cross()
+            'Drift X-Corr', clicked=lambda: self.drift_cross()
         )
         self.drift_fdm_btn = QtWidgets.QPushButton(
-            'Fiducial marker drift correction', clicked=lambda: self.drift_fdm()
+            'Fiducial markers', clicked=lambda: self.drift_fdm()
         )
 
         # Drift GroupBox
@@ -685,9 +694,15 @@ class LocalizationsView(QtWidgets.QWidget):
         fdrift = QtWidgets.QFormLayout()
         drift.setLayout(fdrift)
 
-        fdrift.addRow(QtWidgets.QLabel('Drift X-Corr. (bins, pixelSize, upsampling):'))
+        fdrift.addRow(
+            QtWidgets.QLabel('Drift X-Corr. (bins, pixelSize, upsampling, rmax):')
+        )
         fdrift.addRow(self.drift_cross_args)
-        fdrift.addRow(create_hbox_layout(self.drift_cross_btn, self.drift_fdm_btn))
+        fdrift.addRow(
+            create_hbox_layout(
+                self.cross_method_cbox, self.drift_cross_btn, self.drift_fdm_btn
+            )
+        )
         # End Drift GroupBox
 
         self.frc_cbox = QtWidgets.QComboBox()
@@ -961,9 +976,7 @@ class LocalizationsView(QtWidgets.QWidget):
             self.currentResults.locY,
             self.currentResults.locZ,
         )
-        self.tardis.startWorker.connect(
-            lambda worker: self._threadpool.start(worker)
-        )
+        self.tardis.startWorker.connect(lambda worker: self._threadpool.start(worker))
         self.tardis.show()
 
     def drift_cross(self):
@@ -974,12 +987,17 @@ class LocalizationsView(QtWidgets.QWidget):
         if len(self.currentResults) <= 0:
             return
 
+        method = self.cross_method_cbox.currentData()
+        label = self.cross_method_cbox.currentText()
+
         def work_func(**kwargs):
             try:
                 return self.currentResults.drift_cross_correlation(
                     self.drift_cross_bins.value(),
                     self.drift_cross_px.value(),
                     self.drift_cross_up.value(),
+                    self.drift_rmax.value(),
+                    method=method,
                 )
             except Exception:
                 traceback.print_exc()
@@ -991,7 +1009,10 @@ class LocalizationsView(QtWidgets.QWidget):
                 self.render_loc()
                 self.currentResults = results[0]
                 self.results_plot.setData(self.currentResults.dataFrame())
-                plot_drift(*results[2])
+                plot_drift(
+                    *results[2],
+                    title=f'{label} Cross-Correlation',
+                )
 
         self.worker = QThreadWorker(work_func)
         self.worker.signals.result.connect(done)
@@ -1019,7 +1040,7 @@ class LocalizationsView(QtWidgets.QWidget):
             if results is not None:
                 self.currentResults = results[0]
                 self.results_plot.setData(self.currentResults.dataFrame())
-                plot_drift(*results[1])
+                plot_drift(*results[1], title='Fiducial Marker Drift Correction')
                 self.render_loc()
 
         self.worker = QThreadWorker(work_func)