convolução 2D baseada em FFT e correlação em Python

Question

Existe uma função baseada em FFT 2D cross-correlação ou convolução embutido no scipy (ou outra biblioteca popular)?

Existem funções como estes:

• scipy.signal.correlate2d - "o método direto implementado por convolveND será lento para grandes volumes de dados "
• scipy.ndimage.correlate - "A matriz está correlacionada com o kernel dada usando cálculo exato (ou seja, não FFT) ".
• scipy.fftpack.convolve.convolve, que eu realmente não entendo, mas parece errado

numarray tinha um correlate2d() função com um interruptor fft=True , mas acho que numarray foi dobrado em numpy, e eu não consigo descobrir se esta função foi incluída.

Answer 1

Eu encontrei scipy.signal.fftconvolve, como também apontado por Magnus , mas não sabia que no momento em que a sua n dimensional. Uma vez que é built-in e produz os valores corretos, parece que a solução ideal.

A partir Exemplo de 2D Convolução :

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.]])

Correto! A versão STScI, por outro lado, requer algum trabalho extra para fazer os limites corrigir?

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

(O método STScI também requer compilação, que não teve sucesso com (eu só comentou as partes não python), tem alguns bugs como este e modificando as entradas ([1, 2] torna-se [[1, 2]]), etc. Então eu mudei minha resposta aceita para o built-in função fftconvolve() .)

Correlação, é claro, é a mesma coisa que convolução, mas com uma 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]])

a última revisão tem sido acelerado usando potência de dois tamanhos internamente (e então eu me apressei-lo mais por usando FFT real para entrada verdadeira e usando comprimentos de 5 lisos em vez de potências de 2 : D)

.

Answer 2

olhada scipy.signal.fftconvolve, signal.convolve e signal.correlate (há uma signal.correlate2d mas parece retornar um array mudou, não centrado).

Answer 3

Eu acho que você quer o pacote 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 4

Eu tenho trilha perdida do status deste pacote em scipy, mas sei que incluem ndimage como parte do pacote de lançamento stsci_python como uma conveniência para nossos usuários:

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

ou você deve ser capaz de puxar-lo a partir do repositório se você prefere:

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

Answer 5

Eu escrevi uma correlação cruzada / convolução invólucro que cuida de preenchimento e nans e inclui um simples suavizar invólucro aqui . Não é um pacote popular, mas também não tem dependências, além de numpy (ou fftw para FFTs mais rápidas).

Eu também tenho implementado uma velocidade FFT testar código aqui no caso de alguém está interessado. Mostra - surpreendentemente -. FFT que de numpy é mais rápido do que de SciPy, pelo menos na minha máquina

EDIT: mudou o código para a versão N-dimensional aqui