Corrélation de phase

Question

Comment l'angle de rotation peut-il être déterminé par corrélation de phase (en utilisant fft) de 2 images? L'algorithme donné en http://en.wikipedia.org/wiki/Phase_correlation renvoie un décalage linéaire, non angulaire. Il mentionne également que les images doivent être converties en coordonnées log-polaires pour calculer la rotation. Comment cette conversion est-elle réalisée en python? Et post-conversion font les mêmes étapes de l'algorithme tenir?

Answer 1

Log transformation polaire est en fait la rotation et l'échelle invariante .. La rotation correspond à décalage dans l'axe y et correspond mise à l'échelle à décalage dans l'axe x dans la transformation log-polaire

étapes Donc simples sont les suivantes pour trouver une image x dans l'image y:

1. Recherche d'image x dans l'image y (utilisation de corrélation de phase en coordonnées cartésiennes)

2. Compute log transformées polaires de x et y (ce qui est un autre problème dans son ensemble, voir référence s ci-dessous), assurez-vous de centrer sur la même fonction dans les deux images.

3. Recherche FFT de x et y, dites F (X) et F (y)

4. Recherche de corrélation de phase de F (x) et F (y), appellent R

5. Trouver l'IFFT (FFT inverse) de R. La valeur de crête de R correspond à l'écart de rotation dans l'axe Y et à l'écart d'échelle dans l'axe X à partir de l'image originale.

Références:

1. http://etd.lsu.edu/docs/available/etd-07072005-113808/unrestricted/Thunuguntla_thesis.pdf

Answer 2

Je travaille sur le même problème pendant un certain temps. J'ai pris le week-end pour écrire ça. Ce n'est pas le code le plus propre, mais je ne suis qu'un physicien, pas un programmeur ...

La corrélation de phase elle-même est simple: utilisez votre algorithme de convolution préféré pour convoluer deux images. La position de crête vous donne la différence de rotation/mise à l'échelle. C'est bien expliqué sur Wikipedia (dans le lien mentionné dans la question). Mon problème était que je ne pouvais pas trouver un bon convertisseur log-polaire, alors j'en ai écrit un. Ce n'est pas infaillible, mais ça fait le travail. Toute personne désireuse de le réécrire pour le rendre plus clair, s'il vous plaît faites-le!

import scipy as sp 
from scipy import ndimage 
from math import * 

def logpolar(input,silent=False): 
    # This takes a numpy array and returns it in Log-Polar coordinates. 

    if not silent: print("Creating log-polar coordinates...") 
    # Create a cartesian array which will be used to compute log-polar coordinates. 
    coordinates = sp.mgrid[0:max(input.shape)*2,0:360] 
    # Compute a normalized logarithmic gradient 
    log_r = 10**(coordinates[0,:]/(input.shape[0]*2.)*log10(input.shape[1])) 
    # Create a linear gradient going from 0 to 2*Pi 
    angle = 2.*pi*(coordinates[1,:]/360.) 

    # Using scipy's map_coordinates(), we map the input array on the log-polar 
    # coordinate. Do not forget to center the coordinates! 
    if not silent: print("Interpolation...") 
    lpinput = ndimage.interpolation.map_coordinates(input, 
              (log_r*sp.cos(angle)+input.shape[0]/2., 
              log_r*sp.sin(angle)+input.shape[1]/2.), 
              order=3,mode='constant') 

    # Returning log-normal... 
    return lpinput 

Avertissement: Ce code est conçu pour les images en niveaux de gris. Il peut facilement être adaptateur pour travailler sur des images couleur en bouclant la ligne avec map_coordinates() sur chaque trame de couleur séparée.

EDIT: Maintenant, le code pour faire la corrélation est simple. Après votre script a importé les images comme image et target, procédez comme suit:

# Conversion to log-polar coordinates 
lpimage = logpolar(image) 
lptarget = logpolar(target) 

# Correlation through FFTs  
Fcorr = np.fft.fft2(lpimage)*np.conj(np.fft.fft2(lptarget)) 
correlation = np.fft.ifft2(Fcorr) 

Le tableau correlation doit contenir un pic dont les coordonnées sont la différence de taille et la différence d'angle.En outre, au lieu d'utiliser TFR, vous pouvez simplement utiliser la fonction de numpy np.correlate():

# Conversion to log-polar coordinates 
lpimage = logpolar(image) 
lptarget = logpolar(target) 

# Correlation 
correlation = np.correlate(lpimage,lptarget) 

Answer 3

est ici une mise en œuvre: http://www.lfd.uci.edu/~gohlke/code/imreg.py.html. J'ai trouvé qu'il faut 0.035 secondes pour trouver la similitude entre deux images 128x128.