python - tren - transformada discreta de fourier procesamiento de imagenes

Convolución y correlación 2D basadas en FFT en Python

Question

¿Existe una función de correlación cruzada o convolución 2D basada en FFT integrada en scipy (u otra biblioteca popular)?

Hay funciones como estas:

• scipy.signal.correlate2d - "el método directo implementado por convolveND será lento para datos grandes"
• scipy.ndimage.correlate - "La matriz está correlacionada con el kernel dado usando un cálculo exacto (es decir, no FFT)".
• scipy.fftpack.convolve.convolve , que realmente no entiendo, pero me parece mal

numarray tenía una función correlate2d() con un interruptor fft=True , pero supongo que numarray se convirtió en numpy, y no puedo encontrar si esta función estaba incluida.

Answer 1

Creo que quieres el paquete scipy.stsci:

http://docs.scipy.org/doc/scipy/reference/stsci.html

In [30]: scipy.__version__
Out[30]: ''0.7.0''

In [31]: from scipy.stsci.convolve import convolve2d, correlate2d

Answer 2

Encontré scipy.signal.fftconvolve , como también señaló scipy.signal.fftconvolve , pero en ese momento no me di cuenta de que es n- dimensional. Dado que está integrado y produce los valores correctos, parece ser la solución ideal.

De Ejemplo de Convolución 2D :

In [1]: a = asarray([[ 1, 2, 3],
   ...:              [ 4, 5, 6],
   ...:              [ 7, 8, 9]])

In [2]: b = asarray([[-1,-2,-1],
   ...:              [ 0, 0, 0],
   ...:              [ 1, 2, 1]])

In [3]: scipy.signal.fftconvolve(a, b, mode = ''same'')
Out[3]: 
array([[-13., -20., -17.],
       [-18., -24., -18.],
       [ 13.,  20.,  17.]])

¡Correcto! La versión STSCI, por otro lado, requiere un poco de trabajo adicional para corregir los límites.

In [4]: stsci.convolve2d(a, b, fft = True)
Out[4]: 
array([[-12., -12., -12.],
       [-24., -24., -24.],
       [-12., -12., -12.]])

(El método STSCI también requiere compilación, con lo que no tuve éxito (acabo de comentar las partes que no son de python), tiene algunos errores como this y la modificación de las entradas ([1, 2] se convierte en [[1, 2]]), Así que cambié mi respuesta aceptada a la función incorporada fftconvolve() .)

La correlación, por supuesto, es lo mismo que la convolución, pero con una entrada invertida:

In [5]: a
Out[5]: 
array([[3, 0, 0],
       [2, 0, 0],
       [1, 0, 0]])

In [6]: b
Out[6]: 
array([[3, 2, 1],
       [0, 0, 0],
       [0, 0, 0]])

In [7]: scipy.signal.fftconvolve(a, b[::-1, ::-1])
Out[7]: 
array([[ 0., -0.,  0.,  0.,  0.],
       [ 0., -0.,  0.,  0.,  0.],
       [ 3.,  6.,  9.,  0.,  0.],
       [ 2.,  4.,  6.,  0.,  0.],
       [ 1.,  2.,  3.,  0.,  0.]])

In [8]: scipy.signal.correlate2d(a, b)
Out[8]: 
array([[0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0],
       [3, 6, 9, 0, 0],
       [2, 4, 6, 0, 0],
       [1, 2, 3, 0, 0]])

y la última revisión se aceleró mediante el uso de la potencia de dos tamaños internamente (y luego la aceleré más mediante el uso de FFT real para la entrada real y el uso de 5 longitudes suaves en lugar de potencias de 2 : D).

Answer 3

Escribí una envoltura de correlación cruzada / convolución que se encarga del relleno y las nans e incluye una envoltura simple y suave here . No es un paquete popular, pero tampoco tiene dependencias además de numpy (o fftw para ffts más rápidos).

También he implementado un código de prueba de velocidad FFT here en caso de que alguien esté interesado. Esto muestra, sorprendentemente, que los pies cuadrados de Numpy son más rápidos que los de Scipy, al menos en mi máquina.

EDIT: movió el código a la versión N-dimensional here

Answer 4

He perdido el rastro del estado de este paquete en Scipy, pero sé que incluimos ndimage como parte del paquete de lanzamiento stsci_python como una conveniencia para nuestros usuarios:

http://www.stsci.edu/resources/software_hardware/pyraf/stsci_python/current/download

o deberías poder sacarlo del repositorio si prefieres:

https://www.stsci.edu/svn/ssb/stsci_python/stsci_python/trunk/ndimage/

Answer 5

mire scipy.signal.fftconvolve, signal.convolve y signal.correlate (hay una signal.correlate2d pero parece devolver una matriz desplazada, no centrada).