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