def test_dpss_mtfft_pt(): nfft = sig.size ntapers = 5 D = libtfr.mfft_dpss(nfft, 3, ntapers, nfft) J = D.mtfft_pt(events, 1, 0) assert_tuple_equal(J.shape, (nfft // 2 + 1, ntapers)) assert_equal(J.dtype, libtfr.CTYPE)
def run_dpss_fft(args): from numpy import sqrt, fft D = libtfr.mfft_dpss(args[0], args[1], args[2], args[0]) E = D.tapers Z = D.tapers_fft(1.0) assert_tuple_equal(Z.shape, (args[2], args[0] // 2 + 1)) assert_array_almost_equal(Z, fft.fft(E, axis=1)[:, :Z.shape[1]])
def test_dpss_mtpsd(): nfft = sig.size ntapers = 5 D = libtfr.mfft_dpss(nfft, 3, ntapers, nfft) Z = D.mtpsd(sig) assert_tuple_equal(Z.shape, (nfft // 2 + 1, )) assert_equal(Z.dtype, libtfr.DTYPE)
def test_dpss_mtfft_pt(): nfft = sig.size ntapers = 5 D = libtfr.mfft_dpss(nfft, 3, ntapers, nfft) J = D.mtfft_pt(events, 1, 0) assert_tuple_equal(J.shape, (nfft//2 + 1, ntapers)) assert_equal(J.dtype, libtfr.CTYPE)
def test_dpss_mtpsd(): nfft = sig.size ntapers = 5 D = libtfr.mfft_dpss(nfft, 3, ntapers, nfft) Z = D.mtpsd(sig) assert_tuple_equal(Z.shape, (nfft//2 + 1,)) assert_equal(Z.dtype, libtfr.DTYPE)
def run_dpss_fft(args): from numpy import sqrt, fft D = libtfr.mfft_dpss(args[0], args[1], args[2], args[0]) E = D.tapers Z = D.tapers_fft(1.0) assert_tuple_equal(Z.shape, (args[2], args[0]//2 + 1)) assert_array_almost_equal(Z, fft.fft(E, axis=1)[:, :Z.shape[1]])
def spectral_derivs(song, freq_range=None, fft_step=None, fft_size=None): """ Return the spectral derivatives of a song. The spectral derivatives are usefull to have a nice representation of the song. To get this plot, use `spectral_derivs_plot`. """ if freq_range is None: freq_range = FREQ_RANGE if fft_step is None: fft_step = FFT_STEP if fft_size is None: fft_size = FFT_SIZE windows = get_windows(song, fft_step, fft_size) nb_windows = windows.shape[0] td = np.zeros((nb_windows, freq_range)) fd = np.zeros((nb_windows, freq_range)) fm = np.zeros(nb_windows) D = libtfr.mfft_dpss(windows.shape[1], 1.5, 2, windows.shape[1]) for i, window in enumerate(windows): Z = D.mtfft(window) td[i, :] = time_der(Z, freq_range) fd[i, :] = freq_der(Z, freq_range) fm[i] = np.arctan(np.max(td[i, :]) / (np.max(fd[i, :]) + EPS)) # TODO vectorize cfm = np.cos(fm) sfm = np.sin(fm) return cfm[:, np.newaxis] * td + sfm[:, np.newaxis] * fd
def test_tgrid(): nfft = 256 shift = 10 ntapers = 5 D = libtfr.mfft_dpss(nfft, 3, ntapers, nfft) Z = D.mtstft(sig, shift) tgrid1 = libtfr.tgrid(sig.size, 1, shift) tgrid2 = libtfr.tgrid(Z, 1, shift)
def test_dpss_mtfft_pt_noevents(): from numpy import zeros_like nfft = sig.size ntapers = 5 D = libtfr.mfft_dpss(nfft, 3, ntapers, nfft) J = D.mtfft_pt([], 1, 0) assert_tuple_equal(J.shape, (nfft//2 + 1, ntapers)) assert_equal(J.dtype, libtfr.CTYPE) assert_array_almost_equal(J, zeros_like(J))
def test_dpss_mtfft_pt_noevents(): from numpy import zeros_like nfft = sig.size ntapers = 5 D = libtfr.mfft_dpss(nfft, 3, ntapers, nfft) J = D.mtfft_pt([], 1, 0) assert_tuple_equal(J.shape, (nfft // 2 + 1, ntapers)) assert_equal(J.dtype, libtfr.CTYPE) assert_array_almost_equal(J, zeros_like(J))
def test_dpss_mtstft(): nfft = 256 shift = 10 ntapers = 5 nframes = (sig.size - nfft) // shift + 1 D = libtfr.mfft_dpss(nfft, 3, ntapers, nfft) Z = D.mtstft(sig, shift) assert_tuple_equal(Z.shape, (nfft // 2 + 1, nframes, ntapers)) assert_equal(Z.dtype, libtfr.CTYPE)
def test_dpss_mtspec(): nfft = 256 shift = 10 ntapers = 5 nframes = (sig.size - nfft) // shift + 1 D = libtfr.mfft_dpss(nfft, 3, ntapers, nfft) Z = D.mtspec(sig, shift) assert_tuple_equal(Z.shape, (nfft//2 + 1, nframes)) assert_equal(Z.dtype, libtfr.DTYPE)
def song_amplitude(song, freq_range=None, fft_step=None, fft_size=None): """Return an array of amplitude values for the whole song.""" windows = get_windows(song, fft_step, fft_size) nb_windows = windows.shape[0] amp = np.zeros(nb_windows) D = libtfr.mfft_dpss(windows.shape[1], 1.5, 2, windows.shape[1]) for i, window in enumerate(windows): P = D.mtpsd(window) amp[i] = amplitude(P, freq_range) return amp
def test_dpss_mtstft_pt(): nfft = 256 shift = 10 ntapers = 5 nframes = (sig.size - nfft) // shift + 1 D = libtfr.mfft_dpss(nfft, 3, ntapers, nfft) Z, Nsp = D.mtstft_pt(events, 1, shift, 0, sig.size) assert_tuple_equal(Z.shape, (nfft // 2 + 1, nframes, ntapers)) assert_equal(Nsp.size, nframes) assert_equal(Z.dtype, libtfr.CTYPE)
def test_dpss_mtstft_pt(): nfft = 256 shift = 10 ntapers = 5 nframes = (sig.size - nfft) // shift + 1 D = libtfr.mfft_dpss(nfft, 3, ntapers, nfft) Z, Nsp = D.mtstft_pt(events, 1, shift, 0, sig.size) assert_tuple_equal(Z.shape, (nfft//2 + 1, nframes, ntapers)) assert_equal(Nsp.size, nframes) assert_equal(Z.dtype, libtfr.CTYPE)
def get_power(signal): """ Return the power of the signal. This method uses multitaper fast fourier transform with two tapers as it is commonly done with bird song analysis. """ D = libtfr.mfft_dpss(len(signal), 1.5, 2, len(signal)) P = D.mtpsd(signal) return P
def test_interpolation(): from numpy import interp, arange nfft1 = 256 nfft2 = nfft1 * 2 ntapers = 5 D1 = libtfr.mfft_dpss(nfft1, 3, ntapers, nfft1) t1 = arange(0, nfft1, 1) t2 = arange(0, nfft1, nfft1 / nfft2) h1_interp = D1.tapers_interpolate(t2, 0, 1) assert_tuple_equal(h1_interp.shape, (ntapers, nfft2)) for i in range(ntapers): assert_array_almost_equal(h1_interp[i], interp(t2, t1, D1.tapers[i]))
def test_dpss_mtstft_pt_noevents(): from numpy import zeros_like events = [] nfft = 256 shift = 10 ntapers = 5 nframes = (sig.size - nfft) // shift + 1 D = libtfr.mfft_dpss(nfft, 3, ntapers, nfft) Z, Nsp = D.mtstft_pt(events, 1, shift, 0, sig.size) assert_tuple_equal(Z.shape, (nfft//2 + 1, nframes, ntapers)) assert_equal(Nsp.size, nframes) assert_equal(Z.dtype, libtfr.CTYPE) assert_array_almost_equal(Z, zeros_like(Z))
def test_dpss_mtstft_pt_noevents(): from numpy import zeros_like events = [] nfft = 256 shift = 10 ntapers = 5 nframes = (sig.size - nfft) // shift + 1 D = libtfr.mfft_dpss(nfft, 3, ntapers, nfft) Z, Nsp = D.mtstft_pt(events, 1, shift, 0, sig.size) assert_tuple_equal(Z.shape, (nfft // 2 + 1, nframes, ntapers)) assert_equal(Nsp.size, nframes) assert_equal(Z.dtype, libtfr.CTYPE) assert_array_almost_equal(Z, zeros_like(Z))
def all_song_features(song, sr, pitch_method=None, pitch_threshold=None, freq_range=None, fft_step=None, fft_size=None): """Return all the song features in a `dict`.""" windows = get_windows(song, fft_step, fft_size) out = defaultdict(lambda: np.zeros(windows.shape[0], dtype=float)) D = libtfr.mfft_dpss(windows.shape[1], 1.5, 2, windows.shape[1]) for i, window in enumerate(windows): Z = D.mtfft(window) P = D.mtpsd(window) out['goodness'][i] = goodness(window, freq_range, D=D.tapers) out['am'][i] = amplitude_modulation(Z, freq_range) out['fm'][i] = frequency_modulation(Z, freq_range) out['amplitude'][i] = amplitude(P, freq_range) out['entropy'][i] = wiener_entropy(P, freq_range) out['rms'][i] = rms(window) if pitch_method == 'fft': out['pitch'][i] = np.argmax(P[0:freq_range])/len(P) * sr if pitch_method != 'fft': out['pitch'] = song_pitch(song, sr, pitch_threshold) else: silent_th = np.percentile(out['amplitude'], 20) out['pitch'][out['amplitude'] < silent_th] = 0 return out
def specgram(signal, sampling_rate, nfft=256, shift=128, compress=1): """ Calculate a spectrogram of signal. Parameters: signal - the input signal (needs to be a 1D array) nfft - the window size, in points shift - how much to shift the window in each frame, in points sampling_rate - the number of samples per second in the signal compress - how much to compress the spectrogram. Effectively sets the floor of the spectrogram at log10(compress) Returns: the spectrogram, the frequency grid, and the time grid """ from numpy import log10 import libtfr # generate a transform object D = libtfr.mfft_dpss(nfft, 3, 5, nfft) # calculate the power spectrogram P = D.mtspec(signal, shift) freq, find = libtfr.fgrid(sampling_rate, nfft) bins = libtfr.tgrid(P, sampling_rate, shift) return (log10(P + compress) - log10(compress), freq, bins)
# -*- coding: utf-8 -*- # -*- mode: python -*- import pstats, cProfile from numpy.random import randn import libtfr sig = randn(17590) D = libtfr.mfft_dpss(256, 3, 5) cProfile.runctx("D.mtspec(sig, 10)", globals(), locals(), "Profile.prof") s = pstats.Stats("Profile.prof") s.strip_dirs().sort_stats("time").print_stats()
def get_mtfft(signal): """Return the two multitaper FFT of the signal.""" D = libtfr.mfft_dpss(len(signal), 1.5, 2, len(signal)) return D.mtfft(signal)