def window(f,start,stop,type='blackman'):
"""
runs the data through a hamming window.
@param f: The data matrix
@param start: The start index of the hamming window.
@param stop: The end index of the hamming window.
"""
h=numpy.zeros(f.shape,dtype=float)
if len(h.shape)==1:
if type=='hamming':
h[start:stop]=signal.hamming(stop-start)
elif type=='blackman':
h[start:stop]=signal.blackman(stop-start)
elif type=='hann':
h[start:stop]=signal.hann(stop-start)
elif type=='blackmanharris':
h[start:stop]=signal.blackmanharris(stop-start)
elif type=='rectangular' or type=='rect' or type=='boxcar':
h[start:stop]=signal.boxcar(stop-start)
else:
if type=='hamming':
h[:,start:stop]=signal.hamming(stop-start)
elif type=='blackman':
h[:,start:stop]=signal.blackman(stop-start)
elif type=='hann':
h[:,start:stop]=signal.hann(stop-start)
elif type=='blackmanharris':
h[:,start:stop]=signal.blackmanharris(stop-start)
elif type=='rectangular' or type=='rect' or type=='boxcar':
h[:,start:stop]=signal.boxcar(stop-start)
return numpy.multiply(f,h)
def test_basic(self):
assert_allclose(signal.hamming(6, False),
[0.08, 0.31, 0.77, 1.0, 0.77, 0.31])
assert_allclose(signal.hamming(6),
[0.08, 0.3978521825875242, 0.9121478174124757,
0.9121478174124757, 0.3978521825875242, 0.08])
assert_allclose(signal.hamming(7, sym=True),
[0.08, 0.31, 0.77, 1.0, 0.77, 0.31, 0.08])
def __init__(self,freq,N_samples):
QtGui.QMainWindow.__init__(self)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.createQtConnections()
self.sample_rate = 2.4e5 ###1e6
#self.decim_r1 = 1e6/2e5 # for wideband fm
self.decim_r2 = 2.4e5/48000 # for baseband recovery
self.center_freq = freq #+250e3
self.gain = 38
self.N_samples = N_samples
self.is_sampling = False
self.spectrogram = np.zeros((328,200))
self.chspectrogram = np.zeros((328,200))
self.plspectrogram = np.zeros((164,200))
self.sdr = RtlSdr()
#self.sdr.direct_sampling = 1
self.sdr.sample_rate = self.sample_rate
self.sdr.center_freq = self.center_freq
self.sdr.gain = self.gain
self.pa = pyaudio.PyAudio()
self.stream = self.pa.open( format = pyaudio.paFloat32,
channels = 2,
rate = 48000,
output = True)
adj = 0
hamming = np.kaiser(self.N_samples/4 + adj,1)
lpf = np.append( np.zeros(self.N_samples*3/8),hamming)
self.lpf = np.fft.fftshift(np.append(lpf,np.zeros(self.N_samples*3/8))) #,int(-.25*self.N_samples))
hamming = 10*signal.hamming(self.N_samples/16)
lpf = np.append(np.zeros(self.N_samples*15/32),hamming)
self.lpf_s1 = (np.append(lpf,np.zeros(int(self.N_samples*15/32))))
#self.lpf_s1 = np.roll(temp,int(.5*self.N_samples*67/120))
#self.lpf_s1 += np.roll(temp,int(-.5*self.N_samples*67/120))
self.lpf_s1 = np.fft.fftshift(self.lpf_s1)
#self.lpf_s1 += np.fft.fftshift(self.lpf_s1)
# fig = plt.figure()
# ax = fig.add_subplot(111)
# ax.plot(range(self.lpf_s1.size),self.lpf_s1)
# fig.show()
hamming = 10*signal.hamming(self.N_samples/32)
lpf = np.append(np.zeros(self.N_samples*31/64),hamming)
self.lpf_s2 = (np.append(lpf,np.zeros(int(self.N_samples*31/64))))
#self.lpf_s2 = np.roll(temp,int(.5*self.N_samples*92/120))
#self.lpf_s2 += np.roll(temp,int(-.5*self.N_samples*92/120))
self.lpf_s2 = np.fft.fftshift(self.lpf_s2)
def read_data_thread(rf_q,ad_rdy_ev,audio_q):
print("read data thread start")
pre_data=0
#filter design
#FIR_LP = signal.firwin(19,17e3,1e3,window='hamming',True,False,RFRATE/2)
#FIR_LP = signal.firwin(19,400e3/(RFRATE/2))
#FIR_LP = signal.firwin(9,10e3/(AUDIORATE/2))
rfwindow = signal.hamming(RFSIZE)
audiowindow = signal.hamming(AUDIOSIZE)
fftwindow = signal.hamming(512)
ad_rdy_ev.wait(timeout=5000)
np.save("data",rf_q.get())
while 0:
ad_rdy_ev.wait(timeout=1000)
while not rf_q.empty():
#process data here
data=rf_q.get()
#data=signal.decimate(data,DOWN_FACTOR,ftype="fir")
#data = signal.lfilter(FIR_LP,1.0,data)
#demod method 1
angle_data=np.angle(data)
audioda=np.diff(angle_data)
audiodata=np.insert(audioda,0,angle_data[0]-pre_data)
pre_data=angle_data[-1]
audiodata=np.unwrap(audiodata,np.pi)
#demod method 2
#data_delay=np.insert(data,0,pre_data)
#pre_data = data_delay[-1]
#data_delay=np.delete(data_delay,-1)
#diff_data=data*np.conj(data_delay)
#audiodata=np.angle(diff_data)
#audiodata=np.unwrap(audiodata)
#demod method 3
#diff_data=np.diff(data)
#diff_data=np.insert(diff_data,0,data[0]-pre_data)
#pre_data=data[-1]
#audiodata=data.real*diff_data.imag-data.imag*diff_data.real
#audiodata=audiodata/(np.power(data.real,2)+np.power(data.imag,2))
#audiodata=audiodata*10
audiodata=signal.decimate(audiodata,DOWN_FACTOR,ftype="fir")
#audiodata = signal.lfilter(FIR_LP,1.0,audiodata)
audiodata_amp=audiodata*1e4
snd_data = audiodata_amp.astype(np.dtype('<i2')).tostring()
audio_q.put(snd_data)
ad_rdy_ev.clear()
print("read data thread ended")
def test_basic(self):
assert_allclose(signal.hamming(6, False),
[0.08, 0.31, 0.77, 1.0, 0.77, 0.31])
assert_allclose(signal.hamming(7, sym=False),
[0.08, 0.2531946911449826, 0.6423596296199047,
0.9544456792351128, 0.9544456792351128,
0.6423596296199047, 0.2531946911449826])
assert_allclose(signal.hamming(6),
[0.08, 0.3978521825875242, 0.9121478174124757,
0.9121478174124757, 0.3978521825875242, 0.08])
assert_allclose(signal.hamming(7, sym=True),
[0.08, 0.31, 0.77, 1.0, 0.77, 0.31, 0.08])
def enframe(self, datas, fs, frame_len, frame_inc, win):
'''
' datas: 语音数据
' fs: 采样频率
' frame_len: 帧长，单位秒
' frame_inc: 帧移，单位秒
' win: 窗函数
'''
datas_len = len(datas) # 数据总长度
frame_len = int(round(frame_len * fs)) # 帧长，数据个数
nstep = frame_len - int(round(frame_inc * fs)) # 帧移动步长，数据个数
if datas_len < frame_len: # 若信号长度小于帧长，则帧数定义为1
nf = 1
else:
nf = int(np.ceil((1.0*datas_len-frame_len)/nstep)) + 1
pad_len = int((nf-1)*nstep + frame_len) # 所有帧总数据长度
# 多余的数据使用0填充
new_datas = np.concatenate((datas, np.zeros(pad_len - datas_len)))
indices = np.tile(np.arange(0,frame_len),(nf,1))+np.tile(np.arange(0,nf*nstep,nstep),(frame_len,1)).T
indices = np.array(indices, dtype = np.int32) # 否则会报类型错误
frames = new_datas[indices] #得到帧信号
# 加窗
if win == 'hamming':
win = signal.hamming(frame_len)
elif win == 'hanning':
win = signal.hanning(frame_len)
else:
win = signal.boxcar(frame_len)
return frames * np.tile(win, (nf, 1))
def __init__(self,freq,N_samples):
self.sample_rate = 1e6
self.decim_r1 = 1e6/2e5 # for wideband fm
self.decim_r2 = 2e5/44100 # for baseband recovery
self.center_freq = freq+250e3
self.gain = 36
self.N_samples = N_samples
self.sdr = RtlSdr()
self.sdr.direct_sampling = 1
self.sdr.sample_rate = self.sample_rate
self.sdr.center_freq = self.center_freq
self.sdr.gain = 'auto' #self.gain
self.pa = pyaudio.PyAudio()
self.stream = self.pa.open( format = pyaudio.paFloat32,
channels = 2,
rate = 44100,
output = True)
adj = 0
hamming = 10*signal.hamming(self.N_samples*.10 + adj)
lpf = np.append( np.zeros(self.N_samples*.45),hamming)
self.lpf = np.roll(np.fft.fftshift(np.append(lpf,np.zeros(self.N_samples*.45))),int(-.25*self.N_samples))
def mfcc(samples, winlen, winshift, nfft, nceps, samplingrate):
"""Computes Mel Frequency Cepstrum Coefficients.
Args:
samples: array of speech samples with shape (N,)
winlen: lenght of the analysis window
winshift: number of samples to shift the analysis window at every time step
nfft: length of the Fast Fourier Transform (power of 2, grater than winlen)
nceps: number of cepstrum coefficients to compute
samplingrate: sampling rate of the original signal
Note: for convenienve, you can define defaults for the input arguments that fit the exercise
Returns:
ceps: N x nceps array with one MFCC feature vector per row
mspec: N x M array of outputs of the Mel filterbank (of size M)
spec: N x nfft array with squared absolute fast Fourier transform
"""
enframes = enframe(samples, winlen, winshift)
# preemp_signal = map(lambda x: preemp(x, 0.97), enframes)
preemp_signal = preemp(enframes, p=0.97)
hamWindow = hamming(winlen, False)
ham_signal = helper.combineHam(preemp_signal, hamWindow)
if not nfft:
nfft = 512
spec, logspec_fft = fft(ham_signal, nfft);
bank1 = tools.trfbank(samplingrate, nfft);
mspec = helper.melSpec(spec, bank1)
spec_dct = helper.cosineTransform(mspec)
ceps = spec_dct[:, :nceps]
return (spec, mspec, ceps)
def CQT_fast(x,fs,bins,fmin,fmax,M): threshold = 0.0054 #for Hamming window K = int(bins*np.ceil(np.log2(fmax/fmin))) Q = 1/(2**(1/bins)-1) nfft = np.int32(nearestPow2(np.ceil(Q*fs/fmin))) tempKernel = np.zeros(nfft, dtype = np.complex) specKernel = np.zeros(nfft, dtype = np.complex) sparKernel = [] #create sparse Kernel for k in range(K-1,-1,-1): fk = (2**(k/bins))*fmin N = np.int32(np.round((Q*fs)/fk)) tempKernel[:N] = hamming(N)/N * np.exp(-2*np.pi*1j*Q*np.arange(N)/N) specKernel = fft(tempKernel) specKernel[np.where(np.abs(specKernel) <= threshold)] = 0 if k == K-1: sparKernel = specKernel else: sparKernel = np.vstack((specKernel, sparKernel)) sparKernel = np.transpose(np.conjugate(sparKernel))/nfft ft = fft(x,nfft) cqt = np.dot(ft, sparKernel) ft = fft(x,nfft*(2**M)) #calculate harmonic power spectrum #harm_pow = HPS(ft,M) #cqt = np.dot(harm_pow, sparKernel) return cqt
def setUp(self):
path = join(dirname(__file__), "data")
# setting up sliding window data
data_z = np.loadtxt(join(path, "MBGA_Z.ASC"))
data_e = np.loadtxt(join(path, "MBGA_E.ASC"))
data_n = np.loadtxt(join(path, "MBGA_N.ASC"))
n = 256
fs = 75
inc = int(0.05 * fs)
self.data_win_z, self.nwin, self.no_win = util.enframe(data_z, signal.hamming(n), inc)
self.data_win_e, self.nwin, self.no_win = util.enframe(data_e, signal.hamming(n), inc)
self.data_win_n, self.nwin, self.no_win = util.enframe(data_n, signal.hamming(n), inc)
# global test input
self.fk = [2, 1, 0, -1, -2]
self.norm = pow(np.max(data_z), 2)
self.res = np.loadtxt(join(path, "3cssan.hy.1.MBGA_Z"))
def mteo (x, k_values):
"""
Multi resolution Teagre Energy Operator
Parameters
----------
x : ndarray
The raw signal
k_values : ndarray
The values of k to use for estimating MTEO
Returns
-------
tem : ndarray
The operated signal
"""
from scipy.signal import hamming
from scipy.signal import lfilter
teo_k_wise = np.zeros((len(k_values), len(x)))
for i in range(len(k_values)):
teo_k_wise[i, :] = teo(x, k_values[i])
variance = np.var(teo_k_wise[i, :])
window = hamming(4*k_values[i] + 1)
teo_k_wise[i, :] = lfilter(window, 1, teo_k_wise[i, :]) / variance
tem = np.max(teo_k_wise, axis=0)
return tem
def unsharp_masking(X):
lp = np.array(X)
for i, ws in zip([0, 1, 2], [50, 50, 25]):
h = hamming(ws)
h /= h.sum()
convolve1d(lp, h, axis=i, output=lp)
return X - lp
def filter_csd(self):
'''Spatial filtering of the CSD estimate, using an N-point filter'''
if not self.f_order > 0 and type(self.f_order) == type(3):
raise Exception, 'Filter order must be int > 0!'
if self.f_type == 'boxcar':
num = ss.boxcar(self.f_order)
denom = pl.array([num.sum()])
elif self.f_type == 'hamming':
num = ss.hamming(self.f_order)
denom = pl.array([num.sum()])
elif self.f_type == 'triangular':
num = ss.triang(self.f_order)
denom = pl.array([num.sum()])
elif self.f_type == 'gaussian':
num = ss.gaussian(self.f_order[0], self.f_order[1])
denom = pl.array([num.sum()])
else:
raise Exception, '%s Wrong filter type!' % self.f_type
num_string = '[ '
for i in num:
num_string = num_string + '%.3f ' % i
num_string = num_string + ']'
denom_string = '[ '
for i in denom:
denom_string = denom_string + '%.3f ' % i
denom_string = denom_string + ']'
print 'discrete filter coefficients: \nb = %s, \na = %s' % \
(num_string, denom_string)
self.csd_filtered = pl.empty(self.csd.shape)
for i in xrange(self.csd.shape[1]):
self.csd_filtered[:, i] = ss.filtfilt(num, denom, self.csd[:, i])
def data_w_hamm(dt,frame=256):
temp = []
_t = sig.hamming(frame)
fx = frame*0.5
#temp = [sum(np.array(dt[x*fx:x*fx+frame]*_t)**2) for x in range(int(len(dt)/fx -1))]
temp = [np.log(sum(np.abs(dt[x*fx:x*fx+frame]*_t))) for x in range(int(len(dt)/fx -1))]
return temp
def __init__(self, clip, window=1024, step=None, n=None):
"""Compute the short-time Fourier transform on a 1-dimensional array
*signal*, with the specified *window* size, *step* size, and
*n*-resolution FFT.
This function returns a 2-dimensional array of complex floats. The
0th dimension is time (window steps) and the 1th dimension is
frequency.
"""
if clip is None:
return
if step is None:
step = window / 2
if n is None:
n = window
signal = clip.signal
self.params = (window, step, n, clip.nyq)
if signal.ndim != 1:
raise ValueError("signal must be a 1-dimensional array")
length = signal.size
num_windows = _num_windows(length, window, step)
out = np.zeros((num_windows, n), dtype=np.complex64)
taper = hamming(window)
for (i, s) in enumerate(window_slice_iterator(length, window, step)):
out[i, :] = np.fft.fft(signal[s] * taper, n)
self.data = out
def plot_specgram(ax, data, fs, nfft=256, noverlap=128, window='hann',
cmap='jet', interpolation='bilinear', rasterized=True):
if window not in SPECGRAM_WINDOWS:
raise ValueError("Window not supported")
elif window == "boxcar":
mwindow = signal.boxcar(nfft)
elif window == "hamming":
mwindow = signal.hamming(nfft)
elif window == "hann":
mwindow = signal.hann(nfft)
elif window == "bartlett":
mwindow = signal.bartlett(nfft)
elif window == "blackman":
mwindow = signal.blackman(nfft)
elif window == "blackmanharris":
mwindow = signal.blackmanharris(nfft)
specgram, freqs, time = mlab.specgram(data, NFFT=nfft, Fs=fs,
window=mwindow,
noverlap=noverlap)
specgram = 10 * np.log10(specgram[1:, :])
specgram = np.flipud(specgram)
freqs = freqs[1:]
halfbin_time = (time[1] - time[0]) / 2.0
halfbin_freq = (freqs[1] - freqs[0]) / 2.0
extent = (time[0] - halfbin_time, time[-1] + halfbin_time,
freqs[0] - halfbin_freq, freqs[-1] + halfbin_freq)
ax.imshow(specgram, cmap=cmap, interpolation=interpolation,
extent=extent, rasterized=rasterized)
ax.axis('tight')
def STIFT(stft_windows, nfft, nskip):
"Sum contributions from each window. No normalization."
r = np.zeros(nskip * (len(stft_windows) - 1) + nfft)
h = hamming(nfft)
for w, w_0 in zip(stft_windows, xrange(0, r.size, nskip)):
r[w_0 : w_0+nfft] += irfft(w, nfft) * h
return r
def hamming(self, cutoff): """Filter the data using a hamming filter and store the values in filteredseries""" for i in range(len(self.recarray[0])): fil = signal.hamming(cutoff) output = signal.convolve(self.recarray[:,i], fil, mode='same') self.filteredseries[:,i] = output return self.filteredseries
def __window_data(data):
# Apply window function to the decoded data & store as new key:value pair in dictionary
# Parameters: data: [{'frame_data': string,
# 'frame_count': int,
# 'frame_time': float,
# 'frame_position': int,
# 'frame_decoded': numpy.ndarray}, ...]
# cache window function
if 'hann' == config_analysis.frame_window:
window = signal.hann(config_audio.frames_per_buffer)
elif 'hamming' == config_analysis.frame_window:
window = signal.hamming(config_audio.frames_per_buffer)
elif 'blackman' == config_analysis.frame_window:
window = signal.blackman(config_audio.frames_per_buffer)
elif 'bartlett' == config_analysis.frame_window:
window = signal.bartlett(config_audio.frames_per_buffer)
elif 'barthann' == config_analysis.frame_window:
window = signal.barthann(config_audio.frames_per_buffer)
else:
# window function unavailable
return
# apply specified window function in config
for i in range(len(data)):
data[i]['frame_windowed'] = data[i]['frame_decoded'][:] * window
def freqAnalyze(self): print "freqAnalyze" if len(self.speechSegment)==0 or self.isBlank==True: return self.shortTimeLinjieVector = [] self.formant = [] self.fftFrameAbs = [] #短时谱的临界带特征矢量 F = [0] fs = self.sampleRate/self.frameSize for i in range(1,19): m = int((i+0.53)*1960/(26.81-0.53-i)) n = m/fs F.append(n) self.formantValue = [] self.frameSize/2+1 self.fftFrame = [] #h1,f1 = signal.freqz([1,-0.98],[1]) #cc = 0 for frame in self.frame[:-1]: #窗函数 #cc = cc+1 f = frame*signal.hamming(self.frameSize,sym=0) #预加重 #f = scipy.signal.lfilter([1,-0.97],1,f) fftFrame = np.fft.rfft(f)/(self.frameSize/2) self.fftFrame.append(fftFrame) fftFrameAbs = [abs(fft) for fft in fftFrame] self.fftFrameAbs.append(fftFrameAbs) #短时谱临界带特征矢量 '''
def fourier_transform_and_reconstruct(image, detrend=False, window=False,
ffunc=None):
"""
Take fourier transform, alter it, and reconstruct image. For some
reason this is shifting the origin by 1 pixel after reconstruction, which
should not happen.
:param image: data
:type image: :py:class:`numpy.ndarray`
:param ffunc: function that alters FFT matrix
:type ffunc: func
:return: modified image data
:rtype: :py:class:`numpy.ndarray`
"""
if window:
w = signal.hamming(image.shape)
else:
w = np.ones_like(image)
if detrend:
f = fftpack.fft(w * signal.detrend(image))
else:
f = fftpack.fft(w * image)
# alter the fft
if not ffunc is None:
f = ffunc(f)
result = np.fliplr(fftpack.fft(f))
return result > result.mean()
def get_mfcc_means(cough_wavs): """ Calculate the means of the 13 MFCCs over all the coughs in cough_wavs """ # Get audio of all coughs in recording audio_data = [read(wav)[1] for wav in cough_wavs] # Apply hamming window audio_H = [wav*hamming(len(wav)) for wav in audio_data] audio_H = np.array([item for sublist in audio_H for item in sublist]) audio_data = np.array([item for sublist in audio_data for item in sublist]) plt.subplot(2,1,1) plt.plot(audio_data) plt.subplot(2,1,2) plt.plot(audio_H) plt.show() exit() mfccs = librosa.feature.mfcc(audio_data, sr=fs, n_mfcc=13, n_fft =h, hop_length=r) means = list(np.mean(mfccs,axis=1)) return means
def mfcc(self, x, Fs, win, hop, nfft, CC):
'''Mel-Frequency cepstral coefficients of a signal
x := signal
Fs := sampling rate
win := window size
hop := hop size
nfft := fft size
CC := number of coefficients'''
#filterbank parameters
lowestFrequency = 133.3333
linearFilters = 13
linearSpacing = 200./3
logFilters = 27
logSpacing = 1.0711703
totalFilters = linearFilters + logFilters
w = sig.hamming(win)
seg = np.zeros((np.ceil(len(x)/float(hop)), win))
i = 0
pin = 0
pend = len(x) - win
while pin < pend:
seg[i, 0:win] = x[pin:pin+win] * w
i += 1
pin += hop
preEmp = sig.lfilter(np.array([1, -.97]), 1, seg)
fbank = self.trfbank(Fs, nfft, lowestFrequency, linearSpacing, logSpacing, linearFilters, logFilters)[0]
fftMag = np.abs(fftpack.fft(preEmp, nfft, axis=-1))
earMag = np.log10(np.inner(fftMag, fbank) + 0.0000000001)
ceps = fftpack.realtransforms.dct(earMag, type=2, norm='ortho', axis=-1)[:, 0:CC]
return ceps, earMag
def spectrogramme_inv(Spectro,Phase,Fs,Tau,hopsize,win):
X = Spectro * np.exp(1j*Phase)
[Nf,Nt] = X.shape
Nw=np.round(Tau * Fs)
R = np.round(hopsize * Nw)
if win=='h':
w = signal.hamming(Nw, sym=True)
elif win=='b':
w = signal.blackman(Nw, sym=True)
else:
w = np.ones(Nw)
I = np.round(hopsize * Nw)
M = 2 * (Nf-1)
L = np.ceil( (Nt-1)*I + M )
y = np.zeros([L,1])
aux_window = ola(np.power(w,2),R, Nt)
window=np.sqrt((1/np.max(aux_window))*np.power(w,2))
y_aux=np.zeros([Nw,1])
for r in range(0, Nt):
deb = (r)*R
fin = deb + Nw
Xtilde_inv = ifft(X[:,r])
y_aux[:,0] = Xtilde_inv*window
y[deb:fin,0]=y[deb:fin,0]+y_aux[:,0]
return y
def dip(peak, smooth=True):
""" Run a dip test.
The diptest can be used to test if a distribution is unimodal. In order to
get it to work, I have to turn the peak signal into a distribution by
simulating, and then run the test on the simulated data. This is a little
hackish, there is probably a better/faster way.
"""
# Smooth distribution using hamming
if smooth:
smooth = signal.convolve(peak, signal.hamming(10))
else:
smooth = peak
# Set up x's
x_grid = np.arange(0, smooth.shape[0])
# Normalize the peak section to sum to 1
norm = smooth / smooth.sum()
# Simulate data from the peak distribution
sim = choice(x_grid, size=3000, replace=True, p=norm)
# Run diptest
test, pval = diptest(sim)
return test, pval
def get_mfcc(path):
"""Finds the MFCCs and FFTs of a WAVE file.
Args:
path: The path to a WAVE file.
Returns:
A tuple of two iterables, the FFTs and MFCCs of the frames of the
WAVE file.
"""
global COMP_FRAME_SIZE
# Read the file, and determine its length in frames
(sample, data) = utils.read_wave_from_file(path)
total_frames = (data.size / sample) / COMP_FRAME_SIZE
step = COMP_FRAME_SIZE * sample
window = hamming(step)
# Allocate space for the FFT decompositions of each frame of sound data
fft_out = []
mfcc_out = []
# Loop invariant:
# 0 <= frame_index <= total_frames
# results in an array (fft_out) of FFTs that correspond to the
# frames of the WAVE file
filterbank_cache = {}
frame_index = 0
while frame_index + (1 - FRAME_OVERLAP_FACTOR) < total_frames:
# Obtain the frame_indexth frame from the data
frame = data[frame_index * step : (frame_index + 1) * step]
# Generate the FFT of the frame windowed by the hamming window
frame_fft = numpy.fft.rfft(frame * window, n=256)
frame_fft[frame_fft == 0] = 0.000003
nfft = len(frame_fft)
# Compute the mel triangular filterbank or get a cached version
fb_key = (sample, nfft)
if fb_key in filterbank_cache:
filterbank = filterbank_cache[fb_key]
else:
filterbank = triangular_filters(sample, nfft).T
filterbank[filterbank == 0] = 0.00003
filterbank_cache[fb_key] = filterbank
# The power spectrum of the frame
power_spectrum = numpy.abs(frame_fft)
# Filtered by the mel filterbank
mel_power_spectrum = numpy.log10(numpy.dot(power_spectrum, filterbank))
# With the discrete cosine transform to find the cepstrum
cepstrum = dct(mel_power_spectrum, type=2, norm="ortho", axis=-1)
fft_out.append(frame_fft)
mfcc_out.append(cepstrum[: int(len(cepstrum) * SIGNIFICANT_MFCC)])
frame_index = frame_index + FRAME_OVERLAP_FACTOR
return numpy.array(mfcc_out)
def get_ir(self, sz, wd=50):
x = fftfreq2(sz, 1.0/self.rate)
ir = np.real(fft.ifft(mps(spectrum2fft(self(x)),0,0),axis=0))
if wd:
w = sig.hamming(2*wd)[-wd:]
for i in range(ir.shape[1]):
ir[-wd:,i] *= w
return ir
def _make_window(self):
hlength = np.floor(self.n_fbins / 4.0)
if hlength % 2 == 0:
hlength += 1
from scipy.signal import hamming
fwindow = hamming(hlength)
lh = (fwindow.shape[0] - 1) / 2
return fwindow / fwindow[lh]
def srmr(x, fs, n_cochlear_filters=23, low_freq=125, min_cf=4, max_cf=128, fast=True, norm=False):
wLengthS = .256
wIncS = .064
# Computing gammatone envelopes
if fast:
mfs = 400.0
gt_env = fft_gtgram(x, fs, 0.010, 0.0025, n_cochlear_filters, low_freq)
else:
cfs = centre_freqs(fs, n_cochlear_filters, low_freq)
fcoefs = make_erb_filters(fs, cfs)
gt_env = np.abs(hilbert(erb_filterbank(x, fcoefs)))
mfs = fs
wLength = np.ceil(wLengthS*mfs)
wInc = np.ceil(wIncS*mfs)
# Computing modulation filterbank with Q = 2 and 8 channels
mod_filter_cfs = compute_modulation_cfs(min_cf, max_cf, 8)
MF = modulation_filterbank(mod_filter_cfs, mfs, 2)
n_frames = 1 + (gt_env.shape[1] - wLength)//wInc
w = hamming(wLength+1)[:-1] # window is periodic, not symmetric
energy = np.zeros((n_cochlear_filters, 8, n_frames))
for i, ac_ch in enumerate(gt_env):
mod_out = modfilt(MF, ac_ch)
for j, mod_ch in enumerate(mod_out):
mod_out_frame = segment_axis(mod_ch, wLength, overlap=wLength-wInc, end='pad')
energy[i,j,:] = np.sum((w*mod_out_frame[:n_frames])**2, axis=1)
if norm:
energy = normalize_energy(energy)
erbs = np.flipud(calc_erbs(low_freq, fs, n_cochlear_filters))
avg_energy = np.mean(energy, axis=2)
total_energy = np.sum(avg_energy)
AC_energy = np.sum(avg_energy, axis=1)
AC_perc = AC_energy*100/total_energy
AC_perc_cumsum=np.cumsum(np.flipud(AC_perc))
K90perc_idx = np.where(AC_perc_cumsum>90)[0][0]
BW = erbs[K90perc_idx]
cutoffs = calc_cutoffs(mod_filter_cfs, fs, 2)[0]
if (BW > cutoffs[4]) and (BW < cutoffs[5]):
Kstar=5
elif (BW > cutoffs[5]) and (BW < cutoffs[6]):
Kstar=6
elif (BW > cutoffs[6]) and (BW < cutoffs[7]):
Kstar=7
elif (BW > cutoffs[7]):
Kstar=8
return np.sum(avg_energy[:, :4])/np.sum(avg_energy[:, 4:Kstar]), energy
def _conv_window_fn(self, sig):
duration = 1.0 / sig.get_rate() * sig.get_signal_length()
base_duration = 0.2
window_width = 15.0 * duration / base_duration
#sigma = 3.0 * duration / base_duration
#conv_window = spsignal.general_gaussian(window_width, 1, sigma)
conv_window = spsignal.hamming(window_width, False)
return conv_window
ani = animation.FuncAnimation(fig,
plot_update,
init_func=plot_init,
frames=1,
interval=30,
blit=True)
q = queue.Queue()
#rtlsdr
sdr = RtlSdr()
#processing block
window = signal.hamming(SIZE)
def read_data_thread(q, ad_rdy_ev):
global rt_data, fft_data
#while stream.is_active():
while 1:
ad_rdy_ev.wait(timeout=1000)
if not q.empty():
#process audio data here
data = q.get()
#print(' signal mean:', sum(data)/len(data))
while not q.empty():
q.get()
rt_data = np.real(data)
def data_feeder_training(window_size, fft_size, hop_size, seq_length,
context_length, batch_size, files_per_pass, debug):
"""Provides an iterator over the training examples.
:param window_size: The window size to be used for the time-frequency transformation.
:type window_size: int
:param fft_size: The size of the FFT in samples.
:type fft_size: int
:param hop_size: The hop size in samples.
:type hop_size: int
:param seq_length: The sequence length in frames.
:type seq_length: int
:param context_length: The context length in frames.
:type context_length: int
:param batch_size: The batch size.
:type batch_size: int
:param files_per_pass: How many files per pass.
:type files_per_pass: int
:param batch_size: The batch size.
:type batch_size: int
:param files_per_pass: How many files per pass.
:type files_per_pass: int
:param debug: A flag to indicate debug
:type debug: bool
:return: An iterator that will provide the input and target values.\
The iterator yields (input, target) values.
:rtype: callable
"""
mixtures_list, sources_list = _get_files_lists('training')
hamming_window = signal.hamming(window_size, True)
def epoch_it():
for index in range(int(len(mixtures_list) / files_per_pass)):
mix, voice_true = _get_data_training(current_set=index + 1,
set_size=files_per_pass,
mixtures_list=mixtures_list,
sources_list=sources_list,
window_values=hamming_window,
fft_size=fft_size,
hop=hop_size,
seq_length=seq_length,
context_length=context_length,
batch_size=batch_size)
shuffled_indices = np.random.permutation(mix.shape[0])
mix = mix[shuffled_indices]
voice_true = voice_true[shuffled_indices]
for batch in range(int(mix.shape[0] / batch_size)):
b_start = batch * batch_size
b_end = (batch + 1) * batch_size
mix_batch = mix[b_start:b_end, :, :]
voice_true_batch = voice_true[
b_start:b_end, context_length:-context_length, :]
yield mix_batch, voice_true_batch
if debug:
break
if debug:
break
return epoch_it
t = -100
nH = 40
minf0 = 420
maxf0 = 460
f0et = 5
maxnpeaksTwm = 5
minSineDur = .1
harmDevSlope = 0.01
Ns = 512
H = Ns / 4
mX, pX = STFT.stftAnal(x, fs, w, N, H)
hfreq, hmag, hphase = HM.harmonicModelAnal(x, fs, w, N, H, t, nH, minf0, maxf0,
f0et, harmDevSlope, minSineDur)
xr = UF.sineSubtraction(x, Ns, H, hfreq, hmag, hphase, fs)
mXr, pXr = STFT.stftAnal(xr, fs, hamming(Ns), Ns, H)
maxplotfreq = 5000.0
plt.figure(1, figsize=(9, 7))
plt.subplot(221)
numFrames = int(mX[:, 0].size)
frmTime = H * np.arange(numFrames) / float(fs)
binFreq = fs * np.arange(N * maxplotfreq / fs) / N
plt.pcolormesh(frmTime, binFreq,
np.transpose(mX[:, :N * maxplotfreq / fs + 1]))
plt.autoscale(tight=True)
harms = hfreq * np.less(hfreq, maxplotfreq)
harms[harms == 0] = np.nan
numFrames = int(harms[:, 0].size)
def normhamming(fft_len):
win = numpy.sqrt(hamming(fft_len, False))
win = win / numpy.sqrt(
numpy.sum(numpy.power(win[0:fft_len:FRAME_SHIFT], 2)))
return win
while pin < pend:
mX = spectrum(window(x[pin:pin + N]))
f0t = pitchYin(mX)
f0 = np.append(f0, f0t[0])
pin += H
return f0
if __name__ == '__main__':
(fs, x) = UF.wavread('../../../sounds/bendir.wav')
plt.figure(1, figsize=(9, 7))
N = 2048
H = 256
w = hamming(2048)
mX, pX = STFT.stftAnal(x, fs, w, N, H)
maxplotfreq = 2000.0
frmTime = H * np.arange(mX[:, 0].size) / float(fs)
binFreq = fs * np.arange(N * maxplotfreq / fs) / N
plt.pcolormesh(frmTime, binFreq,
np.transpose(mX[:, :N * maxplotfreq / fs + 1]))
N = 2048
minf0 = 130
maxf0 = 300
H = 256
f0 = f0Yin(x, N, H, minf0, maxf0)
yf0 = UF.sinewaveSynth(f0, .8, H, fs)
frmTime = H * np.arange(f0.size) / float(fs)
plt.plot(frmTime, f0, linewidth=2, color='k')
def hamming_win(self, array_size, *args, **kwargs):
return signal.hamming(array_size)
def smoothed_pseudo_wigner_ville(signal, timestamps=None, n_fbins=None,
twindow=None, fwindow=None):
"""smoothed_pseudo_wigner_ville
:param signal:
:param timestamps:
:param n_fbins:
:param twindow:
:param fwindow:
:type signal:
:type timestamps:
:type n_fbins:
:type twindow:
:type fwindow:
:return:
:rtype:
"""
xrow = signal.shape[0]
if timestamps is None:
timestamps = np.arange(signal.shape[0])
if n_fbins is None:
n_fbins = signal.shape[0]
if fwindow is None:
hlength = np.floor(n_fbins / 4.0)
hlength += 1 - (hlength % 2)
fwindow = ssig.hamming(hlength)
elif fwindow.shape[0] % 2 == 0:
raise ValueError('The smoothing window must have an odd length.')
lh = (fwindow.shape[0] - 1) / 2
if twindow is None:
glength = np.floor(n_fbins / 4.0)
glength += 1 - (glength % 2)
twindow = ssig.hamming(glength)
elif twindow.shape[0] % 2 == 0:
raise ValueError('The smoothing window must have an odd length.')
lg = (twindow.shape[0] - 1) / 2
tcol = timestamps.shape[0]
deltat = timestamps[1:] - timestamps[:-1]
if deltat.min() != deltat.max():
raise ValueError("Time instants must be regularly sampled.")
else:
dt = deltat.min()
tfr = np.zeros((n_fbins, tcol), dtype=complex)
tf2 = np.zeros((n_fbins, tcol), dtype=complex)
tf3 = np.zeros((n_fbins, tcol), dtype=complex)
dh = derive_window(fwindow)
for icol in range(tcol):
ti = timestamps[icol]
taumax = min([ti + lg - 1, xrow - ti + lg, np.round(n_fbins / 2.0) - 1,
lh])
points = np.arange(-min([lg, xrow - ti]), min([lg, ti - 1]) + 1)
g2 = twindow[lg + points]
g2 = g2 / g2.sum()
tg2 = g2 * points
xx = signal[ti - 1 - points] * np.conj(signal[ti - 1 - points])
tfr[0, icol] = (g2 * xx).sum()
tf2[0, icol] = (tg2 * xx).sum()
tf3[0, icol] = dh[lh + 1] * tfr[0, icol]
for tau in range(int(taumax)):
points = np.arange(-min([lg, xrow - ti - tau]),
min([lg, ti - tau - 1]) + 1)
g2 = twindow[lg + points]
g2 = g2 / g2.sum()
tg2 = g2 * points
xx = signal[ti + tau - 1 - points] * np.conj(signal[ti - tau - 1 - points])
tfr[tau, icol] = (g2 * xx).sum() * fwindow[lh + tau]
tf2[tau, icol] = fwindow[lh + tau] * (tg2 * xx).sum()
tf3[tau, icol] = dh[lh + tau] * (g2 * xx).sum()
tfr[n_fbins - tau - 1, icol] = (g2 * np.conj(xx)).sum() * fwindow[lh - tau]
tf2[n_fbins - tau - 1, icol] = (tg2 * np.conj(xx)).sum() * fwindow[lh - tau]
tf3[n_fbins - tau - 1, icol] = dh[lh - tau] * (g2 * np.conj(xx)).sum()
tfr = np.real(np.fft.fft(tfr, axis=0)).ravel()
tf2 = np.real(np.fft.fft(tf2, axis=0)).ravel()
tf3 = np.imag(np.fft.fft(tf3, axis=0)).ravel()
no_warn_mask = tfr != 0
tf2[no_warn_mask] = np.round(tf2[no_warn_mask] / tfr[no_warn_mask] / dt)
tf3[no_warn_mask] = np.round(
n_fbins * tf3[no_warn_mask] / tfr[no_warn_mask] / (2 * np.pi))
tfr, tf2, tf3 = [x.reshape(n_fbins, tcol).astype(complex) for x in (tfr, tf2, tf3)]
tf3 = np.real(tf3)
rtfr = np.zeros((n_fbins, tcol), dtype=complex)
ex = np.mean(np.abs(signal) ** 2)
threshold = ex * 1.0e-6
for icol in range(tcol):
for jcol in range(n_fbins):
if np.abs(tfr[jcol, icol]) > threshold:
icolhat = min(max([icol - tf2[jcol, icol], 1]), tcol)
jcolhat = jcol - tf3[jcol, icol]
jcolhat = (((int(jcolhat) - 1) % n_fbins) + n_fbins) % n_fbins + 1
rtfr[jcol, icol] += tfr[jcol, icol]
tf2[jcol, icol] = jcolhat + 1j * icolhat
else:
tf2[jcol, icol] = np.inf * (1 + 1j)
rtfr[jcol, icol] += tfr[jcol, icol]
return tfr, rtfr, tf2
def pseudo_wigner_ville(signal, timestamps=None, n_fbins=None, fwindow=None):
"""pseudo_wigner_ville
:param signal:
:param timestamps:
:param n_fbins:
:param fwindow:
:type signal:
:type timestamps:
:type n_fbins:
:type fwindow:
:return:
:rtype:
"""
xrow = signal.shape[0]
if timestamps is None:
timestamps = np.arange(signal.shape[0])
if n_fbins is None:
n_fbins = signal.shape[0]
tcol = timestamps.shape[0]
if fwindow is None:
hlength = np.floor(n_fbins / 4.0)
if hlength % 2 == 0:
hlength += 1
fwindow = ssig.hamming(int(hlength))
elif fwindow.shape[0] % 2 == 0:
raise ValueError('The smoothing fwindow must have an odd length.')
lh = (fwindow.shape[0] - 1) // 2
fwindow = fwindow / fwindow[lh]
tfr = np.zeros((n_fbins, tcol), dtype=complex)
tf2 = np.zeros((n_fbins, tcol), dtype=complex)
dh = derive_window(fwindow)
for icol in range(tcol):
ti = timestamps[icol]
taumax = min([ti - 1, xrow - ti, np.round(n_fbins / 2.0) - 1, lh])
tau = np.arange(-taumax, taumax + 1)
indices = np.remainder(n_fbins + tau, n_fbins) + 1
tfr[indices - 1, icol] = fwindow[lh + tau] * signal[ti + tau - 1] * \
np.conj(signal[ti - tau - 1])
tf2[indices - 1, icol] = dh[lh + tau] * signal[ti + tau - 1] * \
np.conj(signal[ti - tau - 1])
tau = np.round(n_fbins / 2)
if (ti <= (xrow - tau)) and (ti > (tau + 1)) and (tau <= lh):
_x = fwindow[lh + 1 + tau] * signal[ti + tau] * np.conj(signal[ti - tau])
_y = fwindow[lh + 1 - tau] * signal[ti - tau] * np.conj(signal[ti + tau])
tfr[tau + 1, icol] = (_x + _y) * 0.5
_x = dh[lh + 1 + tau] * signal[ti + tau] * np.conj(signal[ti - tau])
_y = dh[lh + 1 - tau] * signal[ti - tau] * np.conj(signal[ti + tau])
tf2[tau + 1, icol] = (_x + _y) * 0.5
tfr = np.real(np.fft.fft(tfr, axis=0))
tf2 = np.imag(np.fft.fft(tf2, axis=0))
tfr = tfr.ravel()
tf2 = tf2.ravel()
no_warn_mask = tfr != 0
tf2[no_warn_mask] *= n_fbins / tfr[no_warn_mask] / (2 * np.pi)
tf2[no_warn_mask] = np.round(tf2[no_warn_mask])
tfr = tfr.reshape(n_fbins, tcol)
tf2 = tf2.reshape(n_fbins, tcol)
rtfr = np.zeros((n_fbins, tcol), dtype=complex)
tmin = timestamps.min()
tmax = timestamps.max()
threshold = 1.0e-6 * (np.abs(signal[tmin:(tmax + 1)]) ** 2).mean()
for icol in range(tcol):
for jcol in range(n_fbins):
if np.abs(tfr[jcol, icol]) > threshold:
jcolhat = jcol - int(tf2[jcol, icol])
jcolhat = (((jcolhat - 1) % n_fbins) + n_fbins) % n_fbins
jcolhat += 1
rtfr[jcolhat - 1, icol] += tfr[jcol, icol]
tf2[jcol, icol] = jcolhat
else:
tf2[jcol, icol] = np.inf
rtfr[jcol, icol] += tfr[jcol, icol]
return tfr, rtfr, tf2
def get_data(self):
"""Get spectrogram data from the tuner. Will return width number of
values which are the intensities of each frequency bucket (i.e. FFT of
radio samples).
"""
# Get width number of raw samples so the number of frequency bins is
# the same as the display width. Add two because there will be mean/DC
# values in the results which are ignored. Increase by 1/self.zoom_fac if needed
if self.zoom_fac < (self.sdr.sample_rate / 1000000):
zoom = int(self.width *
((self.sdr.sample_rate / 1000000) / self.zoom_fac))
else:
zoom = self.width
self.zoom_fac = self.get_sample_rate()
if zoom < freqshow.SDR_SAMPLE_SIZE:
freqbins = self.sdr.read_samples(freqshow.SDR_SAMPLE_SIZE)[0:zoom +
2]
else:
zoom = self.width
self.zoom_fac = self.get_sample_rate()
freqbins = self.sdr.read_samples(freqshow.SDR_SAMPLE_SIZE)[0:zoom +
2]
# Apply a window function to the sample to remove power in sample sidebands before the fft.
if self.filter == 'kaiser':
window = signal.kaiser(
freqshow.SDR_SAMPLE_SIZE,
self.kaiser_beta,
False,
)[0:zoom +
2] # for every bin there is a window the same exact size as the read samples.
elif self.filter == 'boxcar':
window = signal.boxcar(
freqshow.SDR_SAMPLE_SIZE,
False,
)[0:zoom + 2]
elif self.filter == 'hann':
window = signal.hann(
freqshow.SDR_SAMPLE_SIZE,
False,
)[0:zoom + 2]
elif self.filter == 'hamming':
window = signal.hamming(
freqshow.SDR_SAMPLE_SIZE,
False,
)[0:zoom + 2]
elif self.filter == 'blackman':
window = signal.blackman(
freqshow.SDR_SAMPLE_SIZE,
False,
)[0:zoom + 2]
elif self.filter == 'blackmanharris':
window = signal.blackmanharris(
freqshow.SDR_SAMPLE_SIZE,
False,
)[0:zoom + 2]
elif self.filter == 'bartlett':
window = signal.bartlett(
freqshow.SDR_SAMPLE_SIZE,
False,
)[0:zoom + 2]
elif self.filter == 'barthann':
window = signal.barthann(
freqshow.SDR_SAMPLE_SIZE,
False,
)[0:zoom + 2]
elif self.filter == 'nuttall':
window = signal.nuttall(
freqshow.SDR_SAMPLE_SIZE,
False,
)[0:zoom + 2]
else:
window = 1
samples = freqbins * window
# Run an FFT and take the absolute value to get frequency magnitudes.
freqs = np.absolute(fft(samples))
# Ignore the mean/DC values at the ends.
freqs = freqs[1:-1]
# Reverse the order of the freqs array if swaping I and Q
if self.swap_iq == True:
freqs = freqs[::-1]
# Shift FFT result positions to put center frequency in center.
freqs = np.fft.fftshift(freqs)
# Truncate the freqs array to the width of the screen if neccesary.
if freqs.size > self.width:
freq_step = self.get_freq_step(
) # Get the frequency step in Hz between pixels.
shiftsweep = int(self.get_lo_offset() * 1000000 /
freq_step) # LO offset in pixels.
extra_samples = int(
(freqs.size - self.width) / 2
) # The excess samples either side of the display width in pixels.
if extra_samples > abs(
shiftsweep
): # check if there is room to shift the array by the LO offset.
if self.get_swap_iq() == True:
lextra = extra_samples + shiftsweep
elif self.get_swap_iq() == False:
lextra = extra_samples - shiftsweep
else:
lextra = extra_samples
rextra = freqs.size - (lextra + self.width)
freqs = freqs[lextra:-rextra]
# Convert to decibels.
freqs = 20.0 * np.log10(freqs)
# Get signal strength of the center frequency.
# for i in range ( 1, 11):
# self.sig_strength = (self.get_sig_strength() + freqs[((zoom+2)/2)+i-5])
# self.sig_strength = self.get_sig_strength()/10
# Update model's min and max intensities when auto scaling each value.
if self.min_auto_scale:
min_intensity = np.min(freqs)
self.min_intensity = min_intensity if self.min_intensity is None \
else min(min_intensity, self.min_intensity)
if self.max_auto_scale:
max_intensity = np.max(freqs)
self.max_intensity = max_intensity if self.max_intensity is None \
else max(max_intensity, self.max_intensity)
# Update intensity range (length between min and max intensity).
self.range = self.max_intensity - self.min_intensity
# Return frequency intensities.
return freqs
def lin_error(enr=10.0,txlen=1000.0,n_ipp=10,ipp=20e-3,bw=1e6,dr=10.0,ddop=1.0,sr=100e6,plot=False):
'''
Determine linearized errors for range and range-rate error
for a psuedorandom binary phase coded radar transmit pulse
with a certain transmit bandwidth (inverse of bit length)
calculate line of sight range and range-rate error,
given ENR after coherent integration (pulse compression)
txlen in microseconds.
Simulate a measurement and do a linearized error estimate.
'''
codes=[]
t_vecs=[]
n_bits = int(bw*txlen/1e6)
oversample=int(sr/bw)
wfun=ss.hamming(oversample)
wfun=wfun/n.sum(wfun)
for i in range(n_ipp):
bits=n.array(n.sign(n.random.randn(n_bits)),dtype=n.complex64)
zcode=n.zeros(n_bits*oversample+2*oversample,dtype=n.complex64)
for j in range(oversample):
zcode[n.arange(n_bits)*oversample+j+oversample]=bits
# filter signal so that phase transitions are not too sharp
zcode=n.convolve(wfun,zcode,mode="same")
codes.append(zcode)
tcode=n.arange(n_bits*oversample+2*oversample)/sr + float(i)*ipp
t_vecs.append(tcode)
z0=simulate_echo(codes,t_vecs,dop_Hz=0.0,range_m=0.0,bw=bw,sr=sr)
tau=(float(n_ipp)*txlen/1e6)
# convert coherently integrated ENR to SNR (variance of the measurement errors at receiver bandwidth)
snr = enr/(tau*sr)
if plot:
plt.plot(z0.real)
plt.plot(z0.imag)
plt.title("Echo")
plt.show()
z_dr=simulate_echo(codes,t_vecs,dop_Hz=0.0,range_m=dr,bw=bw,sr=sr)
z_diff_r=(z0-z_dr)/dr
if plot:
plt.plot(z_diff_r.real)
plt.plot(z_diff_r.imag)
plt.title("Range derivative of echo (dm/dr)")
plt.show()
z_ddop=simulate_echo(codes,t_vecs,dop_Hz=ddop,range_m=0.0,bw=bw,sr=sr)
z_diff_dop=(z0-z_ddop)/ddop
if plot:
plt.plot(z_diff_dop.real)
plt.plot(z_diff_dop.imag)
plt.title("Doppler derivative of echo (dm/df)")
plt.show()
t_l=len(z_dr)
A=n.zeros([t_l,2],dtype=n.complex64)
A[:,0]=z_diff_r
A[:,1]=z_diff_dop
S=n.real(n.linalg.inv(n.dot(n.transpose(n.conj(A)),A))/snr)
return(n.sqrt(n.diag(S)))
def mfcc(input, nwin=256, nfft=512, fs=16000, nceps=13):
"""Compute Mel Frequency Cepstral Coefficients.
Parameters
----------
input: ndarray
input from which the coefficients are computed
Returns
-------
ceps: ndarray
Mel-cepstrum coefficients
mspec: ndarray
Log-spectrum in the mel-domain.
Notes
-----
MFCC are computed as follows:
* Pre-processing in time-domain (pre-emphasizing)
* Compute the spectrum amplitude by windowing with a Hamming window
* Filter the signal in the spectral domain with a triangular
filter-bank, whose filters are approximatively linearly spaced on the
mel scale, and have equal bandwith in the mel scale
* Compute the DCT of the log-spectrum
References
----------
.. [1] S.B. Davis and P. Mermelstein, "Comparison of parametric
representations for monosyllabic word recognition in continuously
spoken sentences", IEEE Trans. Acoustics. Speech, Signal Proc.
ASSP-28 (4): 357-366, August 1980."""
# MFCC parameters: taken from auditory toolbox
over = nwin - 160
# Pre-emphasis factor (to take into account the -6dB/octave rolloff of the
# radiation at the lips level)
prefac = 0.97
#lowfreq = 400 / 3.
lowfreq = 133.33
#highfreq = 6855.4976
linsc = 200 / 3.
logsc = 1.0711703
nlinfil = 13
nlogfil = 27
nfil = nlinfil + nlogfil
w = hamming(nwin, sym=0)
fbank = trfbank(fs, nfft, lowfreq, linsc, logsc, nlinfil, nlogfil)[0]
#------------------
# Compute the MFCC
#------------------
extract = lfilter([1., -prefac], 1, input)
framed = segment_axis(extract, nwin, over) * w
# Compute the spectrum magnitude
spec = np.abs(fft(framed, nfft, axis=-1))
# Filter the spectrum through the triangle filterbank
mspec = np.log10(np.dot(spec, fbank.T))
# Use the DCT to 'compress' the coefficients (spectrum -> cepstrum domain)
ceps = dct(mspec, type=2, norm='ortho', axis=-1)[:, :nceps]
return ceps, mspec, spec
def sineModelMultiRes(inputFile="../../sounds/orchestra.wav",
windows=(signal.blackman(4095), signal.hamming(2047), np.hamming(1023)),
Ns=(4096, 2048, 1024),
Bs=(1000, 5000, 22050),
t=-80, minSineDur=0.02,
maxnSines=150, freqDevOffset=10, freqDevSlope=0.001, PlotIt=True):
sN = 512
H = sN/4
(fs, x) = UF.wavread(inputFile)
tfreq, tmag, tphase = sineModelMultiResAnal(x, fs, windows, Ns, Bs, H, t,
minSineDur, maxnSines, freqDevOffset, freqDevSlope)
y = SM.sineModelSynth(tfreq, tmag, tphase, sN, H, fs)
# calculate diff between x & y
diffLength = min([x.size, y.size])
diff = np.abs(x[:diffLength] - y[:diffLength])
print("diff {0}".format(np.sum(diff)))
outputFile = os.path.basename(inputFile)[:-4] + '_sineModelMulti.wav'
UF.wavwrite(y, fs, outputFile)
if not PlotIt:
return
plt.figure(figsize=(12, 9))
maxplotfreq = 10000.0
# plot the input sound
plt.subplot(3,1,1)
plt.plot(np.arange(x.size)/float(fs), x)
plt.axis([0, x.size/float(fs), min(x), max(x)])
plt.ylabel('amplitude')
plt.xlabel('time (sec)')
plt.title('input sound: x')
# plot the sinusoidal frequencies
plt.subplot(3,1,2)
if (tfreq.shape[1] > 0):
numFrames = tfreq.shape[0]
frmTime = H*np.arange(numFrames)/float(fs)
tfreq[tfreq<=0] = np.nan
plt.ylabel('frequency (Hz)')
plt.xlabel('time (sec)')
plt.title('input sound: x')
plt.plot(frmTime, tfreq)
plt.axis([0, x.size/float(fs), 0, maxplotfreq])
plt.title('frequencies of sinusoidal tracks')
# plot the output sound
plt.subplot(3,1,3)
plt.plot(np.arange(y.size)/float(fs), y)
plt.axis([0, y.size/float(fs), min(y), max(y)])
plt.ylabel('amplitude')
plt.xlabel('time (sec)')
plt.title('output sound: y')
plt.tight_layout()
plt.show()
df_EFR_label = pd.DataFrame(df_EFR_input.iloc[i, 1024:1031].values.reshape(1,7))
df_EFR_detrend = df_EFR_detrend.append(pd.concat([df_EFR_detrend_temp, df_EFR_label], axis=1, ignore_index=True))
# set the title of columns
df_EFR_detrend.columns = np.append(np.arange(1024), ["Subject", "Sex", "Condition", "Vowel", "Sound Level", "Num", "EFR/FFR"])
df_EFR_detrend = df_EFR_detrend.reset_index(drop=True)
# df_EFR_label = pd.DataFrame(df_EFR.iloc[, 1024:1031].values.reshape(1,7))
df_EFR_detrend_label = df_EFR_input.iloc[:, 1024:1031]
# Time domain
# Define window function
win_kaiser = signal.kaiser(1024, beta=14)
win_hamming = signal.hamming(1024)
# implement the window function
df_EFR_win = pd.DataFrame()
for i in range(1408):
# implement the window function
df_EFR_t_win_temp = pd.DataFrame((df_EFR_detrend.iloc[i, 0:1024] * win_hamming).values.reshape(1,1024))
df_EFR_label_temp = pd.DataFrame(df_EFR_detrend.iloc[i, 1024:1031].values.reshape(1,7))
df_EFR_win = df_EFR_win.append(pd.concat([df_EFR_t_win_temp, df_EFR_label_temp], axis=1, ignore_index=True))
# set the title of columns
df_EFR = df_EFR_detrend.sort_values(by=["Condition", "Subject"])
df_EFR = df_EFR.reset_index(drop=True)
df_EFR_win.columns = np.append(np.arange(1024), ["Subject", "Sex", "Condition", "Vowel", "Sound Level", "Num", "EFR/FFR"])
df_EFR_win = df_EFR_win.sort_values(by=["Condition", "Subject"])
def hamming3d(a, b, c):
w2d = np.outer(ss.hamming(a), ss.hamming(b))
w3d = np.zeros((a, b, c))
for i in range(a):
w3d[i, :, :] = np.outer(w2d[i, :].flatten(), ss.hamming(c))
return w3d**(1.0 / 3.0)
def istft(spectrum, winsize_samples, nfft_samples, overlap_percentage,
wintype):
hopsize_fraction = (100 - overlap_percentage) / 100
hopsize = int(hopsize_fraction * winsize_samples)
specsize = int(nfft_samples / 2 + 1)
# get the synthesis window
if wintype == 'cosine':
win_synthesis = cosine(winsize_samples, sym=False)
elif wintype == 'blackmanharris':
win_synthesis = blackmanharris(winsize_samples, sym=False)
elif wintype == 'blackman':
win_synthesis = blackman(winsize_samples, sym=False)
elif wintype == 'hamming':
win_synthesis = hamming(winsize_samples, sym=False)
elif wintype == 'hanning':
win_synthesis = hanning(winsize_samples, sym=False)
#make sure that the scaling is correct
sqsum = np.sum(np.square(win_synthesis)) / winsize_samples
invsqsum = 1 / sqsum
tmp = hopsize_fraction
correctionFactor = tmp * invsqsum
win_synthesis = win_synthesis * correctionFactor
# allocate memory for the signal
numFrames = spectrum.shape[1]
framesize = int((100 - overlap_percentage) * winsize_samples / 100)
# allocate a 2D array for the time-domain signal (to be vectorized later)
sig_hat = np.zeros(shape=(numFrames, framesize))
# prepare buffers for the istft
buffer_chunks = int(1 / hopsize_fraction)
ifft_buffer = np.zeros(shape=(winsize_samples, buffer_chunks))
for idx in range(0, numFrames):
# get the current frame spectrum and append the complex conjugate
tmpspec = np.zeros(shape=(nfft_samples)) + 0.j
tmpspec[
0:specsize] = spectrum[:,
idx] # select the column of the spectrogram
tmpspec[specsize:nfft_samples] = np.conj(
np.flip(spectrum[1:specsize - 1, idx], 0))
# take the ifft of the spectrum
tmpframe = np.real(ifft(tmpspec, nfft_samples))
# apply the synthesis window to the time frame, and keep only the number of samples corresponding to the analysis window (if zero-padding was applied, this ensures that the irrelevant samples are discarded)
frame_in_time = win_synthesis * tmpframe[0:winsize_samples]
# put the last one out, take the new one in
ifft_buffer[:, 1:buffer_chunks] = ifft_buffer[:, 0:buffer_chunks - 1]
ifft_buffer[:, 0] = frame_in_time
# implementation of the overlap-add procedure
frame_out = np.zeros(shape=(hopsize))
for bufidx in range(0, buffer_chunks):
bufstart = bufidx * hopsize
bufend = bufstart + hopsize
frame_out = frame_out + ifft_buffer[bufstart:bufend, bufidx]
# store the current output frame in the correct indices of the signal
sig_hat[idx, :] = frame_out
#--- end of for idx in range(0,numFrames)
# vectorize 2D signal to obtain one time-domain signal vector
sig_out = sig_hat.flatten()
return sig_out
def spectrogram(signal, time_samples=None, n_fbins=None, window=None):
"""Compute the spectrogram and reassigned spectrogram.
:param signal: signal to be analzsed
:param time_samples: time instants (default: np.arange(len(signal)))
:param n_fbins: number of frequency bins (default: len(signal))
:param window: frequency smoothing window (default: Hamming with \
size=len(signal)/4)
:type signal: array-like
:type time_samples: array-like
:type n_fbins: int
:type window: array-like
:return: spectrogram, reassigned specstrogram and matrix of reassignment \
vectors
:rtype: tuple(array-like)
"""
if time_samples is None:
time_samples = np.arange(signal.shape[0])
elif np.unique(np.diff(time_samples)).shape[0] > 1:
raise ValueError('Time instants must be regularly sampled.')
if n_fbins is None:
n_fbins = signal.shape[0]
if window is None:
wlength = int(np.floor(signal.shape[0] / 4.0))
wlength += 1 - np.remainder(wlength, 2)
window = ssig.hamming(wlength)
elif window.shape[0] % 2 == 0:
raise ValueError('The smoothing window must have an odd length.')
tfr = np.zeros((n_fbins, time_samples.shape[0]), dtype=complex)
tf2 = np.zeros((n_fbins, time_samples.shape[0]), dtype=complex)
tf3 = np.zeros((n_fbins, time_samples.shape[0]), dtype=complex)
lh = (window.shape[0] - 1) // 2
th = window * np.arange(-lh, lh + 1)
dwin = derive_window(window)
for icol in range(time_samples.shape[0]):
ti = time_samples[icol]
tau = np.arange(-np.min([np.round(n_fbins / 2) - 1, lh, ti]),
np.min([np.round(n_fbins / 2) - 1, lh,
signal.shape[0] - ti]) + 1).astype(int)
indices = np.remainder(n_fbins + tau, n_fbins)
norm_h = np.linalg.norm(window[lh + tau], ord=2)
tfr[indices, icol] = signal[ti + tau - 1] * np.conj(window[lh + tau]) / norm_h
tf2[indices, icol] = signal[ti + tau - 1] * np.conj(th[lh + tau]) / norm_h
tf3[indices, icol] = signal[ti + tau - 1] * np.conj(dwin[lh + tau]) / norm_h
tfr = np.fft.fft(tfr, axis=0).ravel()
tf2 = np.fft.fft(tf2, axis=0).ravel()
tf3 = np.fft.fft(tf3, axis=0).ravel()
no_warn_mask = tfr != 0
tf2[no_warn_mask] = np.round(np.real(tf2[no_warn_mask] / tfr[no_warn_mask]))
tf3[no_warn_mask] = np.round(
np.imag(n_fbins * tf3[no_warn_mask] / tfr[no_warn_mask] / (2 * np.pi)))
tfr = np.abs(tfr) ** 2
tfr = tfr.reshape(n_fbins, time_samples.shape[0])
tf2 = tf2.reshape(n_fbins, time_samples.shape[0])
tf3 = tf3.reshape(n_fbins, time_samples.shape[0])
tf3 = np.real(tf3)
rtfr = np.zeros((n_fbins, time_samples.shape[0]), dtype=complex)
ix = np.arange(time_samples.min(), time_samples.max() + 1) - 1
threshold = 1e-6 * np.mean(np.abs(signal[ix])**2)
for icol in range(time_samples.shape[0]):
for jcol in range(n_fbins):
if np.abs(tfr[jcol, icol]) > threshold:
icolhat = icol + tf2[jcol, icol]
icolhat = np.min([np.max([icolhat, 1]), time_samples.shape[0]])
jcolhat = jcol - tf3[jcol, icol]
jcolhat = (((jcolhat - 1) % n_fbins) + n_fbins) % n_fbins
rtfr[int(jcolhat), int(icolhat) - 1] += tfr[jcol, icol]
tf2[jcol, icol] = jcolhat + 1j * icolhat
else:
tf2[jcol, icol] = np.inf
rtfr[jcol, icol] += tfr[jcol, icol]
return tfr, rtfr, tf2
output=False,
frames_per_buffer=CHUNK,
stream_callback=audio_callback)
if Recording:
wf = wave.open(WAVE_OUTPUT_FILENAME, 'wb')
wf.setnchannels(CHANNELS)
wf.setsampwidth(p.get_sample_size(FORMAT))
wf.setframerate(RATE)
print("Start Recording")
stream.start_stream()
# processing block
window = signal.hamming(CHUNK)
def read_audio_thead(q, stream, frames, ad_rdy_ev):
global rt_data
global fft_data
while stream.is_active():
ad_rdy_ev.wait(timeout=1000)
if not q.empty():
# process audio data here
data = q.get()
while not q.empty():
q.get()
rt_data = np.frombuffer(data, np.dtype('<i2'))
rt_data = rt_data * window
def pseudo_margenau_hill(signal, timestamps=None, n_fbins=None, fwindow=None):
"""pseudo_margenau_hill
:param signal:
:param timestamps:
:param n_fbins:
:param fwindow:
:type signal:
:type timestamps:
:type n_fbins:
:type fwindow:
:return:
:rtype:
"""
xrow = signal.shape[0]
if timestamps is None:
timestamps = np.arange(signal.shape[0])
if n_fbins is None:
n_fbins = signal.shape[0]
tcol = timestamps.shape[0]
if fwindow is None:
hlength = np.floor(n_fbins / 4.0)
if hlength % 2 == 0:
hlength += 1
fwindow = ssig.hamming(hlength)
elif fwindow.shape[0] % 2 == 0:
raise ValueError('The smoothing fwindow must have an odd length.')
lh = (fwindow.shape[0] - 1) / 2
fwindow = fwindow / fwindow[lh]
tfr = np.zeros((n_fbins, tcol), dtype=complex)
tf2 = np.zeros((n_fbins, tcol), dtype=complex)
dh = derive_window(fwindow)
tfr = np.zeros((n_fbins, tcol), dtype=complex)
for icol in range(tcol):
ti = timestamps[icol]
start = min([np.round(n_fbins / 2.0) - 1, lh, xrow - ti])
end = min([np.round(n_fbins / 2.0) - 1, lh, ti - 1])
tau = np.arange(-start, end + 1)
indices = np.remainder(n_fbins + tau, n_fbins)
tfr[indices, icol] = fwindow[lh + tau] * signal[ti - 1] * \
np.conj(signal[ti - tau - 1])
tf2[indices, icol] = dh[lh + tau] * signal[ti - 1] * \
np.conj(signal[ti - tau - 1])
tfr = np.fft.fft(tfr, axis=0)
tf2 = np.fft.fft(tf2, axis=0)
tfr = tfr.ravel()
tf2 = tf2.ravel()
no_warn_mask = tfr != 0
tf2[no_warn_mask] *= n_fbins / tfr[no_warn_mask] / (2 * np.pi)
tf2[no_warn_mask] = np.round(tf2[no_warn_mask])
tfr = np.real(tfr)
tf2 = np.imag(tf2)
tfr = tfr.reshape(n_fbins, tcol)
tf2 = tf2.reshape(n_fbins, tcol)
rtfr = np.zeros((n_fbins, tcol), dtype=complex)
threshold = 1.0e-6 * (np.abs(signal) ** 2).mean()
for icol in range(tcol):
for jcol in range(n_fbins):
if np.abs(tfr[jcol, icol]) > threshold:
jcolhat = jcol - tf2[jcol, icol]
jcolhat = (((jcolhat - 1) % n_fbins) + n_fbins) % n_fbins
jcolhat += 1
rtfr[jcolhat - 1, icol] += tfr[jcol, icol]
tf2[jcol, icol] = jcolhat
else:
tf2[jcol, icol] = np.inf
rtfr[jcol, icol] += tfr[jcol, icol]
return tfr, rtfr, tf2
for i, t in enumerate(timestamp_array):
try:
a = np.load(folder + '/' + filename + '-audio-' + str(i).zfill(4) + '.npy') # arctic_a0001-audio-0000.npy
#if i % 10 == 1:
# print "wave before inverse quantization: ", i, a[0:10]
a = inv_mulaw_quantize(a)
#if i% 100 == 1:
# print "wave after inverse quantization: ", a[0:10]
period_start = float(t) - 0.005 if float(t) - 0.005 > 0 else 0
period_end = float(t) + 0.005 if float(t) + 0.005 < timestamp_array[-1] else timestamp_array[-1]
frame_start = int(period_start * 1000)
frame_end = int(period_end * 1000)
sample_start = int(period_start * 16000)
sample_end = int(period_end * 16000)
window = hamming(len(a), sym=False)
#print i, t, sample_start, sample_end, sample_end - sample_start, len(a), len(A) #, a[20:40]
if sample_end > len(A):
continue
if sample_end - sample_start == 160 and len(a) == 160:
A_abs[sample_start:sample_end] += a #* window # Direct add
elif sample_end - sample_start == 161 and len(a) == 160:
A_abs[sample_start:sample_end-1] += a #* window
elif sample_end - sample_start == 159 and len(a) == 160:
A_abs[sample_start:sample_end+1] += a #* window
elif sample_end - sample_start == 160 and len(a) == 161:
window = hann(len(a)-1, sym=False)
A_abs[sample_start:sample_end] += a[1:] #* window
elif sample_end - sample_start == 161 and len(a) == 161:
window = hann(len(a)-1, sym=False)
A_abs[sample_start:sample_end-1] += a[1:] #* window
def smoothed_pseudo_wigner_ville(signal,
timestamps=None,
freq_bins=None,
twindow=None,
fwindow=None):
"""Smoothed Pseudo Wigner-Ville time-frequency distribution.
:param signal: signal to be analyzed
:param timestamps: time instants of the signal
:param freq_bins: number of frequency bins
:param twindow: time smoothing window
:param fwindow: frequency smoothing window
:type signal: array-like
:type timestamps: array-like
:type freq_bins: int
:type twindow: array-like
:type fwindow: array-like
:return: Smoothed pseudo Wigner Ville distribution
:rtype: array-like
"""
if timestamps is None:
timestamps = np.arange(signal.shape[0])
if freq_bins is None:
freq_bins = signal.shape[0]
if fwindow is None:
winlength = np.floor(freq_bins / 4.0)
winlength = winlength + 1 - np.remainder(winlength, 2)
from scipy.signal import hamming
fwindow = hamming(int(winlength))
elif fwindow.shape[0] % 2 == 0:
raise ValueError('The smoothing fwindow must have an odd length.')
if twindow is None:
timelength = np.floor(freq_bins / 10.0)
timelength += 1 - np.remainder(timelength, 2)
from scipy.signal import hamming
twindow = hamming(int(timelength))
elif twindow.shape[0] % 2 == 0:
raise ValueError('The smoothing fwindow must have an odd length.')
tfr = np.zeros((freq_bins, timestamps.shape[0]), dtype=complex)
lg = (twindow.shape[0] - 1) / 2
lh = (fwindow.shape[0] - 1) / 2
for icol in range(timestamps.shape[0]):
ti = timestamps[icol]
taumax = min([
ti + lg - 1, signal.shape[0] - ti + lg,
np.round(freq_bins / 2.0) - 1, lh
])
points = np.arange(-min([lg, signal.shape[0] - ti]),
min([lg, ti - 1]) + 1)
g2 = twindow[lg + points]
g2 = g2 / np.sum(g2)
tfr[0, icol] = np.sum(g2 * signal[ti - points - 1] *
np.conj(signal[ti - points - 1]))
for tau in range(int(taumax)):
points = np.arange(-min([lg, signal.shape[0] - ti - tau]),
min([lg, ti - 1 - tau]) + 1)
g2 = twindow[lg + points]
g2 = g2 / np.sum(g2)
R = np.sum(g2 * signal[ti + tau - points - 1] *
np.conj(signal[ti - tau - points - 1]))
tfr[1 + tau, icol] = fwindow[lh + tau + 1] * R
R = np.sum(g2 * signal[ti - tau - points - 1] *
np.conj(signal[ti + tau - points - 1]))
tfr[freq_bins - tau - 1, icol] = fwindow[lh - tau + 1] * R
tau = np.round(freq_bins / 2.0)
if (ti <= signal.shape[0] - tau) and (ti >= tau + 1) and (tau <= lh):
points = np.arange(-min([lg, signal.shape[0] - ti - tau]),
min([lg, ti - 1 - tau]) + 1)
g2 = twindow[lg + 1 + points]
g2 = g2 / np.sum(g2)
_x = np.sum(g2 * signal[ti + tau - points] *
np.conj(signal[ti - tau - points]))
_x *= fwindow[lh + tau + 1]
_y = np.sum(g2 * signal[ti - tau - points] *
np.conj(signal[ti + tau - points]))
_y *= fwindow[lh - tau + 1]
tfr[tau, icol] = (_x + _y) * 0.5
tfr = np.fft.fft(tfr, axis=0)
return np.real(tfr)
logFile.write('nrOfVols=' + unicode(nrOfVols) + '\n')
logFile.write('durations=' + unicode(durations) + '\n')
logFile.write('totalTime=' + unicode(totalTime) + '\n')
# log opacity on/off cycle in ms
logFile.write('lenCycStim=' + unicode(cfg.lenCycStim) + '\n')
logFile.write('lenCycRamp=' + unicode(cfg.lenCycRamp) + '\n')
logFile.write('lenCycRest=' + unicode(cfg.lenCycRest) + '\n')
# derive how much of a second the stimlus, blank and ramp period should be
divStim = 1000 / cfg.lenCycStim
divRamp = 1000 / cfg.lenCycRamp
divRest = 1000 / cfg.lenCycRest
# define arrays to cycle opacity
cycAlt = np.hstack((
signal.hamming(2 * cfg.nFrames / divRamp)[:cfg.nFrames / divRamp],
np.ones(np.round(cfg.nFrames / divStim)),
signal.hamming(2 * cfg.nFrames / divRamp)[cfg.nFrames / divRamp:],
np.zeros(np.round(cfg.nFrames / divRest)),
signal.hamming(2 * cfg.nFrames / divRamp)[:cfg.nFrames / divRamp],
np.ones(np.round(cfg.nFrames / divStim)),
signal.hamming(2 * cfg.nFrames / divRamp)[cfg.nFrames / divRamp:],
np.zeros(np.round(cfg.nFrames / divRest)),
)).astype('float32')
cycTransp = np.zeros(2 * cfg.nFrames).astype('int8')
# set timing sequence for the texture
texTimeBlank = np.tile(
np.repeat(np.array([0, 0]), cfg.nFrames / (cfg.cycPerSec * 2)),
cfg.cycPerSec * 2).astype('int8')
texTimeFlicker = np.tile(
'font.family': 'serif',
'text.usetex': True,
'pgf.rcfonts': False,
})
Fs = np.intc(802e3) # receiver sample rate
dt = 1 / Fs
T = np.float(6e-3) / 4 # Pulse duration
# Time domain window for NLFM generation
NLFM = radar.chirp(Fs)
NLFM.fftLen = 2048
# Synthesize the target autocorrelation function
#window_t = signal.chebwin(np.intc(2048), 60)
window_t = signal.hamming(np.intc(2048))
#window_t = signal.gaussian(np.intc(2048), 360)
#window_t = signal.gaussian(np.intc(2048), 400)
NLFM.getCoefficients(window_t, targetBw=100e3 / 4, centerFreq=100e3 / 4, T=T)
sig_t = NLFM.genNumerical()
t = np.linspace(-T / 2, (T / 2) - dt, len(sig_t))
SNR = 10 # dB
SnrString = 'SNR_' + str(SNR)
sig_t = util.wgnSnr(sig_t, SNR)
########################################################################
# Generate linear chirp (simple)
T = 1e-6
T = T
def setUp(self):
# directory where the test files are located
self.path = os.path.join(os.path.dirname(__file__), 'data')
file = os.path.join(self.path, '3cssan.hy.1.MBGA_Z')
f = open(file)
self.res = np.loadtxt(f)
f.close()
file = os.path.join(self.path, 'MBGA_Z.ASC')
f = open(file)
data = np.loadtxt(f)
f.close()
#self.path = os.path.dirname(__file__)
#self.res = np.loadtxt("3cssan.hy.1.MBGA_Z")
#data = np.loadtxt("MBGA_Z.ASC")
self.n = 256
self.fs = 75
self.smoothie = 3
self.fk = [2, 1, 0, -1, -2]
self.inc = int(0.05 * self.fs)
self.fc1 = 0.68
self.nofb = 8
#[0] Time (k*inc)
#[1] A_norm
#[2] dA_norm
#[3] dAsum
#[4] dA2sum
#[5] ct
#[6] dct
#[7] omega
#[8] domega
#[9] sigma
#[10] dsigma
#[11] logcep
#[12] logcep
#[13] logcep
#[14] dperiod
#[15] ddperiod
#[16] bwith
#[17] dbwith
#[18] cfreq
#[19] dcfreq
#[20] hob1
#[21] hob2
#[22] hob3
#[23] hob4
#[24] hob5
#[25] hob6
#[26] hob7
#[27] hob8
#[28] phi12
#[29] dphi12
#[30] phi13
#[31] dphi13
#[32] phi23
#[33] dphi23
#[34] lv_h1
#[35] lv_h2
#[36] lv_h3
#[37] dlv_h1
#[38] dlv_h2
#[39] dlv_h3
#[40] rect
#[41] drect
#[42] plan
#[43] dplan
self.data_win, self.nwin, self.no_win = \
util.enframe(data, signal.hamming(self.n), self.inc)
def hamming_data(d, window_length):
'''Multiply all epochs with a hamming window.
'''
hamming = signal.hamming(window_length)
return d * hamming
result2 = []
for k in range(0, 100):
for j in range(nw - k):
sum = sum + Frame[i][j] * Frame[i][j + k]
result.append(sum)
#归一化
for l in range(len(result)):
result2.append(result[l] / result[0])
return 8000 / result2.index(max(result2[-80:]))
filename = '01234.wav'
data = wavread(filename)
nw = 160 #窗大小
inc = 40 #窗偏移
winfunc = signal.hamming(nw) #汉明窗
Frame, nf = enframe(data[0], nw, inc, winfunc) #分帧加窗
Energy = calEnergy(Frame, nf, nw) #计算每一帧的能量
#画出每一帧的能量图
x = np.arange(1, len(Energy) + 1)
plt.figure()
plt.title(u'每一帧的能量')
plt.xlabel(u'帧数')
plt.ylabel(u'能量')
plt.plot(x, Energy)
plt.show()
#计算浊音对应的帧
zhuo = calzhuo(Energy, nf)
print(zhuo)
ax.set_ylabel("signal")
ax.legend()
fig.tight_layout()
fig.savefig("ch17-inverse-fft.pdf")
fig.savefig("ch17-inverse-fft.png")
# ## Windowing
# In[28]:
fig, ax = plt.subplots(1, 1, figsize=(8, 3))
N = 100
ax.plot(signal.blackman(N), label="Blackman")
ax.plot(signal.hann(N), label="Hann")
ax.plot(signal.hamming(N), label="Hamming")
ax.plot(signal.gaussian(N, N/5), label="Gaussian (std=N/5)")
ax.plot(signal.kaiser(N, 7), label="Kaiser (beta=7)")
ax.set_xlabel("n")
ax.legend(loc=0)
fig.tight_layout()
fig.savefig("ch17-window-functions.pdf")
# In[29]:
df = pd.read_csv('temperature_outdoor_2014.tsv', delimiter="\t", names=["time", "temperature"])
# In[30]:
def animate(i):
x = np.arange(len(data))
X = data
line.set_data(x, X)
return line,
anim = animation.FuncAnimation(fig,
animate,
frames=1,
interval=100,
blit=False)
Q = queue.Queue()
sdr = RtlSdr()
window = signal.hamming(N)
def data_processing():
global Q
global data
global window
while 1:
origin_data = Q.get()
while not Q.empty():
Q.get()
window_data = origin_data
ob_data = abs(fftpack.fft(window_data))
#sdata=fftpack.fftshift(fftpack.fft(ob_data,overwrite_x=True))
data = 20 * lg(ob_data / N)
x = np.transpose(np.array(x)) # Parametros del ruido normal # El ruido tiene que estar 3 y 10db por abajo de la senoidal u = 0 # Media db = -30 v = (N / 2) * 10**(db / 10) # Varianza # Genero señal de ruido n = np.sqrt(v) * np.random.randn(N, R) + u # Le sumo el ruido a la señal senoidal x = x + n btWin = signal.hamming(N) psdBT, fBT = blackmanTukey(x, btWin, N, fs) plt.figure(1) plt.plot(fBT, psdBT) ''' # Obtengo la autocorrelacion de la señal Sxx = np.correlate(x[:,0], x[:,0], mode='full') #Sxx = np.correlate(x[:,0], x[:,0], mode='same') Sxx = np.reshape(Sxx,(len(Sxx),1)) # Le aplico una ventana a la secuencia de autocorrelacion w = np.reshape(bartlett(len(Sxx)),(len(Sxx),1)) SxxW = Sxx*w # Obtengo el periodograma de la autocorrelacion
# vim:fenc=utf-8 # # Copyright © 2015 jaidev <jaidev@newton> # # Distributed under terms of the MIT license. """ ================================================ Time-frequency Resolution: Short Analysis Window ================================================ This example shows the effect of an analysis window which is short in time on the time-frequency resolution. Specifically, smaller windows have good time resolutions but poor frequency resolutions. Figure 3.8 from the tutorial. """ import numpy as np import matplotlib.pyplot as plt from tftb.generators import atoms from scipy.signal import hamming from tftb.processing.linear import ShortTimeFourierTransform coords = np.array([[45, .25, 32, 1], [85, .25, 32, 1]]) sig = atoms(128, coords) x = np.real(sig) window = hamming(17) stft = ShortTimeFourierTransform(sig, n_fbins=128, fwindow=window) stft.run() stft.plot(show_tf=True, cmap=plt.cm.gray)
def hamming2d(a, b):
# build 2d window
w2d = np.outer(ss.hamming(a), ss.hamming(b))
return np.sqrt(w2d)
