Correlación de fase

Question

¿Cómo se puede determinar el ángulo de rotación mediante la correlación de fase (usando fft) de 2 imágenes? El algoritmo dado en http://en.wikipedia.org/wiki/Phase_correlation devuelve un desplazamiento lineal, no angular. También menciona que las imágenes deben convertirse a coordenadas log-polar para calcular la rotación. ¿Cómo se logra esta conversión en python? Y la conversión posterior ¿realiza los mismos pasos del mantenimiento del algoritmo?

Answer 1

Entrar transformación polar es en realidad la rotación y la escala invariante .. rotación corresponde al cambio en el eje Y y la escala corresponde al cambio en el eje x en el registro de transformación polar

pasos tan simples son los siguientes para encontrar una x en la imagen imagen y:

1. Find imagen x en la imagen y (correlación fase de uso en coordenadas cartesianas)

2. Compute log transformadas polares de tanto x como y (esto es un otro problema conjunto, véase la referencia s abajo), asegúrese de centrarse en la misma característica en ambas imágenes.

3. Find FFT de x e y, dicen F (X) y F (y) correlación de fase

4. Find de F (x) y F (y), llaman R

5. Encuentra el IFFT (FFT inverso) de R. El valor máximo de R corresponde a la desviación de rotación en el eje Y y a la desviación de escala en el eje X desde la imagen original.

Referencias:

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

Answer 2

he estado trabajando en el mismo problema por un tiempo. Tomé el fin de semana para escribir esto. No es el código más limpio que existe, pero solo soy un físico, no un programador ...

La correlación de fase en sí es simple: use su algoritmo de convolución favorito para unir dos imágenes. La posición de pico le proporciona la diferencia de rotación/escala. Está bien explicado en Wikipedia (en el enlace mencionado en la pregunta).

Mi problema era que no pude encontrar un buen convertidor logarítmico, así que escribí uno. No es a prueba de tontos, pero hace el trabajo bien. ¡Cualquiera que esté dispuesto a reescribirlo para hacerlo más claro, por favor hágalo!

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 

Advertencia: Este código está diseñado para imágenes en escala de grises. Puede ser fácilmente un adaptador para trabajar en imágenes en color haciendo un bucle en la línea con map_coordinates() en cada marco de color separado.

EDITAR: Ahora, el código para hacer la correlación es simple. Después de su script ha importado tanto imágenes como image y target, haga lo siguiente:

# 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) 

La matriz correlation debe contener un pico que las coordenadas son la diferencia de tamaño y la diferencia de ángulo.Además, en lugar de utilizar FFT, simplemente puede utilizar la función de np.correlate() numpy:

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

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

Answer 3

Aquí es una implementación: http://www.lfd.uci.edu/~gohlke/code/imreg.py.html. Descubrí que demoran 0.035 segundos en encontrar la similitud entre dos imágenes de 128x128.