znajdź przesunięcie czasowe między dwoma podobnymi przebiegami

Jeśli jeden jest przesunięty w czasie przez drugi, zobaczysz szczyt w korelacji. Ponieważ obliczanie korelacji jest kosztowne, lepiej jest użyć FFT. Więc coś takiego powinno działać:

af = scipy.fft(a)
bf = scipy.fft(b)
c = scipy.ifft(af * scipy.conj(bf))

time_shift = argmax(abs(c))

Ta funkcja jest prawdopodobnie bardziej wydajna dla sygnałów o wartości rzeczywistej. Wykorzystuje on rfft i zero pads wejścia do mocy 2 wystarczająco dużej, aby zapewnić korelację liniową (tj. nieokrągłą): {]}

def rfft_xcorr(x, y):
    M = len(x) + len(y) - 1
    N = 2 ** int(np.ceil(np.log2(M)))
    X = np.fft.rfft(x, N)
    Y = np.fft.rfft(y, N)
    cxy = np.fft.irfft(X * np.conj(Y))
    cxy = np.hstack((cxy[:len(x)], cxy[N-len(y)+1:]))
    return cxy

Wartością zwracaną jest length M = len(x) + len(y) - 1 (połączoną z {[3] } w celu usunięcia dodatkowych zer z zaokrąglenia do potęgi 2). Nieujemne LGD to cxy[0], cxy[1], ..., cxy[len(x)-1], natomiast LGD ujemne to cxy[-1], cxy[-2], ..., cxy[-len(y)+1].

def match(x, ref):
    cxy = rfft_xcorr(x, ref)
    index = np.argmax(cxy)
    if index < len(x):
        return index
    else: # negative lag
        return index - len(cxy)   

In [1]: ref = np.array([1,2,3,4,5])
In [2]: x = np.hstack(([2,-3,9], 1.5 * ref, [0,3,8]))
In [3]: match(x, ref)
Out[3]: 3
In [4]: x = np.hstack((1.5 * ref, [0,3,8], [2,-3,-9]))
In [5]: match(x, ref)
Out[5]: 0
In [6]: x = np.hstack((1.5 * ref[1:], [0,3,8], [2,-3,-9,1]))
In [7]: match(x, ref)
Out[7]: -1

Zależy to od rodzaju posiadanego sygnału (okresowego?... ), czy oba sygnały mają tę samą amplitudę i jakiej precyzji szukasz.

Funkcja korelacji, o której mowa w highBandWidth, może rzeczywiście działać dla Ciebie. Jest to na tyle proste, że powinieneś spróbować.

Inną, bardziej precyzyjną opcją jest ta, której używam do precyzyjnego dopasowania linii widmowej: modelujesz sygnał" master " za pomocą splajnu i dopasowujesz do niego sygnał przesunięty w czasie (podczas gdy prawdopodobnie skalowanie sygnału, w razie potrzeby). Daje to bardzo precyzyjne przesunięcia czasowe. Zaletą tego podejścia jest to, że nie trzeba badać funkcji korelacji. Możesz na przykład łatwo utworzyć splajn za pomocą interpolate.UnivariateSpline() (z SciPy). SciPy zwraca funkcję, która jest następnie łatwo dopasowana do optimize.leastsq ().

Oto inna opcja:

from scipy import signal, fftpack

def get_max_correlation(original, match):
    z = signal.fftconvolve(original, match[::-1])
    lags = np.arange(z.size) - (match.size - 1)
    return ( lags[np.argmax(np.abs(z))] )