def estimate_image_shift(ref, image, roi=None, sobel=True, medfilter=True, hanning=True, plot=False, dtype='float', normalize_corr=False, sub_pixel_factor=1, return_maxval=True): """Estimate the shift in a image using phase correlation This method can only estimate the shift by comparing bidimensional features that should not change the position in the given axis. To decrease the memory usage, the time of computation and the accuracy of the results it is convenient to select a region of interest by setting the roi keyword. Parameters ---------- ref : 2D numpy.ndarray Reference image image : 2D numpy.ndarray Image to register roi : tuple of ints (top, bottom, left, right) Define the region of interest sobel : bool apply a sobel filter for edge enhancement medfilter : bool apply a median filter for noise reduction hanning : bool Apply a 2d hanning filter plot : bool or matplotlib.Figure If True, plots the images after applying the filters and the phase correlation. If a figure instance, the images will be plotted to the given figure. reference : 'current' or 'cascade' If 'current' (default) the image at the current coordinates is taken as reference. If 'cascade' each image is aligned with the previous one. dtype : str or dtype Typecode or data-type in which the calculations must be performed. normalize_corr : bool If True use phase correlation instead of standard correlation sub_pixel_factor : float Estimate shifts with a sub-pixel accuracy of 1/sub_pixel_factor parts of a pixel. Default is 1, i.e. no sub-pixel accuracy. Returns ------- shifts: np.array containing the estimate shifts max_value : float The maximum value of the correlation Notes ----- The statistical analysis approach to the translation estimation when using reference='stat' roughly follows [*]_ . If you use it please cite their article. References ---------- .. [*] Bernhard Schaffer, Werner Grogger and Gerald Kothleitner. “Automated Spatial Drift Correction for EFTEM Image Series.” Ultramicroscopy 102, no. 1 (December 2004): 27–36. """ ref, image = da.compute(ref, image) # Make a copy of the images to avoid modifying them ref = ref.copy().astype(dtype) image = image.copy().astype(dtype) if roi is not None: top, bottom, left, right = roi else: top, bottom, left, right = [ None, ] * 4 # Select region of interest ref = ref[top:bottom, left:right] image = image[top:bottom, left:right] # Apply filters for im in (ref, image): if hanning is True: im *= hanning2d(*im.shape) if medfilter is True: # This is faster than sp.signal.med_filt, # which was the previous implementation. # The size is fixed at 3 to be consistent # with the previous implementation. im[:] = sp.ndimage.median_filter(im, size=3) if sobel is True: im[:] = sobel_filter(im) # If sub-pixel alignment not being done, use faster real-valued fft real_only = (sub_pixel_factor == 1) phase_correlation, image_product = fft_correlation( ref, image, normalize=normalize_corr, real_only=real_only) # Estimate the shift by getting the coordinates of the maximum argmax = np.unravel_index(np.argmax(phase_correlation), phase_correlation.shape) threshold = (phase_correlation.shape[0] / 2 - 1, phase_correlation.shape[1] / 2 - 1) shift0 = argmax[0] if argmax[0] < threshold[0] else \ argmax[0] - phase_correlation.shape[0] shift1 = argmax[1] if argmax[1] < threshold[1] else \ argmax[1] - phase_correlation.shape[1] max_val = phase_correlation.real.max() shifts = np.array((shift0, shift1)) # The following code is more or less copied from # skimage.feature.register_feature, to gain access to the maximum value: if sub_pixel_factor != 1: # Initial shift estimate in upsampled grid shifts = np.round(shifts * sub_pixel_factor) / sub_pixel_factor upsampled_region_size = np.ceil(sub_pixel_factor * 1.5) # Center of output array at dftshift + 1 dftshift = np.fix(upsampled_region_size / 2.0) sub_pixel_factor = np.array(sub_pixel_factor, dtype=np.float64) normalization = (image_product.size * sub_pixel_factor**2) # Matrix multiply DFT around the current shift estimate sample_region_offset = dftshift - shifts * sub_pixel_factor correlation = _upsampled_dft(image_product.conj(), upsampled_region_size, sub_pixel_factor, sample_region_offset).conj() correlation /= normalization # Locate maximum and map back to original pixel grid maxima = np.array(np.unravel_index(np.argmax(np.abs(correlation)), correlation.shape), dtype=np.float64) maxima -= dftshift shifts = shifts + maxima / sub_pixel_factor max_val = correlation.real.max() # Plot on demand if plot is True or isinstance(plot, plt.Figure): if isinstance(plot, plt.Figure): fig = plot axarr = plot.axes if len(axarr) < 3: for i in range(3): fig.add_subplot(1, 3, i + 1) axarr = fig.axes else: fig, axarr = plt.subplots(1, 3) full_plot = len(axarr[0].images) == 0 if full_plot: axarr[0].set_title('Reference') axarr[1].set_title('Image') axarr[2].set_title('Phase correlation') axarr[0].imshow(ref) axarr[1].imshow(image) d = (np.array(phase_correlation.shape) - 1) // 2 extent = [-d[1], d[1], -d[0], d[0]] axarr[2].imshow(np.fft.fftshift(phase_correlation), extent=extent) plt.show() else: axarr[0].images[0].set_data(ref) axarr[1].images[0].set_data(image) axarr[2].images[0].set_data(np.fft.fftshift(phase_correlation)) # TODO: Renormalize images fig.canvas.draw_idle() # Liberate the memory. It is specially necessary if it is a # memory map del ref del image if return_maxval: return -shifts, max_val else: return -shifts
def test_mismatch_offsets_size(): with testing.raises(ValueError): _upsampled_dft(np.ones((4, 4)), 3, axis_offsets=[3, 2, 1, 4])
def test_mismatch_upsampled_region_size(): with testing.raises(ValueError): _upsampled_dft(np.ones((4, 4)), upsampled_region_size=[3, 2, 1, 4])
def imgxfase(img1, img2, ver): rutaImagen = img1 imagenAnalizar = cv2.imread(rutaImagen) image = cv2.cvtColor(imagenAnalizar, cv2.COLOR_BGR2GRAY) shift = (-220.4, 133.32) # The shift corresponds to the pixel offset relative to the reference image #edi offset_image = fourier_shift(np.fft.fftn(image), shift) #edi offset_image = np.fft.ifftn(offset_image) #edi print(f"Known offset (y, x): {shift}") # Valores de entrada rutaImagen = img2 imagenAnalizar = cv2.imread(rutaImagen) imagenGris = cv2.cvtColor(imagenAnalizar, cv2.COLOR_BGR2GRAY) offset_image = cv2.cvtColor(imagenAnalizar, cv2.COLOR_BGR2GRAY) # pixel precision first shift, error, diffphase = phase_cross_correlation(image, offset_image) if (ver.upper() == "Y"): fig = plt.figure(figsize=(8, 3)) ax1 = plt.subplot(1, 3, 1) ax2 = plt.subplot(1, 3, 2, sharex=ax1, sharey=ax1) ax3 = plt.subplot(1, 3, 3) ax1.imshow(image, cmap='gray') ax1.set_axis_off() ax1.set_title('Reference image') ax2.imshow(offset_image.real, cmap='gray') ax2.set_axis_off() ax2.set_title('Offset image') # Show the output of a cross-correlation to show what the algorithm is # doing behind the scenes image_product = np.fft.fft2(image) * np.fft.fft2(offset_image).conj() #image_product = np.fft.fft2(image) * np.fft.fft2(imagenGris).conj() cc_image = np.fft.fftshift(np.fft.ifft2(image_product)) if (ver.upper() == "Y"): ax3.imshow(cc_image.real) ax3.set_axis_off() ax3.set_title("Cross-correlation") plt.show() print("Maximo valor:", abs((cc_image.real.max() - 723190206.0))) #print(f"Detected pixel offset (y, x): {shift}") # subpixel precision shift, error, diffphase = phase_cross_correlation(image, offset_image) data = [] data.append(diffphase) data.append(shift) data.append(error) #print("diffphase :",diffphase) #print("shift:", shift) #print("Error : " , error) if (ver.upper() == "Y"): fig = plt.figure(figsize=(8, 3)) ax1 = plt.subplot(1, 3, 1) ax2 = plt.subplot(1, 3, 2, sharex=ax1, sharey=ax1) ax3 = plt.subplot(1, 3, 3) ax1.imshow(image, cmap='gray') ax1.set_axis_off() ax1.set_title('Reference image') ax2.imshow(offset_image.real, cmap='gray') ax2.set_axis_off() ax2.set_title('Offset image') # Calculate the upsampled DFT, again to show what the algorithm is doing # behind the scenes. Constants correspond to calculated values in routine. # See source code for details. cc_image = _upsampled_dft(image_product, 150, 100, (shift * 100) + 75).conj() if (ver.upper() == "Y"): ax3.imshow(cc_image.real) ax3.set_axis_off() ax3.set_title("Supersampled XC sub-area") plt.show() imx = cc_image.max() #print('max: ',imx) data.append(imx) #print(f"Detected subpixel offset (y, x): {shift}") return data
def phase_cross_correlation( # noqa: C901 reference_image, moving_image, *, upsample_factor=1, space="real", return_error=True, reference_mask=None, border_width=0, extra=False, moving_mask=None, overlap_ratio=0.3): """Efficient subpixel image translation registration by cross-correlation. This code gives the same precision as the FFT upsampled cross-correlation in a fraction of the computation time and with reduced memory requirements. It obtains an initial estimate of the cross-correlation peak by an FFT and then refines the shift estimation by upsampling the DFT only in a small neighborhood of that estimate by means of a matrix-multiply DFT. Parameters ---------- reference_image : array Reference image. moving_image : array Image to register. Must be same dimensionality as ``reference_image``. upsample_factor : int, optional Upsampling factor. Images will be registered to within ``1 / upsample_factor`` of a pixel. For example ``upsample_factor == 20`` means the images will be registered within 1/20th of a pixel. Default is 1 (no upsampling). Not used if any of ``reference_mask`` or ``moving_mask`` is not None. space : string, one of "real" or "fourier", optional Defines how the algorithm interprets input data. "real" means data will be FFT'd to compute the correlation, while "fourier" data will bypass FFT of input data. Case insensitive. Not used if any of ``reference_mask`` or ``moving_mask`` is not None. return_error : bool, optional Returns error and phase difference if on, otherwise only shifts are returned. Has noeffect if any of ``reference_mask`` or ``moving_mask`` is not None. In this case only shifts is returned. reference_mask : ndarray Boolean mask for ``reference_image``. The mask should evaluate to ``True`` (or 1) on valid pixels. ``reference_mask`` should have the same shape as ``reference_image``. moving_mask : ndarray or None, optional Boolean mask for ``moving_image``. The mask should evaluate to ``True`` (or 1) on valid pixels. ``moving_mask`` should have the same shape as ``moving_image``. If ``None``, ``reference_mask`` will be used. overlap_ratio : float, optional Minimum allowed overlap ratio between images. The correlation for translations corresponding with an overlap ratio lower than this threshold will be ignored. A lower `overlap_ratio` leads to smaller maximum translation, while a higher `overlap_ratio` leads to greater robustness against spurious matches due to small overlap between masked images. Used only if one of ``reference_mask`` or ``moving_mask`` is None. Returns ------- shifts : ndarray Shift vector (in pixels) required to register ``moving_image`` with ``reference_image``. Axis ordering is consistent with numpy (e.g. Z, Y, X) error : float Translation invariant normalized RMS error between ``reference_image`` and ``moving_image``. phasediff : float Global phase difference between the two images (should be zero if images are non-negative). References ---------- .. Manuel Guizar-Sicairos, Samuel T. Thurman, and James R. Fienup, "Efficient subpixel image registration algorithms," Optics Letters 33, 156-158 (2008). DOI: 10.1364/OL.33.000156 .. James R. Fienup, "Invariant error metrics for image reconstruction" Optics Letters 36, 8352-8357 (1997). DOI: 10.1364/AO.36.008352 .. Dirk Padfield. Masked Object Registration in the Fourier Domain. IEEE Transactions on Image Processing, vol. 21(5), pp. 2706-2718 (2012). DOI: 10.1109/TIP.2011.2181402 .. D. Padfield. "Masked FFT registration". In Proc. Computer Vision and Pattern Recognition, pp. 2918-2925 (2010). DOI: 10.1109/CVPR.2010.5540032 """ if (reference_mask is not None) or (moving_mask is not None): return _masked_phase_cross_correlation(reference_image, moving_image, reference_mask, moving_mask, overlap_ratio) # images must be the same shape if reference_image.shape != moving_image.shape: raise ValueError("images must be same shape") # assume complex data is already in Fourier space if space.lower() == "fourier": src_freq = reference_image target_freq = moving_image # real data needs to be fft'd. elif space.lower() == "real": src_freq = fft.fftn(reference_image) target_freq = fft.fftn(moving_image) else: raise ValueError('space argument must be "real" of "fourier"') # Whole-pixel shift - Compute cross-correlation by an IFFT shape = src_freq.shape image_product = src_freq * target_freq.conj() if extra: norm = (np.sqrt(src_freq * src_freq.conj() + target_freq * target_freq.conj()) + 1e-10) image_product = image_product / norm image_product = fourier_gaussian(image_product, 5) cross_correlation = fft.ifftn(image_product) if border_width > 0: cross_correlation[:border_width, :] = 0 cross_correlation[-border_width:, :] = 0 cross_correlation[:, :border_width] = 0 cross_correlation[:, -border_width:] = 0 # Locate maximum maxima = np.unravel_index(np.argmax(np.abs(cross_correlation)), cross_correlation.shape) midpoints = np.array([np.fix(axis_size / 2) for axis_size in shape]) shifts = np.array(maxima, dtype=np.float64) shifts[shifts > midpoints] -= np.array(shape)[shifts > midpoints] if upsample_factor == 1: if return_error: src_amp = np.sum(np.abs(src_freq)**2) / src_freq.size target_amp = np.sum(np.abs(target_freq)**2) / target_freq.size CCmax = cross_correlation[maxima] # If upsampling > 1, then refine estimate with matrix multiply DFT else: # Initial shift estimate in upsampled grid shifts = np.round(shifts * upsample_factor) / upsample_factor upsampled_region_size = np.ceil(upsample_factor * 1.5) # Center of output array at dftshift + 1 dftshift = np.fix(upsampled_region_size / 2.0) upsample_factor = np.array(upsample_factor, dtype=np.float64) normalization = src_freq.size * upsample_factor**2 # Matrix multiply DFT around the current shift estimate sample_region_offset = dftshift - shifts * upsample_factor cross_correlation = _upsampled_dft( image_product.conj(), upsampled_region_size, upsample_factor, sample_region_offset, ).conj() cross_correlation /= normalization # Locate maximum and map back to original pixel grid maxima = np.unravel_index(np.argmax(np.abs(cross_correlation)), cross_correlation.shape) CCmax = cross_correlation[maxima] maxima = np.array(maxima, dtype=np.float64) - dftshift shifts = shifts + maxima / upsample_factor if return_error: src_amp = _upsampled_dft(src_freq * src_freq.conj(), 1, upsample_factor)[0, 0] src_amp /= normalization target_amp = _upsampled_dft(target_freq * target_freq.conj(), 1, upsample_factor)[0, 0] target_amp /= normalization # If its only one row or column the shift along that dimension has no # effect. We set to zero. for dim in range(src_freq.ndim): if shape[dim] == 1: shifts[dim] = 0 if return_error: return ( shifts, _compute_error(CCmax, src_amp, target_amp), _compute_phasediff(CCmax), ) else: return shifts
print(f"Detected pixel offset (y, x): {shift}") # subpixel precision shift, error, diffphase = phase_cross_correlation(image, offset_image, 100) fig = plt.figure(figsize=(8, 3)) ax1 = plt.subplot(1, 3, 1) ax2 = plt.subplot(1, 3, 2, sharex=ax1, sharey=ax1) ax3 = plt.subplot(1, 3, 3) ax1.imshow(image, cmap='gray') ax1.set_axis_off() ax1.set_title('Reference image') ax2.imshow(offset_image.real, cmap='gray') ax2.set_axis_off() ax2.set_title('Offset image') # Calculate the upsampled DFT, again to show what the algorithm is doing # behind the scenes. Constants correspond to calculated values in routine. # See source code for details. cc_image = _upsampled_dft(image_product, 150, 100, (shift * 100) + 75).conj() ax3.imshow(cc_image.real) ax3.set_axis_off() ax3.set_title("Supersampled XC sub-area") plt.show() print(f"Detected subpixel offset (y, x): {shift}")