def fft_data(arr, ft='lag'):
"""
Returns the windowed fft of a time/freq array along the time axis, freq axis, or both.
Parameters
==========
arr: complex array
(nfreq x ntimes) array of complex visibilities
ft: str
transform to return, either lag, m, or mlag
Returns
=======
Returns the fft array that was asked for in ft argument.
"""
freq_window = np.hanning(arr.shape[0])[:, np.newaxis]
time_window = np.hanning(arr.shape[-1])[np.newaxis, :]
if ft=='lag':
return np.fft.fftshift(np.fft.fft(freq_window * arr, axis=0), axes=0)
elif ft=='m':
return np.fft.fftshift(np.fft.fft(time_window * arr, axis=-1), axes=-1)
elif ft=='mlag':
return np.fft.fftshift(np.fft.fft2(freq_window * time_window * arr))
else:
raise Exception('only lag, m, or mlag allowed')
def new_resize_data_fft(data,factor=3,window=14):
xwidth, ywidth = data.shape
max_size = max(data.shape)
print window
#create hanning window and apply
#hx = kaiser(xwidth,window)
#hy = kaiser(ywidth,window)
hx = hanning(xwidth)
hy = hanning(ywidth)
ham2d = sqrt(outer(hx,hy))
if window is not None:
data = data*ham2d
#just create an array odd number as big
#to avoid overuns etc - It needs to be padded anyhow
max_size = max_size*factor
if not max_size % 2:
print "Not correct"
return -1
new_array = zeros([max_size, max_size], dtype="complex")
x_start = (max_size - 1)/2 - (xwidth-1)/2
x_end = x_start + xwidth
y_start = (max_size - 1)/2 - (xwidth-1)/2
y_end = y_start + ywidth
print x_start,x_end,y_start,y_end
new_array[x_start:x_end,y_start:y_end] = data
return new_array,ham2d
def load_signature(guids,sample_rate,nbits):
amp,ampS, t= .49,.49,.05 #Variable handels for Bits
tBit = np.arange(0,t*sample_rate+1)/float(sample_rate) #time Vector for Bits
F0,F1,Fsync = 19600, 19300, 19900 #Bits Carrier Frequency
y0=amp*np.cos(2*np.pi*F0*tBit) #Bit0
winB=np.hanning(len(y0)) #Applying Windows
y0=y0*winB
y1=amp*np.cos(2*np.pi*F1*tBit) #Bit1
y1=y1*winB #Applying Windows
ysync=ampS*np.cos(2*np.pi*Fsync*tBit) #Bit for Synchronization
winS=np.hanning(len(ysync)) #Applying Windows
ysync=ysync*winS
ySilence=amp*np.sin(2*np.pi*0*tBit) #Adding Silence in between all bits
y0=np.concatenate([ySilence,y0,ySilence,ysync]) #Bit0 coupled with silence and Sync
y1=np.concatenate([ySilence,y1,ySilence,ysync]) #Bit1 coupled with silence and Sync
guids1=guids[0] #First available guid
signature=ysync #Declare and place Sync
for g in guids1: #Complete Concatenated Signature
if g=='0': # concatenate Bit0
signature=np.concatenate([signature,y0])
else: # concatenate Bit1
signature=np.concatenate([signature,y1])
return signature
def test_calculate_lanczos_kernel(self):
"""
Tests the kernels implemented in C against their numpy counterpart.
"""
x = np.linspace(-5, 5, 11)
values = calculate_lanczos_kernel(x, 5, "hanning")
np.testing.assert_allclose(
values["only_sinc"], np.sinc(x), atol=1E-9)
np.testing.assert_allclose(
values["only_taper"], np.hanning(len(x)), atol=1E-9)
np.testing.assert_allclose(
values["full_kernel"], np.sinc(x) * np.hanning(len(x)),
atol=1E-9)
values = calculate_lanczos_kernel(x, 5, "blackman")
np.testing.assert_allclose(
values["only_sinc"], np.sinc(x), atol=1E-9)
np.testing.assert_allclose(
values["only_taper"], np.blackman(len(x)), atol=1E-9)
np.testing.assert_allclose(
values["full_kernel"], np.sinc(x) * np.blackman(len(x)),
atol=1E-9)
values = calculate_lanczos_kernel(x, 5, "lanczos")
np.testing.assert_allclose(
values["only_sinc"], np.sinc(x), atol=1E-9)
np.testing.assert_allclose(
values["only_taper"], np.sinc(x / 5.0), atol=1E-9)
np.testing.assert_allclose(
values["full_kernel"], np.sinc(x) * np.sinc(x / 5.0),
atol=1E-9)
def spec_est2(A,d1,d2,win=True):
""" computes 2D spectral estimate of A
obs: the returned array is fftshifted
and consistent with the f1,f2 arrays
d1,d2 are the sampling rates in rows,columns """
import numpy as np
l1,l2,l3 = A.shape
df1 = 1./(l1*d1)
df2 = 1./(l2*d2)
f1Ny = 1./(2*d1)
f2Ny = 1./(2*d2)
f1 = np.arange(-f1Ny,f1Ny,df1)
f2 = np.arange(-f2Ny,f2Ny,df2)
if win == True:
wx = np.matrix(np.hanning(l1))
wy = np.matrix(np.hanning(l2))
window_s = np.repeat(np.array(wx.T*wy),l3).reshape(l1,l2,l3)
else:
window_s = np.ones((l1,l2,l3))
an = np.fft.fft2(A*window_s,axes=(0,1))
E = (an*an.conjugate()) / (df1*df2) / ((l1*l2)**2)
E = np.fft.fftshift(E)
E = E.mean(axis=2)
return np.real(E),f1,f2,df1,df2,f1Ny,f2Ny
def hanning_taper(self, side='both', channels=None, offset=0):
"""Hanning taper
Parameters
----------
side : {'left', 'right', 'both'}
channels : {None, int}
The number of channels to taper. If None 5% of the total
number of channels are tapered.
offset : int
Returns
-------
channels
"""
if channels is None:
channels = int(round(len(self()) * 0.02))
if channels < 20:
channels = 20
dc = self.data
if side == 'left' or side == 'both':
dc[..., offset:channels+offset] *= (
np.hanning(2*channels)[:channels])
dc[...,:offset] *= 0.
if side== 'right' or side == 'both':
if offset == 0:
rl = None
else:
rl = -offset
dc[..., -channels-offset:rl] *= (
np.hanning(2*channels)[-channels:])
if offset != 0:
dc[..., -offset:] *= 0.
return channels
def lcn_octaves(X, kernel):
"""Apply octave-varying contrast normalization to an input with a given
kernel.
Notes:
* This is the variant introduced in the LVCE Section of Chapter 5.
* This approach is painfully heuristic, and tuned for the dimensions used
in this work (36 bpo, 7 octaves).
Parameters
----------
X : np.ndarray, ndim=2, shape[1]==252.
CQT representation, with 36 bins per octave and 252 filters.
kernel : np.ndarray
Convolution kernel (should be roughly low-pass).
Returns
-------
Z : np.ndarray
The processed output.
"""
if X.shape[-1] != 252:
raise ValueError(
"Apologies, but this method is currently designed for input "
"representations with a last dimension of 252.")
x_hp = highpass(X, kernel)
x_73 = local_l2norm(x_hp, np.hanning(73).reshape(1, -1))
x_37 = local_l2norm(x_hp, np.hanning(37).reshape(1, -1))
x_19 = local_l2norm(x_hp, np.hanning(19).reshape(1, -1))
x_multi = np.array([x_73, x_37, x_19]).transpose(1, 2, 0)
w = _create_triband_mask()**2.0
return (x_multi * w).sum(axis=-1)
def applyWindow(self, window="hanning", ww=0, cf=0):
'''
Apply window function to frequency domain data
cf: the frequency the window is centered over [Hz]
ww: the window width [Hz], if ww equals 0 the window covers the full range
'''
self.info("Applying %s window ..." % window)
if window == "hanning":
if ww == 0:
w = np.hanning(self.numfreq)
else:
pos = int((cf - self.lowF) / self.deltaF)
halfwidth = int(ww / (2.0 * self.deltaF))
w = np.zeros(self.numfreq)
w[pos - halfwidth:pos + halfwidth] = np.hanning(2 * halfwidth)
elif window == "hamming":
if ww == 0:
w = np.hamming(self.numfreq)
else:
pos = int((cf - self.lowF) / self.deltaF)
halfwidth = int(ww / (2.0 * self.deltaF))
w = np.zeros(self.numfreq)
w[pos - halfwidth:pos + halfwidth] = np.hamming(2 * halfwidth)
elif window == "blackman":
if ww == 0:
w = np.blackman(self.numfreq)
else:
pos = int((cf - self.lowF) / self.deltaF)
halfwidth = int(ww / (2.0 * self.deltaF))
w = np.zeros(self.numfreq)
w[pos - halfwidth:pos + halfwidth] = np.blackman(2 * halfwidth)
self.data = self.data * w
self.done()
def __init__(self):
""" """
# self.in_filename = 'WURB-1_20160612T230008+0200_N57.6629E12.6390_FS-384_Enil_UTAN_KON_TESTFIL-INDATA-FDX.wav'
self.in_filename = 'TEST_FS384.wav'
self.out_filename = 'TEST_FDX.wav'
self.sample_rate_in = 384000
self.sample_rate_out = 38400 ###### 44100
self.channels = 1
self.sample_width = 2 # 16 bits.
# self.buffer_size_in = 1024 * 16
self.buffer_size_in = 1024 * 4
# self.buffer_size_in = 1024 * 2
# self.buffer_size_out = 1878
# self.buffer_size_out = 648
# self.buffer_size_out = 204
self.buffer_size_out = 408
# self.buffer_size_out = 202
self.divide_factor = 10
self.overlap_in = self.buffer_size_in / 2
self.overlap_out = self.buffer_size_out / 2
# Create Hann window
# self.window_in=0.5-np.cos(np.arange(self.buffer_size_in,dtype='float')*2.0*np.pi/(self.buffer_size_in-1))*0.5
# self.window_out=0.5-np.cos(np.arange(self.buffer_size_out,dtype='float')*2.0*np.pi/(self.buffer_size_out-1))*0.5
self.window_in=np.hanning(self.buffer_size_in)
self.window_out=np.hanning(self.buffer_size_out)
#
self.extra_freq_bins = None
# Perform translation.
self.from_fs384_to_fdx()
def de_disperse(Data, DM, del_t):
""" De-disperses pulsar data. First fourier transforms data along time axis then get
the fourier frequencies with length "ntimes". The FT is then multiplied by the delay
phase factor, correcting for dispersion, and data is transformed back.
Parameters
----------
Data : float or array of floats
Pulsar data array. Assumes (freq, corr_prod, time)
DM :
Pulsar dispersion measure in pc/cm**3
del_t:
Total observation time in seconds
Returns
-------
De-dispersed data
"""
n_times = Data.shape[-1]
FT_Data = np.fft.fft(np.hanning(n_times)[np.newaxis, :] * Data, axis=-1)
ft_freq = np.fft.fftfreq(n_times)
delay_nu = time_delay(DM, Data.shape[0])[0]
FT_Data = FT_Data * np.exp(2j * np.pi * ft_freq[np.newaxis, :] * delay_nu[:, np.newaxis] * n_times / del_t)
return np.fft.fft(np.hanning(n_times)[np.newaxis, :] * FT_Data, axis=-1)
def hanningWindow(nx, ny, nPixX, nPixY): """ Return a Hanning window in 2D Args: nx (TYPE): number of pixels in x-direction of mask ny (TYPE): number of pixels in y-direction of mask nPixX (TYPE): number of pixels in x-direction of the transition nPixY (TYPE): number of pixels in y-direction of the transition Returns: real: 2D apodization mask """ winX = np.hanning(nPixX) winY = np.hanning(nPixY) winOutX = np.ones(nx) winOutX[0:nPixX/2] = winX[0:nPixX/2] winOutX[-nPixX/2:] = winX[-nPixX/2:] winOutY = np.ones(ny) winOutY[0:nPixY/2] = winY[0:nPixY/2] winOutY[-nPixY/2:] = winY[-nPixY/2:] return np.outer(winOutX, winOutY)
def ripoc(f, g, M = 50, fitting_shape = (9, 9)):
hy = numpy.hanning(f.shape[0])
hx = numpy.hanning(f.shape[1])
hw = hy.reshape(hy.shape[0], 1) * hx
ff = f * hw
gg = g * hw
F = scipy.fftpack.fft2(ff)
G = scipy.fftpack.fft2(gg)
F = scipy.fftpack.fftshift(numpy.log(numpy.abs(F)))
G = scipy.fftpack.fftshift(numpy.log(numpy.abs(G)))
FLP = logpolar(F, (F.shape[0] / 2, F.shape[1] / 2), M)
GLP = logpolar(G, (G.shape[0] / 2, G.shape[1] / 2), M)
R = poc(FLP, GLP)
angle = -R[1] / F.shape[0] * 360
scale = 1.0 - R[2] / 100
center = tuple(numpy.array(g.shape) / 2)
rot = cv2.getRotationMatrix2D(center, -angle, 1.0 + (1.0 - scale))
g_dash = cv2.warpAffine(g, rot, (g.shape[1], g.shape[0]), flags=cv2.INTER_LANCZOS4)
t = poc(f, g_dash)
return (t[1], t[2], angle, scale)
def gen_spec(self,x,m):
itsreal = np.isreal(x[0])
lx = x.size
nt = (lx +m -1) // m
xb = np.append(x,np.zeros(-lx+nt*m))
xc = np.append(np.roll(x,int(m/2)),np.zeros(nt*m - lx))
xr = np.reshape(xb, (m,nt), order='F') * np.outer(np.hanning(m),np.ones(nt))
xs = np.reshape(xc, (m,nt), order='F') * np.outer(np.hanning(m),np.ones(nt))
xm = np.zeros((m,2*nt),dtype='complex')
xm[:,::2] = xr
xm[:,1::2] = xs
#xm=xr
if itsreal:
spec = np.fft.fft(xm,m,axis=0)[int(m/2):]
else:
spec = np.fft.fftshift(np.fft.fft(xm,m,axis=0))
mx = np.max(spec)
pwr = 64*(20* np.log(np.abs(spec)/mx + 1e-6) + 60 )/60
return np.real(pwr)
def bell(size, ratio): n = size / ratio first_half = numpy.hanning(n * 2)[:n] * 65535 r = size - n second_half = numpy.hanning(r * 2)[r:] * 65535 bell = list(first_half) + list(second_half) + [0] return bell
def compute_window(x, crop1, crop2, MARGIN=0, Pow=1):
#
# __margin__
# / \
# c1 c2
# 1D Function
# -----------
w = np.ones(x)
c1 = crop1 + MARGIN
c2 = crop2+MARGIN
w[:c1] = np.hanning(2*c1)[:c1]**Pow
w[-c2:] = np.hanning(2*c2)[-c2:]**Pow
#~ import matplotlib.pyplot as plt
#~ plt.figure()
#~ plt.plot(w)
#~ plt.plot(1-w)
#~ plt.show()
# Turn into 2D : distance to the center
# -------------------------------------
R, C = generate_coords((x, x))
rmax = int(R.max()-0.5)
M = np.int32(rmax-np.sqrt((R+0.5)**2+(C+0.5)**2));
M[M<0] = 0
return w[M]
def window_func_2d(height, width):
win_col = np.hanning(width)
win_row = np.hanning(height)
mask_col, mask_row = np.meshgrid(win_col, win_row)
win = mask_col * mask_row
return win
def comp_sig_repr(self):
"""Computes the signal representation, stft
"""
if not hasattr(self.audioObject, '_data'):
self.audioObject._read()
if self.verbose:
print ("Computing the chosen signal representation:")
nc = self.audioObject.channels
if nc != 2:
raise ValueError("This implementation only deals "+
"with stereo audio!")
self.sig_repr = {}
# if more than 1min of signal, take 1 min in the middle
# better way : sample data so as to take randomly in the signal
lengthData = self.audioObject.data.shape[0]
startData = 0
endData = lengthData
oneMinLenData = 60*self.audioObject.samplerate
oneMinLenData *= 2 # or more than 1min?
if lengthData>oneMinLenData:
startData = (lengthData - oneMinLenData)/2
endData = startData + oneMinLenData
if self.sig_repr_params['tfrepresentation'] == 'stftold':
self.sig_repr[0], freqs, times = ao.stft(
self.audioObject.data[startData:endData,0],
window=np.hanning(self.sig_repr_params['wlen']),
hopsize=self.sig_repr_params['hopsize'],
nfft=self.sig_repr_params['fsize'],
fs=self.audioObject.samplerate
)
self.sig_repr[1], freqs, times = ao.stft(
self.audioObject.data[startData:endData,1],
window=np.hanning(self.sig_repr_params['wlen']),
hopsize=self.sig_repr_params['hopsize'],
nfft=self.sig_repr_params['fsize'],
fs=self.audioObject.samplerate
)
else:
self.tft.computeTransform(
self.audioObject.data[startData:endData,0],)
self.sig_repr[0] = self.tft.transfo
self.tft.computeTransform(
self.audioObject.data[startData:endData,1],)
self.sig_repr[1] = self.tft.transfo
freqs = self.tft.freq_stamps
# keeping the frequencies, not computing them each time
self.freqs = freqs
del self.audioObject.data
def initialize(self, frame, target_centre, target_shape, context=2,
features=no_op, learn_filter=learn_mosse,
increment_filter=increment_mosse, response_cov=3,
n_perturbations=10, noise_std=0.04, l=0.01,
normalize=normalizenorm_vec, mask=True,
boundary='constant'):
self.target_shape = target_shape
self.learn_filter = learn_filter
self.increment_filter = increment_filter
self.features = features
self.l = l
self.normalize = normalize
self.boundary = boundary
# compute context shape
self.context_shape = np.round(context * np.asarray(target_shape))
self.context_shape[0] += (0 if np.remainder(self.context_shape[0], 2)
else 1)
self.context_shape[1] += (0 if np.remainder(self.context_shape[1], 2)
else 1)
# compute subframe size
self.subframe_shape = self.context_shape + 8
# compute target centre coordinates in subframe
self.subframe_target_centre = PointCloud((
self.subframe_shape // 2)[None])
# extract subframe
subframe = frame.extract_patches(target_centre,
patch_size=self.subframe_shape)[0]
# compute features
subframe = self.features(subframe)
# obtain targets
targets = extract_targets(subframe, self.subframe_target_centre,
self.context_shape, n_perturbations,
noise_std)
# generate gaussian response
self.response = generate_gaussian_response(self.target_shape[-2:],
response_cov)
if mask:
cy = np.hanning(self.context_shape[0])
cx = np.hanning(self.context_shape[1])
self.cosine_mask = cy[..., None].dot(cx[None, ...])
targets_pp = []
for j, t in enumerate(targets):
targets_pp.append(self._preprocess_vec(t))
targets_pp = np.asarray(targets_pp)
self.filter, self.num, self.den = self.learn_filter(
targets_pp, self.response, l=self.l, boundary=self.boundary)
def get_wins(correlation):
# Initialize array for windows
win_signl = np.zeros(len(correlation.data))
win_noise = np.zeros(len(correlation.data))
success = False
# Determine window bounds for signal window
s_0 = int((len(correlation.data)-1)/2)
t_lo = int((correlation.stats.sac['dist']/minp.g_speed-minp.hw)*\
correlation.stats.sampling_rate)
t_hi = int((correlation.stats.sac['dist']/minp.g_speed+minp.hw)*\
correlation.stats.sampling_rate)
w_ind = (s_0-t_hi+1, s_0-t_lo+1, s_0+t_lo, s_0+t_hi)
if w_ind[2] < w_ind[1] and minp.win_overlap == False:
if minp.verbose == True:
print 'No windows found. (Windows overlap) '
return win_signl, win_noise, success
# Construct signal window
if minp.window == 'boxcar':
win_signl[w_ind[0]:w_ind[1]] += 1.
win_signl[w_ind[2]:w_ind[3]] += 1.
elif minp.window == 'hann':
win_signl[w_ind[0]:w_ind[1]] += np.hanning(w_ind[1]-w_ind[0])
win_signl[w_ind[2]:w_ind[3]] += np.hanning(w_ind[3]-w_ind[2])
# Determine window bounds for noise window
noisewinshift = minp.sepsignoise*minp.hw
t_lo = t_hi + int(noisewinshift*correlation.stats.sampling_rate)
t_hi = t_lo + int(2*minp.hw*correlation.stats.sampling_rate)
w_ind = (s_0-t_hi+1, s_0-t_lo+1, s_0+t_lo, s_0+t_hi)
# Out of bounds?
if w_ind[0] < 0 or w_ind[3] > len(correlation.data):
if minp.verbose == True:
print 'No windows found. (Noise window not covered by data)'
# return two zero arrays - no measurement possible
return win_noise, win_noise, success
# Construct noise window
if minp.window == 'boxcar':
win_noise[w_ind[0]:w_ind[1]] += 1.
win_noise[w_ind[2]:w_ind[3]] += 1.
elif minp.window == 'hann':
win_noise[w_ind[0]:w_ind[1]] += np.hanning(w_ind[1]-w_ind[0])
win_noise[w_ind[2]:w_ind[3]] += np.hanning(w_ind[3]-w_ind[2])
success = True
return win_signl, win_noise, success
def hanning2D(M, N):
"""
A 2D hanning window, as per IDL's hanning function. See numpy.hanning for the 1D description
"""
if N <= 1:
return np.hanning(M)
elif M <= 1:
return np.hanning(N) # scalar unity; don't window if dims are too small
else:
return np.outer(np.hanning(M),np.hanning(N))
def test_winf(self):
signal = np.arange(10)
winf = np.arange(5)
windows = utils.sliding_window(signal, 5, 2, winf)
self.assertEqual(windows.shape, (3, 5))
np.testing.assert_equal(windows[:, 0], [0, 0, 0])
np.testing.assert_equal(windows[0, :], np.arange(5) ** 2)
self.assertEqual(utils.sliding_window(signal, 5, 2, np.hanning(5)).dtype,
np.hanning(5).dtype)
def spec2ts(spec, sr):
"""Create time series with random (normal) phases from power spectrum."""
phase = np.random.normal(0, pi, len(spec))
ts_elev = np.fft.irfft(np.sqrt(spec*len(spec)*sr)*np.exp(1j*phase))
# Taper down last second of ts so it can repeat
ramp = np.hanning(sr*2)[0:sr]
ts_elev[:sr] = ts_elev[:sr]*ramp
ramp = np.hanning(sr*2)[sr:]
ts_elev[-sr:] = ts_elev[-sr:]*ramp
return ts_elev
def mainloop(self, q,q2,st):
j={'F3':[], 'O2':[], 'O1':[], 'F8':[], 'F4':[], 'FC6':[], 'AF3':[], 'P7':[], 'P8':[], 'FC5':[], 'T8':[], 'AF4':[], 'F7':[], 'T7':[]}
b={}
#q2.put("Hi")
firstdat=q.recv()
#fileh=open("C:/Users/Gaurav/Desktop/Testlogs.txt", "w")
#fileh.write(str(firstdat))
#fileh.close()
#q2.put('Hi')
if type(firstdat)==str:q2.put(firstdat)
#if firstdat=="j":q2.put("j")
for i in self.sensors:
current=firstdat[i]
b[i]=current
artree=PreprocessUtils.highpass(current)
win32=numpy.hanning(512)
artree=numpy.array(artree)
stuff1=win32*artree
stuff2=PreprocessUtils.bin_power(stuff1, [1,4,8,12,30], 128)
stuff4=abs(20*numpy.log(stuff2))
stuff5=tuple(stuff4[0])
j[i].append(stuff5)
#time.sleep(16/128)
q2.send(j)
while True:
secondat=q.recv()
#q2.send("recieved one")
#fileh=open("C:/Users/Gaurav/Desktop/Testlogs.txt", "w")
#fileh.write(str(secondat))
#fileh.close()
#q2.put('Hi')
if type(secondat)==str:q2.put(secondat)
#if str(secondat)=="die": q2.put("die");break
for i in self.sensors:
current=b[i]
del current[0:16]
current+=secondat[i]
#q2.put(len(current))
b[i]=current
artree=PreprocessUtils.highpass(current)
#q2.send("Highpass")
win32=numpy.hanning(512)
artree=numpy.array(artree)
stuff1=win32*artree
stuff2=PreprocessUtils.bin_power(stuff1, [1,4,8,12,30], 128)
stuff4=abs(20*numpy.log(stuff2))
stuff5=tuple(stuff4[0])
j[i].append(stuff5)
#time.sleep(16/128)
#if len(j["FC5"])==st:
q2.send(j)
for i in j.keys():
j[i]=[]
def __next__(self):
seq_id = np.random.randint(self.n_seq)
start_frame = self.ranges[seq_id][0]
end_frame = self.ranges[seq_id][1]
idx = np.random.randint(end_frame-start_frame-self.lookahead)
lh_idx = idx + np.random.randint(self.lookahead)+1
bbox = np.copy(self.gt[seq_id][idx])
lh_bbox = np.copy(self.gt[seq_id][lh_idx])
img_path = self.img_dir + ('/%s/%06d.JPEG'%(self.seq_names[seq_id], (start_frame-1)+idx))
lh_img_path = self.img_dir + ('/%s/%06d.JPEG'%(self.seq_names[seq_id],(start_frame-1)+lh_idx))
# resize the image mainly for reducing computational cost
scale = 1
if bbox[2:].prod() > self.max_object_sz**2:
scale = self.max_object_sz/(bbox[2:].max())
image = Image.open(img_path).convert('RGB')
lh_image = Image.open(lh_img_path).convert('RGB')
if scale!=1:
image = image.resize((int(image.size[0]*scale),int(image.size[1]*scale)), Image.BICUBIC)
lh_image = lh_image.resize((int(lh_image.size[0]*scale),int(lh_image.size[1]*scale)), Image.BICUBIC)
bbox = np.round(bbox*scale)
lh_bbox = np.round(lh_bbox*scale)
# calculate sizes
target_sz = bbox[2:]
target_center = bbox[:2] + np.floor(target_sz/2)
target_cell_sz = np.ceil(target_sz/self.cell_sz)
window_sz = get_search_size(target_sz)
window_cell_sz = np.ceil(window_sz/self.cell_sz)
window_cell_sz = window_cell_sz - (window_cell_sz%2) + 1
# get center cropped patch for current image
center = bbox[:2] + np.floor(target_sz/2)
patch = get_search_patch(image, center, window_sz)
# get center cropped patch for lookahead image
# patch size is same
lh_target_sz = lh_bbox[2:]
lh_center = lh_bbox[:2] + np.floor(lh_target_sz/2)
lh_patch = get_search_patch(lh_image, lh_center, window_sz)
# get some windows
cos_window = np.outer(np.hanning(window_cell_sz),np.hanning(window_cell_sz))
cos_window = cos_window[None,None,:,:].repeat(self.feat_num_channels,axis=1)
output_sigma = target_cell_sz*self.output_sigma_factor
label_map = gaussian_shaped_labels(output_sigma, window_cell_sz, target_sz)
# tensorize them
patch = torch.from_numpy(patch[None,:]).float()
lh_patch = torch.from_numpy(lh_patch[None,:]).float()
label_map = torch.from_numpy(label_map[None,None,:]).float()
cos_window = torch.from_numpy(cos_window).float()
return patch, lh_patch, target_cell_sz, label_map, cos_window, seq_id
def hanning2d(M, N):
"""
A 2D hanning window, as per IDL's hanning function. See numpy.hanning for
the 1d description. Copied from http://code.google.com/p/agpy/source/browse/trunk/agpy/psds.py?r=343
"""
# scalar unity; don't window if dims are too small
if N <= 1:
return np.hanning(M)
elif M <= 1:
return np.hanning(N)
else:
return np.outer(np.hanning(M), np.hanning(N))
def applyWindow(self, samples, window='hanning'):
if window == 'bartlett':
return samples*np.bartlett(len(samples))
elif window == 'blackman':
return samples*np.hanning(len(samples))
elif window == 'hamming':
return samples*np.hamming(len(samples))
elif window == 'kaiser':
return samples*np.kaiser(len(samples))
else:
return samples*np.hanning(len(samples))
def initialize(self, frame, target_centre, target_shape, context=2,
features=no_op, learn_filter=learn_kcf,
kernel_correlation=gaussian_correlation, response_cov=3,
l=0.01, normalize=normalizenorm_vec, mask=True,
boundary='constant', **kwargs):
self.target_shape = target_shape
self.learn_filter = learn_filter
self.kernel_correlation = kernel_correlation
self.features = features
self.l = l
self.normalize = normalize
self.boundary = boundary
# compute context shape
self.context_shape = np.round(context * np.asarray(target_shape))
self.context_shape[0] += (0 if np.remainder(self.context_shape[0], 2)
else 1)
self.context_shape[1] += (0 if np.remainder(self.context_shape[1], 2)
else 1)
# compute subframe size
self.subframe_shape = self.context_shape + 8
# compute target centre coordinates in subframe
self.subframe_target_centre = PointCloud((
self.subframe_shape // 2)[None])
# extract subframe
subframe = frame.extract_patches(target_centre,
patch_size=self.subframe_shape)[0]
# compute features
subframe = self.features(subframe)
# obtain targets
target = subframe.extract_patches(self.subframe_target_centre,
patch_size=self.context_shape)[0]
# generate gaussian response
self.response = generate_gaussian_response(self.target_shape[-2:],
response_cov)
if mask:
cy = np.hanning(self.context_shape[0])
cx = np.hanning(self.context_shape[1])
self.cosine_mask = cy[..., None].dot(cx[None, ...])
target = self._preprocess_vec(target.pixels)
self.alpha, self.target = self.learn_filter(
target, self.response, kernel_correlation=self.kernel_correlation,
l=self.l, boundary=self.boundary, **kwargs)
def _compute_fft(i_data, q_data, correct_phase, iq_correction_wideband,
hide_differential_dc_offset, convert_to_dbm, apply_window, decimation, iqswapedbit, Rx_Bw):
Nsamp = len(i_data)
rbw = Rx_Bw/Nsamp
if hide_differential_dc_offset:
i_data = i_data - np.mean(i_data)
q_data = q_data - np.mean(q_data)
if apply_window:
i_data = i_data * np.hanning(len(i_data))
q_data = q_data * np.hanning(len(q_data))
if correct_phase:
phi2_deg = 52 # phase error after which the T.D algorithm is skipped to avoid noise floor jumping
# Measuring phase error
phi_rad, Phi_deg = measurePhaseError(i_data, q_data)
if decimation == 1: # F.D + T.D corrections
if abs(Phi_deg) < phi2_deg:
# T.D correction
i_cal, q_cal = _calibrate_i_q_tarek1(i_data, q_data, phi_rad)
# F.D correction
i_data, q_data = imageAttenuation(i_cal, q_cal, Phi_deg, iqswapedbit, iq_correction_wideband, Rx_Bw, rbw)
else:
# F.D correction only at the edges
q_data = q_data * np.sqrt(sum(i_data ** 2)/sum(q_data ** 2))
i_data, q_data = imageAttenuation(i_data, q_data, Phi_deg, iqswapedbit, iq_correction_wideband, Rx_Bw, rbw)
else:
# Only T.D correction at the decimation level > 1
i_data, q_data = _calibrate_i_q_tarek1(i_data, q_data, phi_rad)
i_data = i_data - np.mean(i_data)
q_data = q_data - np.mean(q_data)
iq = i_data + 1j * q_data
if apply_window:
iq = iq * np.hanning(len(i_data))
power_spectrum = np.abs(np.fft.fftshift(np.fft.fft(iq)))/len(i_data)
if convert_to_dbm:
power_spectrum = 20 * np.log10(power_spectrum)
if hide_differential_dc_offset:
median_index = len(power_spectrum) // 2
power_spectrum[median_index] = (power_spectrum[median_index - 1]
+ power_spectrum[median_index + 1]) / 2
return power_spectrum
def test_dft_2d(self):
"""Test the discrete Fourier transform on 2D data"""
N = 16
da = xr.DataArray(np.random.rand(N,N), dims=['x','y'],
coords={'x':range(N),'y':range(N)}
)
ft = xrft.dft(da, shift=False)
npt.assert_almost_equal(ft.values, np.fft.fftn(da.values))
ft = xrft.dft(da, shift=False, window=True, detrend='constant')
dim = da.dims
window = np.hanning(N) * np.hanning(N)[:, np.newaxis]
da_prime = (da - da.mean(dim=dim)).values
npt.assert_almost_equal(ft.values, np.fft.fftn(da_prime*window))
def window(data, window='hanning', renormalize=1):
''' Windows the data with hanning window
If renormalize is set to 1, the data is multiplied by
a factor which makes the mean squared amplitude of the
windowed data equal to the mean squared amplitude of the
original data. This is important for normalizing a PSD
correctly.
'''
N = len(data)
rescale = (8/3.)**0.5 # normalize the power for a hanning window
if renormalize == 1:
return data*np.hanning(N)*rescale
else:
return data*np.hanning(N)
def _init_window(self, fs):
self.fs = fs
self.window_size = int(MAGIC_NUMBER * fs)
self.window = np.hanning(self.window_size)
def make_sound(rate=44100, frequency=5000, duration=0.1, amplitude=1,
fade=0.01, chans='L+TTL'):
"""
Build sounds and save bin file for upload to soundcard or play via
sounddevice lib.
:param rate: sample rate of the soundcard use 96000 for Bpod,
defaults to 44100 for soundcard
:type rate: int, optional
:param frequency: (Hz) of the tone, if -1 will create uniform random white
noise, defaults to 10000
:type frequency: int, optional
:param duration: (s) of sound, defaults to 0.1
:type duration: float, optional
:param amplitude: E[0, 1] of the sound 1=max 0=min, defaults to 1
:type amplitude: intor float, optional
:param fade: (s) time of fading window rise and decay, defaults to 0.01
:type fade: float, optional
:param chans: ['mono', 'L', 'R', 'stereo', 'L+TTL', 'TTL+R'] number of
sound channels and type of output, defaults to 'L+TTL'
:type chans: str, optional
:return: streo sound from mono definitions
:rtype: np.ndarray with shape (Nsamples, 2)
"""
sample_rate = rate # Sound card dependent,
tone_duration = duration # sec
fade_duration = fade # sec
tvec = np.linspace(0, tone_duration, tone_duration * sample_rate)
tone = amplitude * np.sin(2 * np.pi * frequency * tvec) # tone vec
len_fade = int(fade_duration * sample_rate)
fade_io = np.hanning(len_fade * 2)
fadein = fade_io[:len_fade]
fadeout = fade_io[len_fade:]
win = np.ones(len(tvec))
win[:len_fade] = fadein
win[-len_fade:] = fadeout
tone = tone * win
ttl = np.ones(len(tone)) * 0.99
one_ms = round(sample_rate/1000) * 10
ttl[one_ms:] = 0
null = np.zeros(len(tone))
if frequency == -1:
tone = amplitude * np.random.rand(tone.size)
if chans == 'mono':
sound = np.array(tone)
elif chans == 'L':
sound = np.array([tone, null]).T
elif chans == 'R':
sound = np.array([null, tone]).T
elif chans == 'stereo':
sound = np.array([tone, tone]).T
elif chans == 'L+TTL':
sound = np.array([tone, ttl]).T
elif chans == 'TTL+R':
sound = np.array([ttl, tone]).T
return sound
lag_sum = 0
sumarray = np.zeros(n + lag)
sumarray[:n] = data[frame_index:frame_index + n]
sumarray[:n] *= data[frame_index + lag:frame_index + n + lag]
lag_sum = np.sum(sumarray[:n])
ccf.append(lag_sum)
nccf.append(lag_sum / np.sqrt(e[frame_index] * e[frame_index + lag]))
return ccf, nccf
# storage
data = util.load_wav(input_file)
cc_correlogram = []
nccf_correlogram = []
best_frequencies = []
hann = np.hanning(frame_width)
# pre-calculate normalization factor data
squared_data = []
for i in range(0, len(data)):
squared_data.append(data[i]**2)
e = [0.0]
for i in range(0, frame_width - 1):
e[0] += squared_data[i]
for i in range(0, len(data) - frame_width):
e.append(e[i - 1] - squared_data[i - 1] + squared_data[i + frame_width])
for i in tqdm(range(0, int((len(data) - frame_width * 2) / spacing))):
cc, ncc = nccf(data, i * spacing, e, bitrate // f_max, bitrate // f_min)
def hanning2d(M, N):
"""
A 2D hanning window created by outer product.
"""
return np.outer(np.hanning(M), np.hanning(N))
def tracker(hp, run, design, frame_name_list, pos_x, pos_y, target_w, target_h,
final_score_sz, filename, image, templates_z, scores, start_frame):
num_frames = np.size(frame_name_list)
# stores tracker's output for evaluation
bboxes = np.zeros((num_frames, 4))
scale_factors = hp.scale_step**np.linspace(-np.ceil(hp.scale_num / 2),
np.ceil(hp.scale_num / 2),
hp.scale_num)
# cosine window to penalize large displacements
hann_1d = np.expand_dims(np.hanning(final_score_sz), axis=0)
penalty = np.transpose(hann_1d) * hann_1d
penalty = penalty / np.sum(penalty)
context = design.context * (target_w + target_h)
z_sz = np.sqrt(np.prod((target_w + context) * (target_h + context)))
x_sz = float(design.search_sz) / design.exemplar_sz * z_sz
# thresholds to saturate patches shrinking/growing
min_z = hp.scale_min * z_sz
max_z = hp.scale_max * z_sz
min_x = hp.scale_min * x_sz
max_x = hp.scale_max * x_sz
# run_metadata = tf.RunMetadata()
# run_opts = {
# 'options': tf.RunOptions(trace_level=tf.RunOptions.FULL_TRACE),
# 'run_metadata': run_metadata,
# }
run_opts = {}
# with tf.Session(config=tf.ConfigProto(log_device_placement=True)) as sess:
with tf.Session() as sess:
tf.global_variables_initializer().run()
# Coordinate the loading of image files.
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(coord=coord)
# save first frame position (from ground-truth)
bboxes[
0, :] = pos_x - target_w / 2, pos_y - target_h / 2, target_w, target_h
image_, templates_z_ = sess.run(
[image, templates_z],
feed_dict={
siam.pos_x_ph: pos_x,
siam.pos_y_ph: pos_y,
siam.z_sz_ph: z_sz,
filename: frame_name_list[0]
})
new_templates_z_ = templates_z_
t_start = time.time()
# Get an image from the queue
for i in range(1, num_frames):
scaled_exemplar = z_sz * scale_factors
scaled_search_area = x_sz * scale_factors
scaled_target_w = target_w * scale_factors
scaled_target_h = target_h * scale_factors
image_, scores_ = sess.run(
[image, scores],
feed_dict={
siam.pos_x_ph: pos_x,
siam.pos_y_ph: pos_y,
siam.x_sz0_ph: scaled_search_area[0],
siam.x_sz1_ph: scaled_search_area[1],
siam.x_sz2_ph: scaled_search_area[2],
templates_z: np.squeeze(templates_z_),
filename: frame_name_list[i],
},
**run_opts)
scores_ = np.squeeze(scores_)
# penalize change of scale
scores_[0, :, :] = hp.scale_penalty * scores_[0, :, :]
scores_[2, :, :] = hp.scale_penalty * scores_[2, :, :]
# find scale with highest peak (after penalty)
new_scale_id = np.argmax(np.amax(scores_, axis=(1, 2)))
# update scaled sizes
x_sz = (1 - hp.scale_lr
) * x_sz + hp.scale_lr * scaled_search_area[new_scale_id]
target_w = (
1 - hp.scale_lr
) * target_w + hp.scale_lr * scaled_target_w[new_scale_id]
target_h = (
1 - hp.scale_lr
) * target_h + hp.scale_lr * scaled_target_h[new_scale_id]
# select response with new_scale_id
score_ = scores_[new_scale_id, :, :]
score_ = score_ - np.min(score_)
score_ = score_ / np.sum(score_)
# apply displacement penalty
score_ = (1 - hp.window_influence
) * score_ + hp.window_influence * penalty
pos_x, pos_y = _update_target_position(pos_x, pos_y, score_,
final_score_sz,
design.tot_stride,
design.search_sz,
hp.response_up, x_sz)
# convert <cx,cy,w,h> to <x,y,w,h> and save output
bboxes[
i, :] = pos_x - target_w / 2, pos_y - target_h / 2, target_w, target_h
# update the target representation with a rolling average
if hp.z_lr > 0:
new_templates_z_ = sess.run(
[templates_z],
feed_dict={
siam.pos_x_ph: pos_x,
siam.pos_y_ph: pos_y,
siam.z_sz_ph: z_sz,
image: image_
})
templates_z_ = (1 - hp.z_lr) * np.asarray(
templates_z_) + hp.z_lr * np.asarray(new_templates_z_)
# update template patch size
z_sz = (1 - hp.scale_lr
) * z_sz + hp.scale_lr * scaled_exemplar[new_scale_id]
# if run.visualization:
# show_frame(image_, bboxes[i,:], 1)
t_elapsed = time.time() - t_start
speed = num_frames / t_elapsed
# Finish off the filename queue coordinator.
coord.request_stop()
coord.join(threads)
# from tensorflow.python.client import timeline
# trace = timeline.Timeline(step_stats=run_metadata.step_stats)
# trace_file = open('timeline-search.ctf.json', 'w')
# trace_file.write(trace.generate_chrome_trace_format())
plt.close('all')
return bboxes, speed
def inverse_spectrum_truncation(psd,
max_filter_len,
low_frequency_cutoff=None,
trunc_method=None):
"""Modify a PSD such that the impulse response associated with its inverse
square root is no longer than `max_filter_len` time samples. In practice
this corresponds to a coarse graining or smoothing of the PSD.
Parameters
----------
psd : FrequencySeries
PSD whose inverse spectrum is to be truncated.
max_filter_len : int
Maximum length of the time-domain filter in samples.
low_frequency_cutoff : {None, int}
Frequencies below `low_frequency_cutoff` are zeroed in the output.
trunc_method : {None, 'hann'}
Function used for truncating the time-domain filter.
None produces a hard truncation at `max_filter_len`.
Returns
-------
psd : FrequencySeries
PSD whose inverse spectrum has been truncated.
Raises
------
ValueError
For invalid types or values of `max_filter_len` and `low_frequency_cutoff`.
Notes
-----
See arXiv:gr-qc/0509116 for details.
"""
# sanity checks
if type(max_filter_len) is not int or max_filter_len <= 0:
raise ValueError('max_filter_len must be a positive integer')
if low_frequency_cutoff is not None and low_frequency_cutoff < 0 \
or low_frequency_cutoff > psd.sample_frequencies[-1]:
raise ValueError(
'low_frequency_cutoff must be within the bandwidth of the PSD')
N = (len(psd) - 1) * 2
inv_asd = FrequencySeries((1. / psd)**0.5, delta_f=psd.delta_f, \
dtype=complex_same_precision_as(psd))
inv_asd[0] = 0
inv_asd[N / 2] = 0
q = TimeSeries(numpy.zeros(N), delta_t=(N / psd.delta_f), \
dtype=real_same_precision_as(psd))
if low_frequency_cutoff:
kmin = int(low_frequency_cutoff / psd.delta_f)
inv_asd[0:kmin] = 0
ifft(inv_asd, q)
trunc_start = max_filter_len / 2
trunc_end = N - max_filter_len / 2
if trunc_method == 'hann':
trunc_window = Array(numpy.hanning(max_filter_len), dtype=q.dtype)
q[0:trunc_start] *= trunc_window[max_filter_len / 2:max_filter_len]
q[trunc_end:N] *= trunc_window[0:max_filter_len / 2]
q[trunc_start:trunc_end] = 0
psd_trunc = FrequencySeries(numpy.zeros(len(psd)), delta_f=psd.delta_f, \
dtype=complex_same_precision_as(psd))
fft(q, psd_trunc)
psd_trunc *= psd_trunc.conj()
psd_out = 1. / abs(psd_trunc)
return psd_out
def find_closest(date):
segundos = time.mktime(date.timetuple())
indice = np.argmin(np.abs(df_speed.index.values - segundos))
print('Hora de la captura',
datetime.datetime.fromtimestamp(df_speed.index[indice]))
print('Diferencia en minutos', (df_speed.index[indice] - segundos) / 60)
waveform = df_speed.iloc[indice]
b, a = signal.butter(3, 2 * 10 / fs, 'highpass', analog=False)
l = np.size(waveform)
l_mitad = int(l / 2)
f = np.arange(l) / l * fs
#----------quitamos los 2 HZ del principio
label = 'Peak'
cte_p = 1
cte_c = np.sqrt(2)
hann = np.hanning(l)
wave_f = signal.filtfilt(b, a, waveform)
sptrm_P = np.abs(np.fft.fft(wave_f * 2 * hann) / l)
sptrm_C = np.abs(np.fft.fft(wave_f * 1.63 * hann) / l)
TRH = 0 * np.std(sptrm_P[0:l_mitad]) / 3
indexes, properties = find_peaks(cte_p * 2 * sptrm_C[0:l_mitad],
height=TRH,
prominence=0.01,
width=1,
rel_height=0.75)
minorLocator = AutoMinorLocator()
#plt.figure(num=None, figsize=(24, 11), dpi=80, facecolor='w', edgecolor='k')
plt.figure(num=None, figsize=(18, 8), dpi=80, facecolor='w', edgecolor='k')
ax1 = plt.subplot2grid((4, 4), (0, 0), colspan=4, rowspan=4)
plt.plot(f[0:l_mitad], cte_p * 2 * sptrm_P[0:l_mitad], 'b')
#plt.plot(f[indexes] , cte_p*2*sptrm_P[indexes] ,'o')
for counter, k in enumerate(harm.columns):
if k[0] == 'i':
print(counter, k)
index = int(harm.iloc[indice][counter])
if f[index] != 0:
plt.plot(f[index], cte_p * 2 * sptrm_P[index], 'o')
plt.text(f[index], cte_p * 2 * sptrm_P[index], str(k))
plt.ylabel('mm/s ' + label)
plt.title(str(date))
plt.xlabel('Hz')
plt.grid(True)
plt.vlines(x=f[indexes],
ymin=cte_p * 2 * sptrm_P[indexes] - properties["prominences"],
ymax=cte_p * 2 * sptrm_P[indexes],
color="C1")
plt.hlines(y=properties["width_heights"],
xmin=f[properties["left_ips"].astype(int)],
xmax=f[properties["right_ips"].astype(int)],
color="C1")
# plt.hlines(y=properties["width_heights"], xmin=f[properties["left_bases"].astype(int)],xmax=f[properties["right_bases"].astype(int)], color = "C2")
ax1.xaxis.set_minor_locator(minorLocator)
plt.tick_params(which='both', width=2)
plt.tick_params(which='major', length=7)
plt.tick_params(which='minor', length=4, color='r')
return
def _loop_once():
'''Run the main loop once
This uses the global variables from setup and start, and adds a set of global variables
'''
global parser, args, config, r, response, patch, monitor, ft_host, ft_port, ft_input
global timeout, hdr_input, start, channel_items, channame, chanindx, item, prefix, begsample, endsample
global scale_window, offset_window, window, taper, frequency, band_items, bandname, bandlo, bandhi, lohi, dat, power, chan, band, meandat, sample, F, i, lo, hi, count, key
monitor.loop()
time.sleep(patch.getfloat('general', 'delay'))
scale_window = patch.getfloat('scale', 'window', default=1.)
offset_window = patch.getfloat('offset', 'window', default=0.)
window = patch.getfloat('processing', 'window', default=2)
window = EEGsynth.rescale(window, slope=scale_window, offset=offset_window)
monitor.update('window', window)
window = int(round(window * hdr_input.fSample)) # in samples
taper = np.hanning(window)
frequency = np.fft.rfftfreq(window, 1.0 / hdr_input.fSample)
band_items = config.items('band')
bandname = []
bandlo = []
bandhi = []
for item in band_items:
# channel numbers are one-offset in the ini file, zero-offset in the code
lohi = patch.getfloat('band', item[0], multiple=True)
bandname.append(item[0])
bandlo.append(lohi[0])
bandhi.append(lohi[1])
monitor.debug(bandname, bandlo, bandhi)
hdr_input = ft_input.getHeader()
if (hdr_input.nSamples - 1) < endsample:
raise RuntimeError("buffer reset detected")
if hdr_input.nSamples < window:
# there are not yet enough samples in the buffer
monitor.info("Waiting for data...")
return
# get the most recent data segment
begsample = hdr_input.nSamples - window
endsample = hdr_input.nSamples - 1
dat = ft_input.getData([begsample, endsample]).astype(np.double)
dat = dat[:, chanindx]
# demean the data to prevent spectral leakage
dat = detrend(dat, axis=0, type='constant')
# taper the data
dat = dat * taper[:, np.newaxis]
# compute the FFT over the sample direction
F = np.fft.rfft(dat, axis=0)
power = [0] * len(channame) * len(bandname)
i = 0
for chan in range(F.shape[1]):
for lo, hi in zip(bandlo, bandhi):
power[i] = 0
count = 0
for sample in range(len(frequency)):
if frequency[sample] >= lo and frequency[sample] <= hi:
power[i] += abs(F[sample, chan] * F[sample, chan])
count += 1
if count > 0:
power[i] /= count
i += 1
monitor.debug(power)
i = 0
for chan in channame:
for band in bandname:
key = "%s.%s.%s" % (prefix, chan, band)
patch.setvalue(key, power[i])
i += 1
"""
from warnings import warn
import numpy as np
from matplotlib.colors import is_color_like
from matplotlib.figure import Figure
from itertools import compress # noqa
import matplotlib
import matplotlib.pyplot as plt
import sphinx_gallery.backreferences
from local_module import N # N = 1000
t = np.arange(N) / float(N)
win = np.hanning(N)
print(is_color_like('r'))
fig, ax = plt.subplots()
ax.plot(t, win, color='r')
ax.text(0, 1, 'png', size=40, va='top')
fig.tight_layout()
orig_dpi = 80. if matplotlib.__version__[0] < '2' else 100.
assert plt.rcParams['figure.dpi'] == orig_dpi
plt.rcParams['figure.dpi'] = 70.
assert plt.rcParams['figure.dpi'] == 70.
listy = [0, 1]
compress('abc', [0, 0, 1])
warn('This warning should show up in the output', RuntimeWarning)
x = Figure() # plt.Figure should be decorated (class), x shouldn't (inst)
# nested resolution resolves to numpy.random.mtrand.RandomState:
rng = np.random.RandomState(0)
def smooth1d(x, window_len):
s = np.r_[2 * x[0] - x[window_len:1:-1], x,
2 * x[-1] - x[-1:-window_len:-1]]
w = np.hanning(window_len)
y = np.convolve(w / w.sum(), s, mode='same')
return y[window_len - 1:-window_len + 1]
def mavfft_fttd(logfile, multi_log):
'''display fft for raw ACC data in logfile'''
'''object to store data about a single FFT plot'''
class PlotData(object):
def __init__(self, ffth):
self.seqno = -1
self.fftnum = ffth.N
self.sensor_type = ffth.type
self.instance = ffth.instance
self.sample_rate_hz = ffth.smp_rate
self.multiplier = ffth.mul
self.data = {}
self.data["X"] = []
self.data["Y"] = []
self.data["Z"] = []
self.holes = False
self.freq = None
def add_fftd(self, fftd):
if fftd.N != self.fftnum:
print("Skipping ISBD with wrong fftnum (%u vs %u)\n" %
(fftd.N, self.fftnum))
return
if self.holes:
print("Skipping ISBD(%u) for ISBH(%u) with holes in it" %
(fftd.seqno, self.fftnum))
return
if fftd.seqno != self.seqno + 1:
print("ISBH(%u) has holes in it" % fftd.N)
self.holes = True
return
self.seqno += 1
self.data["X"].extend(fftd.x)
self.data["Y"].extend(fftd.y)
self.data["Z"].extend(fftd.z)
def overlap_windows(self, plotdata):
newplotdata = copy.deepcopy(self)
if plotdata.tag() != self.tag():
print("Invalid FFT data tag (%s vs %s) for window overlap" %
(plotdata.tag(), self.tag()))
return self
if plotdata.fftnum <= self.fftnum:
print("Invalid FFT sequence (%u vs %u) for window overlap" %
(plotdata.fftnum, self.fftnum))
return self
newplotdata.data["X"] = numpy.split(numpy.asarray(
self.data["X"]), 2)[1].tolist() + numpy.split(
numpy.asarray(plotdata.data["X"]), 2)[0].tolist()
newplotdata.data["Y"] = numpy.split(numpy.asarray(
self.data["Y"]), 2)[1].tolist() + numpy.split(
numpy.asarray(plotdata.data["Y"]), 2)[0].tolist()
newplotdata.data["Z"] = numpy.split(numpy.asarray(
self.data["Z"]), 2)[1].tolist() + numpy.split(
numpy.asarray(plotdata.data["Z"]), 2)[0].tolist()
return newplotdata
def prefix(self):
if self.sensor_type == 0:
return "Accel"
elif self.sensor_type == 1:
return "Gyro"
else:
return "?Unknown Sensor Type?"
def tag(self):
return str(self)
def __str__(self):
return "%s[%u]" % (self.prefix(), self.instance)
print("Processing log %s" % logfile)
mlog = mavutil.mavlink_connection(logfile)
# see https://holometer.fnal.gov/GH_FFT.pdf for a description of the techniques used here
things_to_plot = []
plotdata = None
prev_plotdata = {}
msgcount = 0
hntch_mode = None
hntch_option = None
batch_mode = None
start_time = time.time()
thr_total = 0.
thr_count = 0
while True:
m = mlog.recv_match(condition=args.condition)
if m is None:
break
msgcount += 1
if msgcount % 1000 == 0:
sys.stderr.write(".")
msg_type = m.get_type()
if msg_type == "ISBH":
if plotdata is not None:
sensor = plotdata.tag()
# close off previous data collection
# in order to get 50% window overlap we need half the old data + half the new data and then the new data itself
if args.fft_overlap and sensor in prev_plotdata:
things_to_plot.append(
prev_plotdata[sensor].overlap_windows(plotdata))
things_to_plot.append(plotdata)
prev_plotdata[sensor] = plotdata
plotdata = PlotData(m)
continue
if msg_type == "ISBD":
if plotdata is None:
sys.stderr.write("?(fftnum=%u)" % m.N)
continue
plotdata.add_fftd(m)
if msg_type == "PARM":
if m.Name == "INS_HNTCH_MODE":
hntch_mode = m.Value
elif m.Name == "INS_HNTCH_OPTS":
hntch_option = m.Value
elif m.Name == "INS_LOG_BAT_OPT":
batch_mode = m.Value
# get an average read of the throttle value assuming a stable hover above 1m
if args.notch_params and msg_type == "CTUN":
if m.Alt > 1:
thr_total += m.ThO
thr_count = thr_count + 1
print("", file=sys.stderr)
time_delta = time.time() - start_time
print("%us messages %u messages/second %u kB/second" %
(msgcount, msgcount / time_delta,
os.stat(filename).st_size / time_delta))
print("Extracted %u fft data sets" % len(things_to_plot), file=sys.stderr)
if args.notch_params:
thr_ref = thr_total / thr_count
print("Throttle average %f" % thr_ref)
sum_fft = {}
freqmap = {}
sample_rates = {}
counts = {}
window = {}
S2 = {}
hntch_mode_names = {0: "No", 1: "Throttle", 2: "RPM", 3: "ESC", 4: "FFT"}
hntch_option_names = {
0: "Single",
1: "Double",
2: "Dynamic",
4: "Loop-Rate"
}
batch_mode_names = {0: "Pre-filter", 1: "Sensor-rate", 2: "Post-filter"}
fft_peak = int(args.fft_peak)
first_freq = None
for thing_to_plot in things_to_plot:
fft_len = len(thing_to_plot.data["X"])
if thing_to_plot.tag() not in sum_fft:
sum_fft[thing_to_plot.tag()] = {
"X": numpy.zeros(fft_len // 2 + 1),
"Y": numpy.zeros(fft_len // 2 + 1),
"Z": numpy.zeros(fft_len // 2 + 1),
}
counts[thing_to_plot.tag()] = 0
if thing_to_plot.tag() not in window:
if args.fft_window == 'hanning':
# create hanning window
window[thing_to_plot.tag()] = numpy.hanning(fft_len)
elif args.fft_window == 'blackman':
# create blackman window
window[thing_to_plot.tag()] = numpy.blackman(fft_len)
else:
window[thing_to_plot.tag()] = numpy.arange(fft_len)
window[thing_to_plot.tag()].fill(1)
# calculate NEBW constant
S2[thing_to_plot.tag()] = numpy.inner(window[thing_to_plot.tag()],
window[thing_to_plot.tag()])
for axis in ["X", "Y", "Z"]:
# only plot the selected axis
if axis not in args.axis:
continue
# normalize data and convert to dps in order to produce more meaningful magnitudes
if thing_to_plot.sensor_type == 1:
d = numpy.array(numpy.degrees(
thing_to_plot.data[axis])) / float(
thing_to_plot.multiplier)
else:
d = numpy.array(thing_to_plot.data[axis]) / float(
thing_to_plot.multiplier)
if len(d) == 0:
print("No data?!?!?!")
continue
if len(window[thing_to_plot.tag()]) != fft_len:
print("Skipping corrupted frame of length %d" % fft_len)
continue
# apply window to the input
d *= window[thing_to_plot.tag()]
# perform RFFT
d_fft = numpy.fft.rfft(d)
# convert to squared complex magnitude
d_fft = numpy.square(abs(d_fft))
# remove DC component
d_fft[0] = 0
d_fft[-1] = 0
# accumulate the sums
sum_fft[thing_to_plot.tag()][axis] += d_fft
freq = numpy.fft.rfftfreq(len(d),
1.0 / thing_to_plot.sample_rate_hz)
freqmap[thing_to_plot.tag()] = freq
sample_rates[thing_to_plot.tag()] = thing_to_plot.sample_rate_hz
counts[thing_to_plot.tag()] += 1
numpy.seterr(divide='ignore')
for sensor in sum_fft:
print("Sensor: %s" % str(sensor))
fig = pylab.figure(str(sensor))
for axis in ["X", "Y", "Z"]:
# only plot the selected axis
if axis not in args.axis:
continue
# normalize output to averaged PSD
psd = 2 * (sum_fft[sensor][axis] /
counts[sensor]) / (sample_rates[sensor] * S2[sensor])
# calculate peaks from linear accel data
# the accel data is less noisy than the gyro data
if sensor == 'Accel[0]' and axis == "X" and args.notch_params:
linear_psd = numpy.sqrt(psd)
peaks, _ = signal.find_peaks(psd, prominence=0.1)
peak_freqs = freqmap[sensor][peaks]
print("Peaks: %s" % str(peak_freqs))
print("INS_HNTCH_REF = %.4f" % thr_ref)
print("INS_HNTCH_FREQ = %.1f" % float(peak_freqs[fft_peak]))
print("INS_HNTCH_BW = %.1f" %
(float(peak_freqs[fft_peak]) / 2.))
# linerize of requested
if args.fft_output == 'lsd':
psd = numpy.sqrt(psd)
# convert to db if requested
if args.fft_scale == 'db':
psd = 10 * numpy.log10(psd)
# add file name to axis if doing multi-file plot
if multi_log:
# remove extension and path
(log_name, _, _) = logfile.rpartition('.')
(_, _, log_name) = log_name.rpartition('/')
legend_label = '%s (%s)' % (axis, log_name)
else:
legend_label = axis
pylab.plot(freqmap[sensor], psd, label=legend_label)
pylab.legend(loc='upper right')
pylab.xlabel('Hz')
scale_label = ''
psd_label = 'PSD'
if args.fft_scale == 'db':
scale_label = "dB "
if args.fft_output == 'lsd':
if str(sensor).startswith("Gyro"):
pylab.ylabel('LSD $' + scale_label + 'd/s/\sqrt{Hz}$')
else:
pylab.ylabel('LSD $' + scale_label + 'm/s^2/\sqrt{Hz}$')
else:
if str(sensor).startswith("Gyro"):
pylab.ylabel('PSD $' + scale_label + 'd^2/s^2/Hz$')
else:
pylab.ylabel('PSD $' + scale_label + 'm^2/s^4/Hz$')
if hntch_mode is not None and hntch_option is not None and batch_mode is not None:
option_label = ""
for hopt in hntch_option_names:
if hopt & int(hntch_option) != 0:
if len(option_label) > 0:
option_label += "+"
option_label += hntch_option_names[hopt]
textstr = '\n'.join(
(r'%s tracking' % (hntch_mode_names[hntch_mode], ),
r'%s notch' % (option_label, ),
r'%s sampling' % (batch_mode_names[batch_mode], )))
props = dict(boxstyle='round', facecolor='wheat', alpha=0.5)
pylab.text(0.5,
0.95,
textstr,
fontsize=12,
verticalalignment='top',
bbox=props,
transform=pylab.gca().transAxes)
N_MICS): #inicializando un buffer de 6*WINDOW_SIZE para cada microfono
buffers.append(np.zeros((WINDOW_SIZE * 6), dtype=np.int16))
for window_index in range(251):
# for window_index in range(len(mic_windows[0])):
if window_index % 50 == 0:
print("{0} de {1} ventanas".format(window_index, len(mic_windows[0])))
# Se guarda la nueva ventana desplazando a una vieja
for i in range(N_MICS):
buffers[i] = np.roll(buffers[i], -WINDOW_SIZE)
buffers[i][-WINDOW_SIZE:] = mic_windows[i][window_index]
buffer1_fft = []
for i in range(N_MICS):
b = buffers[i][:BUFFER_SIZE] * np.hanning(BUFFER_SIZE)
buffer1_fft.append(np.fft.fft(b))
buffer2_fft = []
for i in range(N_MICS):
b = buffers[i][-BUFFER_SIZE:] * np.hanning(BUFFER_SIZE)
buffer2_fft.append(np.fft.fft(b))
X1 = np.vstack(buffer1_fft)
X2 = np.vstack(buffer2_fft)
S1 = np.zeros((BUFFER_SIZE), dtype=complex)
S2 = np.zeros((BUFFER_SIZE), dtype=complex)
for m in range(N_MICS): # Para luego calcular la R
saved_windows1[m] = np.delete(saved_windows1[m], 0, 0)
saved_windows1[m] = np.vstack([saved_windows1[m], X1[m]])
def M_frameAnalysis(self,
L_sec=0.08,
STEP_sec=0.02,
window_shape="hamming",
remove_dc=True,
mark_sec_v=np.zeros(0)):
"""
**Description:** Split the data vector or matrix into frames and concatenate the frames into a matrix
**Parameters:** L_sec, STEP_sec, window_shape, remove_dc
**Status:** OK
"""
# --- self.data_v (nbChannel=1, LT_n)
L_n = int(round(L_sec * self.x_sr_hz))
if not (L_n % 2):
L_n += 1 # in order to have an odd-length window
LD_n = int((L_n - 1) / 2)
L_sec = float(L_n) / self.x_sr_hz
LD_sec = float(LD_n) / self.x_sr_hz
if window_shape == "boxcar":
fenetre_v = np.ones((L_n))
elif window_shape == "hanning":
fenetre_v = np.hanning(L_n)
elif window_shape == "hamming":
fenetre_v = np.hamming(L_n)
elif window_shape == "blackman":
fenetre_v = np.blackman(L_n)
else:
print "no other window_shape implemented so far"
LT_n = self.data_v.shape[1]
# --- convert analysis window to a matrix
nbChannel = self.data_v.shape[0]
# --- fenetre_v (nbChannel, L_n)
fenetre_m = np.tile(fenetre_v, (nbChannel, 1))
coefNorm = 0.5 / np.sum(fenetre_v)
if len(mark_sec_v):
mark_n_v = (mark_sec_v - self.x_start) * self.x_sr_hz + 1
STEP_sec = np.mean(np.diff(mark_sec_v))
else:
STEP_n = int(round(STEP_sec * self.x_sr_hz))
STEP_sec = float(STEP_n) / self.x_sr_hz
nbFrame = float(LT_n - L_n) / float(STEP_n)
mark_n_v = (np.arange(0, nbFrame) * STEP_n) + LD_n
mark_sec_v = self.x_start + (mark_n_v - 1) / self.x_sr_hz
nbFrame = len(mark_n_v)
signal_3m = np.zeros((nbChannel, L_n, nbFrame))
for numFrame in range(0, len(mark_n_v)):
# --- signal_m (nbChannel, L_n)
signal_m = self.data_v[:,
int(mark_n_v[numFrame]) -
LD_n:int(mark_n_v[numFrame]) + LD_n + 1]
# --- somme (nbChannel, 1)
if remove_dc:
somme_v = np.mean(signal_m, axis=1, keepdims=True)
else:
somme_v = 0
signal_3m[:, :, numFrame] = coefNorm * np.multiply(
(signal_m - np.tile(somme_v, (1, L_n))), fenetre_m)
# --- def __init__(self, name, data_v, x_label, x_sr_hz, x_start, y_label, y_sr_hz, y_start):
output = C_Descriptor('M_frameAnalysis(' + self.name + ')', signal_3m,
'Frame [sec]', 1. / STEP_sec, mark_sec_v[0],
self.x_label, self.x_sr_hz, 0)
return output
def __init__(self,
feature_type='HDT',
padding=2.2,
feature_bandwidth_sigma=0.2,
spatial_bandwidth_sigma_factor=1 / float(16),
adaptation_rate_range_max=0.0025,
adaptation_rate_scale_range_max=0.005,
lambda_value=1e-4,
kernel='gaussian',
sub_feature_type="",
sub_sub_feature_type=""):
"""
:param feature_type:
:param padding:
:param feature_bandwidth_sigma:
:param spatial_bandwidth_sigma_factor:
:param adaptation_rate_range_max:
:param adaptation_rate_scale_range_max:
:param lambda_value:
:param kernel:
"""
self.feature_type = feature_type
self.padding = padding
self.feature_bandwidth_sigma = feature_bandwidth_sigma
self.spatial_bandwidth_sigma_factor = spatial_bandwidth_sigma_factor
self.adaptation_rate_range_max = adaptation_rate_range_max
self.adaptation_rate_scale_range_max = adaptation_rate_scale_range_max
self.lambda_value = lambda_value
self.kernel = kernel
self.sub_sub_feature_type = sub_sub_feature_type
self.name = 'KCF_' + feature_type
if feature_type == 'HDT':
from keras.applications.vgg19 import VGG19
import theano
self.base_model = VGG19(include_top=False, weights='imagenet')
self.extract_model_function = theano.function(
[self.base_model.input], [
self.base_model.get_layer('block1_conv2').output,
self.base_model.get_layer('block2_conv2').output,
self.base_model.get_layer('block3_conv4').output,
self.base_model.get_layer('block4_conv4').output,
self.base_model.get_layer('block5_conv4').output
],
allow_input_downcast=True)
# we first resize all the response maps to a size of 40*60 (store the resize scale)
# because average target size is 81 *52
self.resize_size = (241, 161)
# store pre-computed cosine window, here is a multiscale CNN, here we have 5 layers cnn:
self.cos_window = []
self.y = []
self.yf = []
self.response_all = []
self.max_list = []
for i in range(5):
cos_wind_sz = np.divide(self.resize_size, 2**i)
self.cos_window.append(
np.outer(np.hanning(cos_wind_sz[0]),
np.hanning(cos_wind_sz[1])))
grid_y = np.arange(cos_wind_sz[0]) - np.floor(
cos_wind_sz[0] / 2)
grid_x = np.arange(cos_wind_sz[1]) - np.floor(
cos_wind_sz[1] / 2)
# desired output (gaussian shaped), bandwidth proportional to target size
output_sigma = np.sqrt(
np.prod(cos_wind_sz)) * self.spatial_bandwidth_sigma_factor
rs, cs = np.meshgrid(grid_x, grid_y)
y = np.exp(-0.5 / output_sigma**2 * (rs**2 + cs**2))
self.y.append(y)
self.yf.append(np.fft.fft2(y, axes=(0, 1)))
# some hyperparameter for HDT
self.loss_acc_time = 5
self.stability = np.zeros(shape=(5, 1))
self.A = 0.011
def stft(x, window_size, stride, fft_size, window_type='hanning', center=True, pad_mode='reflect'):
"""Computes the short-time Fourier transform
Args:
x (~nnabla.Variable): Time domain sequence of size `batch_size x sample_size`.
window_size (int): Size of STFT analysis window.
stride (int): Number of samples that we shift the window, also called `hop size`.
fft_size (int): Size of the FFT, the output will have `fft_size // 2+ 1` frequency bins.
window_type (str): Analysis window, can be either `hanning`, `hamming` or `rectangular`.
For convenience, also `window_type=None` is supported which is equivalent to `window_type='rectangular'`.
center (bool): If `True`, then the signal `x` is padded by half the FFT size using reflection padding.
pad_mode (str): Padding mode, which can be `'constant'` or `'reflect'`. `'constant'` pads with `0`.
Returns:
Returns real and imaginary parts of STFT result.
* :obj:`~nnabla.Variable`: Real part of STFT of size `batch_size x fft_size//2 + 1 x frame_size`.
* :obj:`~nnabla.Variable`: Imaginary part of STFT of size `batch x fft_size//2 + 1 x frame_size`.
"""
from nnabla.parameter import get_parameter, get_parameter_or_create
conv_r = get_parameter('conv_r')
conv_i = get_parameter('conv_i')
if conv_r is None or conv_i is None:
if window_type == 'hanning':
window_func = np.hanning(window_size + 1)[:-1]
elif window_type == 'hamming':
window_func = np.hamming(window_size + 1)[:-1]
elif window_type == 'rectangular' or window_type is None:
window_func = np.ones(window_size)
else:
raise ValueError("Unknown window type {}.".format(window_type))
# pad window if `fft_size > window_size`
if fft_size > window_size:
diff = fft_size - window_size
window_func = np.pad(
window_func, (diff//2, diff - diff//2), mode='constant')
elif fft_size < window_size:
raise ValueError(
"FFT size has to be as least as large as window size.")
# compute STFT filter coefficients
mat_r = np.zeros((fft_size//2 + 1, 1, fft_size))
mat_i = np.zeros((fft_size//2 + 1, 1, fft_size))
for w in range(fft_size//2+1):
for t in range(fft_size):
mat_r[w, 0, t] = np.cos(2. * np.pi * w * t / fft_size)
mat_i[w, 0, t] = -np.sin(2. * np.pi * w * t / fft_size)
mat_r = mat_r * window_func
mat_i = mat_i * window_func
conv_r = get_parameter_or_create(
'conv_r', initializer=mat_r, need_grad=False)
conv_i = get_parameter_or_create(
'conv_i', initializer=mat_i, need_grad=False)
if center:
# pad at begin/end (per default this is a reflection padding)
x = pad(x, (fft_size // 2, fft_size // 2), mode=pad_mode)
# add channel dimension
x = reshape(x, (x.shape[0], 1, x.shape[1]), inplace=False)
# compute STFT
y_r = convolution(x, conv_r, stride=(stride,))
y_i = convolution(x, conv_i, stride=(stride,))
return y_r, y_i
from checkdirectories import *
dir_training = '_'
if simulatedcheck:
dir_training = dir_training + 'evalita_'
if hsc:
dir_training = dir_training + 'hscma_'
if fittizio:
dir_training = dir_training + 'dls_'
dirAudio2 = '/Signals/Mixed_Sources/' + nameplace
if nameplace == 'Kitchen':
pathdir_fittizio = pathdir_fittizio + 'DIRHALibriSpeechsource_083seconds_reverberation/'
mic_log_mel = 13 #numero di microfoni nella cucina
else:
mic_log_mel = 15
pathdir_fittizio = pathdir_fittizio + 'DIRHALibriSpeechsource_074seconds_reverberation/'
window = np.hanning(N)
pathdir = pathdir_evalita + 'AUDIO_FILES/'
micArray, num, fi, lsb, usb = getPhi(nameplace, pathdir, dirArray, dirWall,
formattext)
del lsb, getPhi
fi = np.asarray(fi)
ax = usb[0] * 1000.0
ay = usb[1] * 1000.0
az = usb[2] * 1000.0
context = 15
numContext = int((context - 1) / 2)
CNNkernel = [256]
DenseNeuron = [1024, 1024, 1024, 1024, 1024]
sizekernelCNN = 4
stridesCNN = 3
startSimulationSingleChannel(context, CNNkernel, sizekernelCNN, stridesCNN,
def compute_epochs_csd(epochs,
mode='multitaper',
fmin=0,
fmax=np.inf,
fsum=True,
tmin=None,
tmax=None,
n_fft=None,
mt_bandwidth=None,
mt_adaptive=False,
mt_low_bias=True,
projs=None,
verbose=None):
"""Estimate cross-spectral density from epochs
Note: Baseline correction should be used when creating the Epochs.
Otherwise the computed cross-spectral density will be inaccurate.
Note: Results are scaled by sampling frequency for compatibility with
Matlab.
Parameters
----------
epochs : instance of Epochs
The epochs.
mode : str
Spectrum estimation mode can be either: 'multitaper' or 'fourier'.
fmin : float
Minimum frequency of interest.
fmax : float | np.inf
Maximum frequency of interest.
fsum : bool
Sum CSD values for the frequencies of interest. Summing is performed
instead of averaging so that accumulated power is comparable to power
in the time domain. If True, a single CSD matrix will be returned. If
False, the output will be a list of CSD matrices.
tmin : float | None
Minimum time instant to consider. If None start at first sample.
tmax : float | None
Maximum time instant to consider. If None end at last sample.
n_fft : int | None
Length of the FFT. If None the exact number of samples between tmin and
tmax will be used.
mt_bandwidth : float | None
The bandwidth of the multitaper windowing function in Hz.
Only used in 'multitaper' mode.
mt_adaptive : bool
Use adaptive weights to combine the tapered spectra into PSD.
Only used in 'multitaper' mode.
mt_low_bias : bool
Only use tapers with more than 90% spectral concentration within
bandwidth. Only used in 'multitaper' mode.
projs : list of Projection | None
List of projectors to use in CSD calculation, or None to indicate that
the projectors from the epochs should be inherited.
verbose : bool, str, int, or None
If not None, override default verbose level (see mne.verbose).
Returns
-------
csd : instance of CrossSpectralDensity
The computed cross-spectral density.
"""
# Portions of this code adapted from mne/connectivity/spectral.py
# Check correctness of input data and parameters
if fmax < fmin:
raise ValueError('fmax must be larger than fmin')
tstep = epochs.times[1] - epochs.times[0]
if tmin is not None and tmin < epochs.times[0] - tstep:
raise ValueError('tmin should be larger than the smallest data time '
'point')
if tmax is not None and tmax > epochs.times[-1] + tstep:
raise ValueError('tmax should be smaller than the largest data time '
'point')
if tmax is not None and tmin is not None:
if tmax < tmin:
raise ValueError('tmax must be larger than tmin')
if epochs.baseline is None:
warnings.warn('Epochs are not baseline corrected, cross-spectral '
'density may be inaccurate')
if projs is None:
projs = cp.deepcopy(epochs.info['projs'])
else:
projs = cp.deepcopy(projs)
picks_meeg = pick_types(epochs[0].info,
meg=True,
eeg=True,
eog=False,
ref_meg=False,
exclude='bads')
ch_names = [epochs.ch_names[k] for k in picks_meeg]
# Preparing time window slice
tstart, tend = None, None
if tmin is not None:
tstart = np.where(epochs.times >= tmin)[0][0]
if tmax is not None:
tend = np.where(epochs.times <= tmax)[0][-1] + 1
tslice = slice(tstart, tend, None)
n_times = len(epochs.times[tslice])
n_fft = n_times if n_fft is None else n_fft
# Preparing frequencies of interest
sfreq = epochs.info['sfreq']
frequencies = fftfreq(n_fft, 1. / sfreq)
freq_mask = (frequencies > fmin) & (frequencies < fmax)
frequencies = frequencies[freq_mask]
n_freqs = len(frequencies)
if n_freqs == 0:
raise ValueError('No discrete fourier transform results within '
'the given frequency window. Please widen either '
'the frequency window or the time window')
# Preparing for computing CSD
logger.info('Computing cross-spectral density from epochs...')
if mode == 'multitaper':
# Compute standardized half-bandwidth
if mt_bandwidth is not None:
half_nbw = float(mt_bandwidth) * n_times / (2 * sfreq)
else:
half_nbw = 2
# Compute DPSS windows
n_tapers_max = int(2 * half_nbw)
window_fun, eigvals = dpss_windows(n_times,
half_nbw,
n_tapers_max,
low_bias=mt_low_bias)
n_tapers = len(eigvals)
logger.info(' using multitaper spectrum estimation with %d DPSS '
'windows' % n_tapers)
if mt_adaptive and len(eigvals) < 3:
warnings.warn('Not adaptively combining the spectral estimators '
'due to a low number of tapers.')
mt_adaptive = False
elif mode == 'fourier':
logger.info(' using FFT with a Hanning window to estimate spectra')
window_fun = np.hanning(n_times)
mt_adaptive = False
eigvals = 1.
n_tapers = None
else:
raise ValueError('Mode has an invalid value.')
csds_mean = np.zeros((len(ch_names), len(ch_names), n_freqs),
dtype=complex)
# Compute CSD for each epoch
n_epochs = 0
for epoch in epochs:
epoch = epoch[picks_meeg][:, tslice]
# Calculating Fourier transform using multitaper module
x_mt, _ = _mt_spectra(epoch, window_fun, sfreq, n_fft)
if mt_adaptive:
# Compute adaptive weights
_, weights = _psd_from_mt_adaptive(x_mt,
eigvals,
freq_mask,
return_weights=True)
# Tiling weights so that we can easily use _csd_from_mt()
weights = weights[:, np.newaxis, :, :]
weights = np.tile(weights, [1, x_mt.shape[0], 1, 1])
else:
# Do not use adaptive weights
if mode == 'multitaper':
weights = np.sqrt(eigvals)[np.newaxis, np.newaxis, :,
np.newaxis]
else:
# Hack so we can sum over axis=-2
weights = np.array([1.])[:, None, None, None]
# Picking frequencies of interest
x_mt = x_mt[:, :, freq_mask]
# Calculating CSD
# Tiling x_mt so that we can easily use _csd_from_mt()
x_mt = x_mt[:, np.newaxis, :, :]
x_mt = np.tile(x_mt, [1, x_mt.shape[0], 1, 1])
y_mt = np.transpose(x_mt, axes=[1, 0, 2, 3])
weights_y = np.transpose(weights, axes=[1, 0, 2, 3])
csds_epoch = _csd_from_mt(x_mt, y_mt, weights, weights_y)
# Scaling by number of samples and compensating for loss of power due
# to windowing (see section 11.5.2 in Bendat & Piersol).
if mode == 'fourier':
csds_epoch /= n_times
csds_epoch *= 8 / 3.
# Scaling by sampling frequency for compatibility with Matlab
csds_epoch /= sfreq
csds_mean += csds_epoch
n_epochs += 1
csds_mean /= n_epochs
logger.info('[done]')
# Summing over frequencies of interest or returning a list of separate CSD
# matrices for each frequency
if fsum is True:
csd_mean_fsum = np.sum(csds_mean, 2)
csd = CrossSpectralDensity(csd_mean_fsum,
ch_names,
projs,
epochs.info['bads'],
frequencies=frequencies,
n_fft=n_fft)
return csd
else:
csds = []
for i in range(n_freqs):
csds.append(
CrossSpectralDensity(csds_mean[:, :, i],
ch_names,
projs,
epochs.info['bads'],
frequencies=frequencies[i],
n_fft=n_fft))
return csds
ax[1].set_ylabel('$-\delta I_{tes}$ ($\\mu$A)')
y1 = tes.Rshunt * (pulses.iv.ItesFinal - pulses.iv.IbiasFinal) * cumtrapz(
templatePulse, dx=pulses.dt)
y2 = tes.Rshunt * cumtrapz(templatePulse**2, dx=pulses.dt)
ax[2].plot(t[1:], y1 / eV, '--r')
ax[2].plot(t[1:], y2 / eV, '--b')
ax[2].plot(t[1:], (y1 + y2) / eV, '--k')
ax[2].set_ylabel('Pulse integral (eV)')
ax[-1].set_xlabel('Time')
#mpl.show()
#from scipy.fftpack import rfft, irfft
#from numpy import rfft, irfft
nPoints = len(templatePulse)
window = np.hanning(nPoints)
windowedTemplate = window * templatePulse
windowNorm = np.sum(window)
noise = RunningStats()
for i in pulses.iBaseline:
pulse = pulses[i]
y = pulse.Vsquid - pulse.preTriggerBaseline()
noise.push(abs(np.fft.rfft(window * y))**2)
noisePsd = noise.mean() #/nPoints**2/windowNorm
mpl.figure()
f = (np.arange(0, len(noisePsd)) / (len(noisePsd) * pulses.dt))
mpl.loglog(f, np.sqrt(noisePsd))
mpl.ylabel('Noise PSD (V/rtHz)')
mpl.xlabel('f (Hz)')
def NAT_stim(exptevents,
exptparams,
stimfmt='gtgram',
separate_files_only=False,
channels=18,
rasterfs=100,
f_min=200,
f_max=20000,
mono=False,
binaural=False,
**options):
"""
:param exptevents: from baphy
:param exptparams: from baphy
:param stimfmt: string, currently must be 'wav' or 'gtgram'
:param separate_files_only: boolean [=False]
if True, just return each individual sound file rather than combinations
(eg, as specified for binaural stim)
:param channels: int
number of gtgram channels
:param rasterfs: int
gtgram sampling rate
:param f_min: float
gtgram min frequency
:param f_max: float
gtgram max frequency
:param mono: boolean [False]
if True, collapse wavs to single channel (dumb control for binaural)
:param binaural:
if True, apply model to simulate sound at each ear. Currently, a very dumb HRTF
:param options: dict
extra stuff to pass through
:return:
stim, tags, stimparam
"""
ReferenceClass = exptparams['TrialObject'][1]['ReferenceClass']
ReferenceHandle = exptparams['TrialObject'][1]['ReferenceHandle'][1]
OveralldB = exptparams['TrialObject'][1]['OveralldB']
if exptparams['TrialObject'][1]['ReferenceClass'] == 'BigNat':
sound_root = Path(exptparams['TrialObject'][1]['ReferenceHandle'][1]
['SoundPath'].replace("H:/", "/auto/data/"))
#stim_epochs = exptevents.loc[exptevents.name.str.startswith("Stim"),'name'].tolist()
#print(exptevents.loc[exptevents.name.str.startswith("Stim"),'name'].tolist()[:10])
#wav1=[e.split(' , ')[1].split("+")[0].split(":")[0].replace("STIM_","") for e in stim_epochs]
#wav2=[e.split(' , ')[1].split("+")[0].split(":")[0].replace("STIM_","") for e in stim_epochs]
stim_epochs = exptparams['TrialObject'][1]['ReferenceHandle'][1][
'Names']
#print(exptparams['TrialObject'][1]['ReferenceHandle'][1]['Names'][:10])
wav1 = [e.split("+")[0].split(":")[0] for e in stim_epochs]
wav2 = [e.split("+")[1].split(":")[0] for e in stim_epochs]
chan1 = [int(e.split("+")[0].split(":")[1]) - 1 for e in stim_epochs]
chan2 = [int(e.split("+")[1].split(":")[1]) - 1 for e in stim_epochs]
#log.info(wav1[0],chan1[0],wav2[0],chan2[0])
file_unique = wav1.copy()
file_unique.extend(wav2)
file_unique = list(set(file_unique))
if 'NULL' in file_unique:
file_unique.remove('NULL')
elif ReferenceClass == 'NaturalSounds':
subset = ReferenceHandle['Subsets']
if subset == 1:
sound_root = Path(
f'/auto/users/svd/code/baphy/Config/lbhb/SoundObjects/@NaturalSounds/sounds'
)
else:
sound_root = Path(
f'/auto/users/svd/code/baphy/Config/lbhb/SoundObjects/@NaturalSounds/sounds_set{subset}'
)
stim_epochs = ReferenceHandle['Names']
file_unique = [f.replace('.wav', '') for f in stim_epochs]
wav1 = file_unique.copy()
chan1 = [0] * len(wav1)
wav2 = ["NULL"] * len(wav1)
chan2 = [0] * len(wav1)
elif ReferenceClass == 'OverlappingPairs':
bg_folder = ReferenceHandle['BG_Folder']
fg_folder = ReferenceHandle['FG_Folder']
bg_root = Path(
f'/auto/users/hamersky/baphy/Config/lbhb/SoundObjects/@OverlappingPairs/{bg_folder}'
)
fg_root = Path(
f'/auto/users/hamersky/baphy/Config/lbhb/SoundObjects/@OverlappingPairs/{fg_folder}'
)
stim_epochs = ReferenceHandle['Names']
#print(exptparams['TrialObject'][1]['ReferenceHandle'][1]['Names'][:10])
wav1 = [e.split("_")[0].split("-")[0] for e in stim_epochs]
wav2 = [e.split("_")[1].split("-")[0] for e in stim_epochs]
chan1 = [
int(e.split("_")[0].split("-")[3]) -
1 if e.split("_")[0] != 'null' else 0 for e in stim_epochs
]
chan2 = [
int(e.split("_")[1].split("-")[3]) -
1 if e.split("_")[1] != 'null' else 0 for e in stim_epochs
]
#log.info(wav1[0],chan1[0],wav2[0],chan2[0])
#wav1 = [wav for wav in wav1 if wav != 'null']
#wav2 = [wav for wav in wav2 if wav != 'null']
file_unique = wav1.copy()
file_unique.extend(wav2)
file_unique = list(set(file_unique))
file_unique = [f for f in file_unique if f != 'null']
log.info(
'NOTE: Stripping spaces from epoch names in OverlappingPairs files'
)
stim_epochs = [s.replace(" ", "") for s in stim_epochs]
else:
raise ValueError(
f"ReferenceClass {ReferenceClass} gtgram not supported.")
max_chans = np.max(np.concatenate([np.array(chan1), np.array(chan2)])) + 1
max_chans_was = max_chans
if mono:
log.info("Forcing mono stimulus, averaging across space")
chan1 = [0] * len(wav1)
chan2 = [0] * len(wav2)
max_chans = 1
PreStimSilence = ReferenceHandle['PreStimSilence']
Duration = ReferenceHandle['Duration']
PostStimSilence = ReferenceHandle['PostStimSilence']
log.info(f"Pre/Dur/Pos: {PreStimSilence}/{Duration}/{PostStimSilence}")
wav_unique = {}
fs0 = None
for filename in file_unique:
if ReferenceClass == "OverlappingPairs":
try:
fs, w = wavfile.read(Path(bg_root) / (filename + '.wav'))
except:
fs, w = wavfile.read(Path(fg_root) / (filename + '.wav'))
else:
fs, w = wavfile.read(sound_root / (filename + '.wav'))
if fs0 is None:
fs0 = fs
elif fs != fs0:
raise ValueError(
"fs mismatch between wav files. Need to implement resampling!")
#print(f"{filename} fs={fs} len={w.shape}")
duration_samples = int(np.floor(Duration * fs))
# 10ms ramp at onset:
w = w[:duration_samples].astype(float)
ramp = np.hanning(.01 * fs * 2)
ramp = ramp[:int(np.floor(len(ramp) / 2))]
w[:len(ramp)] *= ramp
w[-len(ramp):] = w[-len(ramp):] * np.flipud(ramp)
# scale peak-to-peak amplitude to OveralldB
w = w / np.max(np.abs(w)) * 5
sf = 10**((80 - OveralldB) / 20)
w /= sf
wav_unique[filename] = w[:, np.newaxis]
if separate_files_only:
# combine into pairs that were actually presented
wav_all = wav_unique
else:
wav_all = {}
fs_all = {}
for (f1, c1, f2, c2, n) in zip(wav1, chan1, wav2, chan2, stim_epochs):
#print(f1,f2)
if f1.upper() != "NULL":
w1 = wav_unique[f1]
if f2.upper() != "NULL":
w2 = wav_unique[f2]
else:
w2 = np.zeros(w1.shape)
else:
w2 = wav_unique[f2]
w1 = np.zeros(w2.shape)
w = np.zeros((w1.shape[0], max_chans))
if (binaural is None) | (binaural == False):
#log.info(f'binaural model: None')
w[:, [c1]] = w1
w[:, [c2]] += w2
else:
#log.info(f'binaural model: {binaural}')
#import pdb; pdb.set_trace()
db_atten = 10
factor = 10**(-db_atten / 20)
w[:, [c1]] = w1 * 1 / (1 + factor) + w2 * factor / (1 + factor)
w[:,
[c2]] += w2 * 1 / (1 + factor) + w1 * factor / (1 + factor)
wav_all[n] = w
if stimfmt == 'wav':
for f, w in wav_all.items():
wav_all[f] = np.concatenate([
np.zeros((int(np.floor(fs * PreStimSilence)), max_chans)), w,
np.zeros((int(np.floor(fs * PostStimSilence)), max_chans))
],
axis=0)
return wav_all
if stimfmt == 'gtgram':
window_time = 1 / rasterfs
hop_time = 1 / rasterfs
duration_bins = int(np.floor(rasterfs * Duration))
sg_pre = np.zeros((channels, int(np.floor(rasterfs * PreStimSilence))))
sg_null = np.zeros((channels, duration_bins))
sg_post = np.zeros(
(channels, int(np.floor(rasterfs * PostStimSilence))))
sg_unique = {}
stimparam = {'f_min': f_min, 'f_max': f_max, 'rasterfs': rasterfs}
padbins = int(np.ceil((window_time - hop_time) / 2 * fs))
for (f, w) in wav_all.items():
if len(sg_unique) % 100 == 99:
log.info(f"i={len(sg_unique)+1} {f} {w.std(axis=0)}")
sg = [
gtgram(np.pad(w[:, i], [padbins, padbins]), fs, window_time,
hop_time, channels, f_min, f_max)
if w[:, i].var() > 0 else sg_null for i in range(w.shape[1])
]
sg = [
np.concatenate(
[sg_pre,
np.abs(s[:, :duration_bins])**0.5, sg_post],
axis=1) for s in sg
]
if mono & (max_chans_was > 1):
sgshuff = np.random.permutation(sg[0].flatten())
sgshuff = np.reshape(sgshuff, sg[0].shape)
sg.append(sgshuff)
sg_unique[f] = np.concatenate(sg, axis=0)
return sg_unique, list(sg_unique.keys()), stimparam
# Iterate through the audio file's samples constructing blocks.
for i in range(0, len(ra), cs - overlap_c):
raw_chunk = ra[i:i + cs]
# Check if we need to pad raw_chunk on the right, i.e. are we
# at the end of the file.
if len(raw_chunk) < cs:
diff = cs - len(raw_chunk)
raw_chunk = np.concatenate([raw_chunk, np.zeros(diff)], axis=0)
padded_chunk = get_chunk_with_margin(ra, i, cs, peek)
X.append(padded_chunk)
clip_X.append(X)
hann_window = np.hanning(600)
if __name__ == '__main__':
X_n = tf.placeholder(tf.float32, shape=[None, 1000])
X = tf.placeholder(tf.float32, shape=[None, 600])
Z_mu = encoder(X_n, z_dim)
Z = Z_mu
X_hat = decoder(Z)
saver = tf.train.Saver()
sess = tf.Session()
sess.run(tf.global_variables_initializer())
saver.restore(sess, model_name)
def generate_cosine_mask(patch_shape):
r"""
"""
cy = np.hanning(patch_shape[0])
cx = np.hanning(patch_shape[1])
return cy[..., None].dot(cx[None, ...])
for i in indices:
#print i
y = X_train[i]
frq, E = getSpectrum(y, Fs)
smoothed = np.convolve(kernel, E, mode='SAME')
logeeg = np.log10(smoothed)
logeeg0 = np.interp(frq0, frq, logeeg)
if doNorm:
V[icnt, :] = (logeeg0 - logeeg0.mean()) / logeeg0.std()
else:
V[icnt, :] = logeeg0
icnt += 1
return V
kernel = np.hanning(80)
kernel = kernel / kernel.sum()
frqmax = 100
frq0 = np.arange(0, frqmax, 1)
doNorm = 1
L = len(X_train)
L_t = len(X_test)
indx = np.arange(0, L)
indx_t = np.arange(0, L_t)
V_train = computeVec(X_train, indx, frq0, doNorm, kernel)
V_test = computeVec(X_test, indx_t, frq0, doNorm, kernel)
def spectral_connectivity(data,
method='coh',
indices=None,
sfreq=2 * np.pi,
mode='multitaper',
fmin=None,
fmax=np.inf,
fskip=0,
faverage=False,
tmin=None,
tmax=None,
mt_bandwidth=None,
mt_adaptive=False,
mt_low_bias=True,
cwt_frequencies=None,
cwt_n_cycles=7,
block_size=1000,
n_jobs=1,
verbose=None):
"""Compute various frequency-domain and time-frequency domain connectivity
measures.
The connectivity method(s) are specified using the "method" parameter.
All methods are based on estimates of the cross- and power spectral
densities (CSD/PSD) Sxy and Sxx, Syy.
The spectral densities can be estimated using a multitaper method with
digital prolate spheroidal sequence (DPSS) windows, a discrete Fourier
transform with Hanning windows, or a continuous wavelet transform using
Morlet wavelets. The spectral estimation mode is specified using the
"mode" parameter.
By default, the connectivity between all signals is computed (only
connections corresponding to the lower-triangular part of the
connectivity matrix). If one is only interested in the connectivity
between some signals, the "indices" parameter can be used. For example,
to compute the connectivity between the signal with index 0 and signals
"2, 3, 4" (a total of 3 connections) one can use the following:
indices = (np.array([0, 0, 0], # row indices
np.array([2, 3, 4]))) # col indices
con_flat = spectral_connectivity(data, method='coh', indices=indices, ...)
In this case con_flat.shape = (3, n_freqs). The connectivity scores are
in the same order as defined indices.
Supported Connectivity Measures:
The connectivity method(s) is specified using the "method" parameter. The
following methods are supported (note: E[] denotes average over epochs).
Multiple measures can be computed at once by using a list/tuple, e.g.
"['coh', 'pli']" to compute coherence and PLI.
'coh' : Coherence given by
| E[Sxy] |
C = ---------------------
sqrt(E[Sxx] * E[Syy])
'cohy' : Coherency given by
E[Sxy]
C = ---------------------
sqrt(E[Sxx] * E[Syy])
'imcoh' : Imaginary coherence [1] given by
Im(E[Sxy])
C = ----------------------
sqrt(E[Sxx] * E[Syy])
'plv' : Phase-Locking Value (PLV) [2] given by
PLV = |E[Sxy/|Sxy|]|
'ppc' : Pairwise Phase Consistency (PPC), an unbiased estimator of squared
PLV [3].
'pli' : Phase Lag Index (PLI) [4] given by
PLI = |E[sign(Im(Sxy))]|
'pli2_unbiased' : Unbiased estimator of squared PLI [5].
'wpli' : Weighted Phase Lag Index (WPLI) [5] given by
|E[Im(Sxy)]|
WPLI = ------------------
E[|Im(Sxy)|]
'wpli2_debiased' : Debiased estimator of squared WPLI [5].
References
----------
[1] Nolte et al. "Identifying true brain interaction from EEG data using
the imaginary part of coherency" Clinical neurophysiology, vol. 115,
no. 10, pp. 2292-2307, Oct. 2004.
[2] Lachaux et al. "Measuring phase synchrony in brain signals" Human brain
mapping, vol. 8, no. 4, pp. 194-208, Jan. 1999.
[3] Vinck et al. "The pairwise phase consistency: a bias-free measure of
rhythmic neuronal synchronization" NeuroImage, vol. 51, no. 1,
pp. 112-122, May 2010.
[4] Stam et al. "Phase lag index: assessment of functional connectivity
from multi channel EEG and MEG with diminished bias from common
sources" Human brain mapping, vol. 28, no. 11, pp. 1178-1193,
Nov. 2007.
[5] Vinck et al. "An improved index of phase-synchronization for electro-
physiological data in the presence of volume-conduction, noise and
sample-size bias" NeuroImage, vol. 55, no. 4, pp. 1548-1565, Apr. 2011.
Parameters
----------
data : array, shape=(n_epochs, n_signals, n_times)
or list/generator of array, shape =(n_signals, n_times)
or list/generator of SourceEstimate
or Epochs
The data from which to compute connectivity. Note that it is also
possible to combine multiple signals by providing a list of tuples,
e.g., data = [(arr_0, stc_0), (arr_1, stc_1), (arr_2, stc_2)],
corresponds to 3 epochs, and arr_* could be an array with the same
number of time points as stc_*.
method : string | list of string
Connectivity measure(s) to compute.
indices : tuple of arrays | None
Two arrays with indices of connections for which to compute
connectivity. If None, all connections are computed.
sfreq : float
The sampling frequency.
mode : str
Spectrum estimation mode can be either: 'multitaper', 'fourier', or
'cwt_morlet'.
fmin : float | tuple of floats
The lower frequency of interest. Multiple bands are defined using
a tuple, e.g., (8., 20.) for two bands with 8Hz and 20Hz lower freq.
If None the frequency corresponding to an epoch length of 5 cycles
is used.
fmax : float | tuple of floats
The upper frequency of interest. Multiple bands are dedined using
a tuple, e.g. (13., 30.) for two band with 13Hz and 30Hz upper freq.
fskip : int
Omit every "(fskip + 1)-th" frequency bin to decimate in frequency
domain.
faverage : boolean
Average connectivity scores for each frequency band. If True,
the output freqs will be a list with arrays of the frequencies
that were averaged.
tmin : float | None
Time to start connectivity estimation.
tmax : float | None
Time to end connectivity estimation.
mt_bandwidth : float | None
The bandwidth of the multitaper windowing function in Hz.
Only used in 'multitaper' mode.
mt_adaptive : bool
Use adaptive weights to combine the tapered spectra into PSD.
Only used in 'multitaper' mode.
mt_low_bias : bool
Only use tapers with more than 90% spectral concentration within
bandwidth. Only used in 'multitaper' mode.
cwt_frequencies : array
Array of frequencies of interest. Only used in 'cwt_morlet' mode.
cwt_n_cycles: float | array of float
Number of cycles. Fixed number or one per frequency. Only used in
'cwt_morlet' mode.
block_size : int
How many connections to compute at once (higher numbers are faster
but require more memory).
n_jobs : int
How many epochs to process in parallel.
verbose : bool, str, int, or None
If not None, override default verbose level (see mne.verbose).
Returns
-------
con : array | list of arrays
Computed connectivity measure(s). The shape of each array is either
(n_signals, n_signals, n_frequencies) mode: 'multitaper' or 'fourier'
(n_signals, n_signals, n_frequencies, n_times) mode: 'cwt_morlet'
when "indices" is None, or
(n_con, n_frequencies) mode: 'multitaper' or 'fourier'
(n_con, n_frequencies, n_times) mode: 'cwt_morlet'
when "indices" is specified and "n_con = len(indices[0])".
freqs : array
Frequency points at which the connectivity was computed.
times : array
Time points for which the connectivity was computed.
n_epochs : int
Number of epochs used for computation.
n_tapers : int
The number of DPSS tapers used. Only defined in 'multitaper' mode.
Otherwise None is returned.
"""
if n_jobs > 1:
parallel, my_epoch_spectral_connectivity, _ = \
parallel_func(_epoch_spectral_connectivity, n_jobs,
verbose=verbose)
# format fmin and fmax and check inputs
if fmin is None:
fmin = -np.inf # set it to -inf, so we can adjust it later
fmin = np.asarray((fmin, )).ravel()
fmax = np.asarray((fmax, )).ravel()
if len(fmin) != len(fmax):
raise ValueError('fmin and fmax must have the same length')
if np.any(fmin > fmax):
raise ValueError('fmax must be larger than fmin')
n_bands = len(fmin)
# assign names to connectivity methods
if not isinstance(method, (list, tuple)):
method = [method] # make it a list so we can iterate over it
n_methods = len(method)
con_method_types = []
for m in method:
if m in _CON_METHOD_MAP:
method = _CON_METHOD_MAP[m]
con_method_types.append(method)
elif isinstance(m, basestring):
raise ValueError('%s is not a valid connectivity method' % m)
else:
# add custom method
method_valid, msg = _check_method(m)
if not method_valid:
raise ValueError('The supplied connectivity method does '
'not have the method %s' % msg)
con_method_types.append(m)
# determine how many arguments the compute_con_function needs
n_comp_args = [
len(getargspec(mtype.compute_con).args) for mtype in con_method_types
]
# we only support 3 or 5 arguments
if any([n not in (3, 5) for n in n_comp_args]):
raise ValueError('The compute_con function needs to have either '
'3 or 5 arguments')
# if none of the comp_con functions needs the PSD, we don't estimate it
accumulate_psd = any([n == 5 for n in n_comp_args])
if isinstance(data, Epochs):
times_in = data.times # input times for Epochs input type
sfreq = data.info['sfreq']
# loop over data; it could be a generator that returns
# (n_signals x n_times) arrays or SourceEstimates
epoch_idx = 0
logger.info('Connectivity computation...')
for epoch_block in _get_n_epochs(data, n_jobs):
if epoch_idx == 0:
# initialize everything
first_epoch = epoch_block[0]
# get the data size and time scale
n_signals, n_times_in, times_in =\
_get_and_verify_data_sizes(first_epoch)
if times_in is None:
# we are not using Epochs or SourceEstimate(s) as input
times_in = np.linspace(0.0,
n_times_in / sfreq,
n_times_in,
endpoint=False)
n_times_in = len(times_in)
tmin_idx = 0
tmax_idx = n_times_in
tmin_true = times_in[0]
tmax_true = times_in[-1]
if tmin is not None:
tmin_idx = np.argmin(np.abs(times_in - tmin))
tmin_true = times_in[tmin_idx]
if tmax is not None:
tmax_idx = np.argmin(np.abs(times_in - tmax)) + 1
tmax_true = times_in[tmax_idx - 1] # time of last point used
times = times_in[tmin_idx:tmax_idx]
n_times = len(times)
if indices is None:
# only compute r for lower-triangular region
indices_use = tril_indices(n_signals, -1)
else:
indices_use = check_indices(indices)
# number of connectivities to compute
n_cons = len(indices_use[0])
logger.info(' computing connectivity for %d connections' %
n_cons)
logger.info(
' using t=%0.3fs..%0.3fs for estimation (%d points)' %
(tmin_true, tmax_true, n_times))
# get frequencies of interest for the different modes
if mode in ['multitaper', 'fourier']:
# fmin fmax etc is only supported for these modes
# decide which frequencies to keep
freqs_all = fftfreq(n_times, 1. / sfreq)
freqs_all = freqs_all[freqs_all >= 0]
elif mode == 'cwt_morlet':
# cwt_morlet mode
if cwt_frequencies is None:
raise ValueError('define frequencies of interest using '
'cwt_frequencies')
else:
cwt_frequencies = cwt_frequencies.astype(np.float)
if any(cwt_frequencies > (sfreq / 2.)):
raise ValueError('entries in cwt_frequencies cannot be '
'larger than Nyquist (sfreq / 2)')
freqs_all = cwt_frequencies
else:
raise ValueError('mode has an invalid value')
# check that fmin corresponds to at least 5 cycles
five_cycle_freq = 5. * sfreq / float(n_times)
if len(fmin) == 1 and fmin[0] == -np.inf:
# we use the 5 cycle freq. as default
fmin = [five_cycle_freq]
else:
if any(fmin < five_cycle_freq):
warn('fmin corresponds to less than 5 cycles, '
'spectrum estimate will be unreliable')
# create a frequency mask for all bands
freq_mask = np.zeros(len(freqs_all), dtype=np.bool)
for f_lower, f_upper in zip(fmin, fmax):
freq_mask |= ((freqs_all >= f_lower) & (freqs_all <= f_upper))
# possibly skip frequency points
for pos in xrange(fskip):
freq_mask[pos + 1::fskip + 1] = False
# the frequency points where we compute connectivity
freqs = freqs_all[freq_mask]
n_freqs = len(freqs)
# get the freq. indices and points for each band
freq_idx_bands = [
np.where((freqs >= fl) & (freqs <= fu))[0]
for fl, fu in zip(fmin, fmax)
]
freqs_bands = [freqs[freq_idx] for freq_idx in freq_idx_bands]
# make sure we don't have empty bands
for i, n_f_band in enumerate([len(f) for f in freqs_bands]):
if n_f_band == 0:
raise ValueError(
'There are no frequency points between '
'%0.1fHz and %0.1fHz. Change the band specification '
'(fmin, fmax) or the frequency resolution.' %
(fmin[i], fmax[i]))
if n_bands == 1:
logger.info(' frequencies: %0.1fHz..%0.1fHz (%d points)' %
(freqs_bands[0][0], freqs_bands[0][-1], n_freqs))
else:
logger.info(' computing connectivity for the bands:')
for i, bfreqs in enumerate(freqs_bands):
logger.info(' band %d: %0.1fHz..%0.1fHz '
'(%d points)' %
(i + 1, bfreqs[0], bfreqs[-1], len(bfreqs)))
if faverage:
logger.info(' connectivity scores will be averaged for '
'each band')
# get the window function, wavelets, etc for different modes
if mode == 'multitaper':
# compute standardized half-bandwidth
if mt_bandwidth is not None:
half_nbw = float(mt_bandwidth) * n_times / (2 * sfreq)
else:
half_nbw = 4
# compute dpss windows
n_tapers_max = int(2 * half_nbw)
window_fun, eigvals = dpss_windows(n_times,
half_nbw,
n_tapers_max,
low_bias=mt_low_bias)
n_tapers = len(eigvals)
logger.info(' using multitaper spectrum estimation with '
'%d DPSS windows' % n_tapers)
if mt_adaptive and len(eigvals) < 3:
warn('Not adaptively combining the spectral estimators '
'due to a low number of tapers.')
mt_adaptive = False
n_times_spectrum = 0 # this method only uses the freq. domain
wavelets = None
elif mode == 'fourier':
logger.info(' using FFT with a Hanning window to estimate '
'spectra')
window_fun = np.hanning(n_times)
mt_adaptive = False
eigvals = 1.
n_tapers = None
n_times_spectrum = 0 # this method only uses the freq. domain
wavelets = None
elif mode == 'cwt_morlet':
logger.info(' using CWT with Morlet wavelets to estimate '
'spectra')
# reformat cwt_n_cycles if we have removed some frequencies
# using fmin, fmax, fskip
cwt_n_cycles = np.asarray((cwt_n_cycles, )).ravel()
if len(cwt_n_cycles) > 1:
if len(cwt_n_cycles) != len(cwt_frequencies):
raise ValueError(
'cwt_n_cycles must be float or an '
'array with the same size as cwt_frequencies')
cwt_n_cycles = cwt_n_cycles[freq_mask]
# get the Morlet wavelets
wavelets = morlet(sfreq,
freqs,
n_cycles=cwt_n_cycles,
zero_mean=True)
eigvals = None
n_tapers = None
window_fun = None
n_times_spectrum = n_times
else:
raise ValueError('mode has an invalid value')
# unique signals for which we actually need to compute PSD etc.
sig_idx = np.unique(np.r_[indices_use[0], indices_use[1]])
# map indices to unique indices
idx_map = [np.searchsorted(sig_idx, ind) for ind in indices_use]
# allocate space to accumulate PSD
if accumulate_psd:
if n_times_spectrum == 0:
psd_shape = (len(sig_idx), n_freqs)
else:
psd_shape = (len(sig_idx), n_freqs, n_times_spectrum)
psd = np.zeros(psd_shape)
else:
psd = None
# create instances of the connectivity estimators
con_methods = [
mtype(n_cons, n_freqs, n_times_spectrum)
for mtype in con_method_types
]
sep = ', '
metrics_str = sep.join([method.name for method in con_methods])
logger.info(' the following metrics will be computed: %s' %
metrics_str)
# check dimensions and time scale
for this_epoch in epoch_block:
_get_and_verify_data_sizes(this_epoch, n_signals, n_times_in,
times_in)
if n_jobs == 1:
# no parallel processing
for this_epoch in epoch_block:
logger.info(' computing connectivity for epoch %d' %
(epoch_idx + 1))
# con methods and psd are updated inplace
_epoch_spectral_connectivity(this_epoch,
sig_idx,
tmin_idx,
tmax_idx,
sfreq,
mode,
window_fun,
eigvals,
wavelets,
freq_mask,
mt_adaptive,
idx_map,
block_size,
psd,
accumulate_psd,
con_method_types,
con_methods,
n_signals,
n_times,
accumulate_inplace=True)
epoch_idx += 1
else:
# process epochs in parallel
logger.info(' computing connectivity for epochs %d..%d' %
(epoch_idx + 1, epoch_idx + len(epoch_block)))
out = parallel(
my_epoch_spectral_connectivity(this_epoch,
sig_idx,
tmin_idx,
tmax_idx,
sfreq,
mode,
window_fun,
eigvals,
wavelets,
freq_mask,
mt_adaptive,
idx_map,
block_size,
psd,
accumulate_psd,
con_method_types,
None,
n_signals,
n_times,
accumulate_inplace=False)
for this_epoch in epoch_block)
# do the accumulation
for this_out in out:
for method, parallel_method in zip(con_methods, this_out[0]):
method.combine(parallel_method)
if accumulate_psd:
psd += this_out[1]
epoch_idx += len(epoch_block)
# normalize
n_epochs = epoch_idx
if accumulate_psd:
psd /= n_epochs
# compute final connectivity scores
con = []
for method, n_args in zip(con_methods, n_comp_args):
if n_args == 3:
# compute all scores at once
method.compute_con(slice(0, n_cons), n_epochs)
else:
# compute scores block-wise to save memory
for i in xrange(0, n_cons, block_size):
con_idx = slice(i, i + block_size)
psd_xx = psd[idx_map[0][con_idx]]
psd_yy = psd[idx_map[1][con_idx]]
method.compute_con(con_idx, n_epochs, psd_xx, psd_yy)
# get the connectivity scores
this_con = method.con_scores
if this_con.shape[0] != n_cons:
raise ValueError('First dimension of connectivity scores must be '
'the same as the number of connections')
if faverage:
if this_con.shape[1] != n_freqs:
raise ValueError('2nd dimension of connectivity scores must '
'be the same as the number of frequencies')
con_shape = (n_cons, n_bands) + this_con.shape[2:]
this_con_bands = np.empty(con_shape, dtype=this_con.dtype)
for band_idx in xrange(n_bands):
this_con_bands[:, band_idx] =\
np.mean(this_con[:, freq_idx_bands[band_idx]], axis=1)
this_con = this_con_bands
con.append(this_con)
if indices is None:
# return all-to-all connectivity matrices
logger.info(' assembling connectivity matrix')
con_flat = con
con = []
for this_con_flat in con_flat:
this_con = np.zeros(
(n_signals, n_signals) + this_con_flat.shape[1:],
dtype=this_con_flat.dtype)
this_con[indices_use] = this_con_flat
con.append(this_con)
logger.info('[Connectivity computation done]')
if n_methods == 1:
# for a single method return connectivity directly
con = con[0]
if faverage:
# for each band we return the frequencies that were averaged
freqs = freqs_bands
return con, freqs, times, n_epochs, n_tapers
def _frame(self, samples, sample_rate, window_ms):
stride_ms = window_ms / 2
stride_size = int(0.001 * sample_rate * stride_ms)
window_size = int(0.001 * sample_rate * window_ms)
# Extract strided windows
truncate_size = (len(samples) - window_size) % stride_size
samples = samples[:len(samples) - truncate_size]
nshape = (window_size, (len(samples) - window_size) // stride_size + 1)
nstrides = (samples.strides[0], samples.strides[0] * stride_size)
windows = np.lib.stride_tricks.as_strided(samples,
shape=nshape,
strides=nstrides)
assert np.all(windows[:, 1] == samples[stride_size:(stride_size +
window_size)])
# Window weighting, squared Fast Fourier Transform (fft), scaling
weighting = np.hanning(window_size)[:, None]
fft = np.fft.fft(windows * weighting, axis=0)
fft = np.absolute(fft)
fft = fft**2
scale = np.sum(weighting**2) * sample_rate
fft[1:-1, :] *= 2.0 / scale
fft[(0, -1), :] /= scale
fft = np.log(fft)
# Prepare fft frequency list
freqs = float(sample_rate) / window_size * np.arange(fft.shape[0])
frames = []
for i in range(40):
bands = []
band0 = []
band1 = []
band2 = []
band3 = []
band4 = []
j = 0
for freq in freqs:
if freq <= 333.3:
band0.append(fft[j][i])
elif freq > 333.3 and freq <= 666.7:
band1.append(fft[j][i])
elif freq > 666.7 and freq <= 1333.3:
band2.append(fft[j][i])
elif freq > 1333.3 and freq <= 2333.3:
band3.append(fft[j][i])
elif freq > 2333.3 and freq <= 4000:
band4.append(fft[j][i])
j += 1
bands.append(np.sum(band0) / np.shape(band0)[0])
bands.append(np.sum(band1) / np.shape(band1)[0])
bands.append(np.sum(band2) / np.shape(band2)[0])
bands.append(np.sum(band3) / np.shape(band3)[0])
bands.append(np.sum(band4) / np.shape(band4)[0])
frames.append(bands)
return frames
# Signal reconstruction
def signal_reconstruction(X_estimated):
X_estimated = X_estimated.T
temp = np.zeros(len(x_t))
for i in range(X_estimated.shape[0]):
temp[(i * 512):(i * 512) +
512] = temp[(i * 512):(i * 512) +
512] + X_estimated[i, 0:512].flatten()
temp[((i * 512) + 512):((i * 512) +
1024)] = X_estimated[i, 512:1024].flatten()
return temp
N = 1024
f, n = np.arange(N), np.arange(N)
han = np.hanning(1024).reshape(1024, 1)
print(I_DFT(f))
# For speaker signal trs.wav
x_s, _ = librosa.load('data/trs.wav', sr=None)
x_s = x_s.reshape(len(x_s), 1)
# STFT of signal trs.wav
S = np.abs(stft(x_s))
# Initializing matrix W and H
W_S, H_S = init_W_H(S.shape[0], 30, S.shape[1])
# Non-negative Matrix Factorization
W_S, H_S = NMF(S, W_S, H_S)
def __init__(self, model, cfg):
super(SiamCARTracker, self).__init__()
hanning = np.hanning(cfg.SCORE_SIZE)
self.window = np.outer(hanning, hanning) # 生成 汉宁窗
self.model = model # 跟踪网络
self.model.eval() # 测试模式
def simulate_raw(raw,
stc,
trans,
src,
bem,
cov='simple',
blink=False,
ecg=False,
chpi=False,
head_pos=None,
mindist=1.0,
interp='cos2',
iir_filter=None,
n_jobs=1,
random_state=None,
verbose=None):
"""Simulate raw data
Head movements can optionally be simulated using the ``head_pos``
parameter.
Parameters
----------
raw : instance of Raw
The raw template to use for simulation. The ``info``, ``times``,
and potentially ``first_samp`` properties will be used.
stc : instance of SourceEstimate
The source estimate to use to simulate data. Must have the same
sample rate as the raw data.
trans : dict | str | None
Either a transformation filename (usually made using mne_analyze)
or an info dict (usually opened using read_trans()).
If string, an ending of `.fif` or `.fif.gz` will be assumed to
be in FIF format, any other ending will be assumed to be a text
file with a 4x4 transformation matrix (like the `--trans` MNE-C
option). If trans is None, an identity transform will be used.
src : str | instance of SourceSpaces
Source space corresponding to the stc. If string, should be a source
space filename. Can also be an instance of loaded or generated
SourceSpaces.
bem : str | dict
BEM solution corresponding to the stc. If string, should be a BEM
solution filename (e.g., "sample-5120-5120-5120-bem-sol.fif").
cov : instance of Covariance | str | None
The sensor covariance matrix used to generate noise. If None,
no noise will be added. If 'simple', a basic (diagonal) ad-hoc
noise covariance will be used. If a string, then the covariance
will be loaded.
blink : bool
If true, add simulated blink artifacts. See Notes for details.
ecg : bool
If true, add simulated ECG artifacts. See Notes for details.
chpi : bool
If true, simulate continuous head position indicator information.
Valid cHPI information must encoded in ``raw.info['hpi_meas']``
to use this option.
head_pos : None | str | dict | tuple | array
Name of the position estimates file. Should be in the format of
the files produced by maxfilter. If dict, keys should
be the time points and entries should be 4x4 ``dev_head_t``
matrices. If None, the original head position (from
``info['dev_head_t']``) will be used. If tuple, should have the
same format as data returned by `head_pos_to_trans_rot_t`.
If array, should be of the form returned by `read_head_pos`.
mindist : float
Minimum distance between sources and the inner skull boundary
to use during forward calculation.
interp : str
Either 'cos2', 'linear', or 'zero', the type of forward-solution
interpolation to use between forward solutions at different
head positions.
iir_filter : None | array
IIR filter coefficients (denominator) e.g. [1, -1, 0.2].
n_jobs : int
Number of jobs to use.
random_state : None | int | np.random.RandomState
The random generator state used for blink, ECG, and sensor
noise randomization.
verbose : bool, str, int, or None
If not None, override default verbose level (see mne.verbose).
Returns
-------
raw : instance of Raw
The simulated raw file.
See Also
--------
read_head_pos
simulate_evoked
simulate_stc
simalute_sparse_stc
Notes
-----
Events coded with the position number (starting at 1) will be stored
in the trigger channel (if available) at times corresponding to t=0
in the ``stc``.
The resulting SNR will be determined by the structure of the noise
covariance, the amplitudes of ``stc``, and the head position(s) provided.
The blink and ECG artifacts are generated by 1) placing impulses at
random times of activation, and 2) convolving with activation kernel
functions. In both cases, the scale-factors of the activation functions
(and for the resulting EOG and ECG channel traces) were chosen based on
visual inspection to yield amplitudes generally consistent with those
seen in experimental data. Noisy versions of the blink and ECG
activations will be stored in the first EOG and ECG channel in the
raw file, respectively, if they exist.
For blink artifacts:
1. Random activation times are drawn from an inhomogeneous poisson
process whose blink rate oscillates between 4.5 blinks/minute
and 17 blinks/minute based on the low (reading) and high (resting)
blink rates from [1]_.
2. The activation kernel is a 250 ms Hanning window.
3. Two activated dipoles are located in the z=0 plane (in head
coordinates) at ±30 degrees away from the y axis (nasion).
4. Activations affect MEG and EEG channels.
For ECG artifacts:
1. Random inter-beat intervals are drawn from a uniform distribution
of times corresponding to 40 and 80 beats per minute.
2. The activation function is the sum of three Hanning windows with
varying durations and scales to make a more complex waveform.
3. The activated dipole is located one (estimated) head radius to
the left (-x) of head center and three head radii below (+z)
head center; this dipole is oriented in the +x direction.
4. Activations only affect MEG channels.
.. versionadded:: 0.10.0
References
----------
.. [1] Bentivoglio et al. "Analysis of blink rate patterns in normal
subjects" Movement Disorders, 1997 Nov;12(6):1028-34.
"""
if not isinstance(raw, _BaseRaw):
raise TypeError('raw should be an instance of Raw')
times, info, first_samp = raw.times, raw.info, raw.first_samp
raw_verbose = raw.verbose
# Check for common flag errors and try to override
if not isinstance(stc, _BaseSourceEstimate):
raise TypeError('stc must be a SourceEstimate')
if not np.allclose(info['sfreq'], 1. / stc.tstep):
raise ValueError('stc and info must have same sample rate')
if len(stc.times) <= 2: # to ensure event encoding works
raise ValueError('stc must have at least three time points')
stim = False if len(pick_types(info, meg=False, stim=True)) == 0 else True
n_jobs = check_n_jobs(n_jobs)
rng = check_random_state(random_state)
if interp not in ('cos2', 'linear', 'zero'):
raise ValueError('interp must be "cos2", "linear", or "zero"')
if head_pos is None: # use pos from file
dev_head_ts = [info['dev_head_t']] * 2
offsets = np.array([0, len(times)])
interp = 'zero'
# Use position data to simulate head movement
else:
if isinstance(head_pos, string_types):
head_pos = read_head_pos(head_pos)
if isinstance(head_pos, np.ndarray):
head_pos = head_pos_to_trans_rot_t(head_pos)
if isinstance(head_pos, tuple): # can be an already-loaded pos file
transs, rots, ts = head_pos
ts -= first_samp / info['sfreq'] # MF files need reref
dev_head_ts = [
np.r_[np.c_[r, t[:, np.newaxis]], [[0, 0, 0, 1]]]
for r, t in zip(rots, transs)
]
del transs, rots
elif isinstance(head_pos, dict):
ts = np.array(list(head_pos.keys()), float)
ts.sort()
dev_head_ts = [head_pos[float(tt)] for tt in ts]
else:
raise TypeError('unknown head_pos type %s' % type(head_pos))
bad = ts < 0
if bad.any():
raise RuntimeError('All position times must be >= 0, found %s/%s'
'< 0' % (bad.sum(), len(bad)))
bad = ts > times[-1]
if bad.any():
raise RuntimeError('All position times must be <= t_end (%0.1f '
'sec), found %s/%s bad values (is this a split '
'file?)' % (times[-1], bad.sum(), len(bad)))
if ts[0] > 0:
ts = np.r_[[0.], ts]
dev_head_ts.insert(0, info['dev_head_t']['trans'])
dev_head_ts = [{
'trans': d,
'to': info['dev_head_t']['to'],
'from': info['dev_head_t']['from']
} for d in dev_head_ts]
if ts[-1] < times[-1]:
dev_head_ts.append(dev_head_ts[-1])
ts = np.r_[ts, [times[-1]]]
offsets = raw.time_as_index(ts)
offsets[-1] = len(times) # fix for roundoff error
assert offsets[-2] != offsets[-1]
del ts
src = _ensure_src(src, verbose=False)
if isinstance(bem, string_types):
bem = read_bem_solution(bem, verbose=False)
if isinstance(cov, string_types):
if cov == 'simple':
cov = make_ad_hoc_cov(info, verbose=False)
else:
cov = read_cov(cov, verbose=False)
assert np.array_equal(offsets, np.unique(offsets))
assert len(offsets) == len(dev_head_ts)
approx_events = int(
(len(times) / info['sfreq']) / (stc.times[-1] - stc.times[0]))
logger.info('Provided parameters will provide approximately %s event%s' %
(approx_events, '' if approx_events == 1 else 's'))
# Extract necessary info
meeg_picks = pick_types(info, meg=True, eeg=True, exclude=[]) # for sim
meg_picks = pick_types(info, meg=True, eeg=False, exclude=[]) # for CHPI
fwd_info = pick_info(info, meeg_picks)
fwd_info['projs'] = [] # Ensure no 'projs' applied
logger.info(
'Setting up raw simulation: %s position%s, "%s" interpolation' %
(len(dev_head_ts), 's' if len(dev_head_ts) != 1 else '', interp))
verts = stc.vertices
verts = [verts] if isinstance(stc, VolSourceEstimate) else verts
src = _restrict_source_space_to(src, verts)
# array used to store result
raw_data = np.zeros((len(info['ch_names']), len(times)))
# figure out our cHPI, ECG, and blink dipoles
ecg_rr = blink_rrs = exg_bem = hpi_rrs = None
ecg = ecg and len(meg_picks) > 0
chpi = chpi and len(meg_picks) > 0
if chpi:
hpi_freqs, hpi_rrs, hpi_pick, hpi_ons = _get_hpi_info(info)[:4]
hpi_nns = hpi_rrs / np.sqrt(np.sum(hpi_rrs * hpi_rrs,
axis=1))[:, np.newaxis]
# turn on cHPI in file
raw_data[hpi_pick, :] = hpi_ons.sum()
_log_ch('cHPI status bits enbled and', info, hpi_pick)
if blink or ecg:
R, r0 = fit_sphere_to_headshape(info, units='m', verbose=False)[:2]
exg_bem = make_sphere_model(r0,
head_radius=R,
relative_radii=(0.97, 0.98, 0.99, 1.),
sigmas=(0.33, 1.0, 0.004, 0.33),
verbose=False)
if blink:
# place dipoles at 45 degree angles in z=0 plane
blink_rrs = np.array([[np.cos(np.pi / 3.),
np.sin(np.pi / 3.), 0.],
[-np.cos(np.pi / 3.),
np.sin(np.pi / 3), 0.]])
blink_rrs /= np.sqrt(np.sum(blink_rrs * blink_rrs, axis=1))[:,
np.newaxis]
blink_rrs *= 0.96 * R
blink_rrs += r0
# oriented upward
blink_nns = np.array([[0., 0., 1.], [0., 0., 1.]])
# Blink times drawn from an inhomogeneous poisson process
# by 1) creating the rate and 2) pulling random numbers
blink_rate = (1 + np.cos(2 * np.pi * 1. / 60. * times)) / 2.
blink_rate *= 12.5 / 60.
blink_rate += 4.5 / 60.
blink_data = rng.rand(len(times)) < blink_rate / info['sfreq']
blink_data = blink_data * (rng.rand(len(times)) + 0.5) # varying amps
# Activation kernel is a simple hanning window
blink_kernel = np.hanning(int(0.25 * info['sfreq']))
blink_data = np.convolve(blink_data, blink_kernel,
'same')[np.newaxis, :] * 1e-7
# Add rescaled noisy data to EOG ch
ch = pick_types(info, meg=False, eeg=False, eog=True)
noise = rng.randn(blink_data.shape[1]) * 5e-6
if len(ch) >= 1:
ch = ch[-1]
raw_data[ch, :] = blink_data * 1e3 + noise
else:
ch = None
_log_ch('Blinks simulated and trace', info, ch)
del blink_kernel, blink_rate, noise
if ecg:
ecg_rr = np.array([[-R, 0, -3 * R]])
max_beats = int(np.ceil(times[-1] * 80. / 60.))
# activation times with intervals drawn from a uniform distribution
# based on activation rates between 40 and 80 beats per minute
cardiac_idx = np.cumsum(
rng.uniform(60. / 80., 60. / 40., max_beats) *
info['sfreq']).astype(int)
cardiac_idx = cardiac_idx[cardiac_idx < len(times)]
cardiac_data = np.zeros(len(times))
cardiac_data[cardiac_idx] = 1
# kernel is the sum of three hanning windows
cardiac_kernel = np.concatenate([
2 * np.hanning(int(0.04 * info['sfreq'])),
-0.3 * np.hanning(int(0.05 * info['sfreq'])),
0.2 * np.hanning(int(0.26 * info['sfreq']))
],
axis=-1)
ecg_data = np.convolve(cardiac_data, cardiac_kernel,
'same')[np.newaxis, :] * 15e-8
# Add rescaled noisy data to ECG ch
ch = pick_types(info, meg=False, eeg=False, ecg=True)
noise = rng.randn(ecg_data.shape[1]) * 1.5e-5
if len(ch) >= 1:
ch = ch[-1]
raw_data[ch, :] = ecg_data * 2e3 + noise
else:
ch = None
_log_ch('ECG simulated and trace', info, ch)
del cardiac_data, cardiac_kernel, max_beats, cardiac_idx
stc_event_idx = np.argmin(np.abs(stc.times))
if stim:
event_ch = pick_channels(info['ch_names'],
_get_stim_channel(None, info))[0]
raw_data[event_ch, :] = 0.
else:
event_ch = None
_log_ch('Event information', info, event_ch)
used = np.zeros(len(times), bool)
stc_indices = np.arange(len(times)) % len(stc.times)
raw_data[meeg_picks, :] = 0.
hpi_mag = 70e-9
last_fwd = last_fwd_chpi = last_fwd_blink = last_fwd_ecg = src_sel = None
zf = None # final filter conditions for the noise
# don't process these any more if no MEG present
for fi, (fwd, fwd_blink, fwd_ecg, fwd_chpi) in \
enumerate(_iter_forward_solutions(
fwd_info, trans, src, bem, exg_bem, dev_head_ts, mindist,
hpi_rrs, blink_rrs, ecg_rr, n_jobs)):
# must be fixed orientation
# XXX eventually we could speed this up by allowing the forward
# solution code to only compute the normal direction
fwd = convert_forward_solution(fwd,
surf_ori=True,
force_fixed=True,
verbose=False)
if blink:
fwd_blink = fwd_blink['sol']['data']
for ii in range(len(blink_rrs)):
fwd_blink[:, ii] = np.dot(fwd_blink[:, 3 * ii:3 * (ii + 1)],
blink_nns[ii])
fwd_blink = fwd_blink[:, :len(blink_rrs)]
fwd_blink = fwd_blink.sum(axis=1)[:, np.newaxis]
# just use one arbitrary direction
if ecg:
fwd_ecg = fwd_ecg['sol']['data'][:, [0]]
# align cHPI magnetic dipoles in approx. radial direction
if chpi:
for ii in range(len(hpi_rrs)):
fwd_chpi[:, ii] = np.dot(fwd_chpi[:, 3 * ii:3 * (ii + 1)],
hpi_nns[ii])
fwd_chpi = fwd_chpi[:, :len(hpi_rrs)].copy()
if src_sel is None:
src_sel = _stc_src_sel(fwd['src'], stc)
verts = stc.vertices
verts = [verts] if isinstance(stc, VolSourceEstimate) else verts
diff_ = sum([len(v) for v in verts]) - len(src_sel)
if diff_ != 0:
warn('%s STC vertices omitted due to fwd calculation' % diff_)
if last_fwd is None:
last_fwd, last_fwd_blink, last_fwd_ecg, last_fwd_chpi = \
fwd, fwd_blink, fwd_ecg, fwd_chpi
continue
# set up interpolation
n_pts = offsets[fi] - offsets[fi - 1]
if interp == 'zero':
interps = None
else:
if interp == 'linear':
interps = np.linspace(1, 0, n_pts, endpoint=False)
else: # interp == 'cos2':
interps = np.cos(0.5 * np.pi * np.arange(n_pts))**2
interps = np.array([interps, 1 - interps])
assert not used[offsets[fi - 1]:offsets[fi]].any()
event_idxs = np.where(stc_indices[offsets[fi - 1]:offsets[fi]] ==
stc_event_idx)[0] + offsets[fi - 1]
if stim:
raw_data[event_ch, event_idxs] = fi
logger.info(' Simulating data for %0.3f-%0.3f sec with %s event%s' %
(tuple(offsets[fi - 1:fi + 1] / info['sfreq']) +
(len(event_idxs), '' if len(event_idxs) == 1 else 's')))
# Process data in large chunks to save on memory
chunk_size = 10000
chunks = np.concatenate((np.arange(offsets[fi - 1], offsets[fi],
chunk_size), [offsets[fi]]))
for start, stop in zip(chunks[:-1], chunks[1:]):
assert stop - start <= chunk_size
used[start:stop] = True
if interp == 'zero':
this_interp = None
else:
this_interp = interps[:, start - chunks[0]:stop - chunks[0]]
time_sl = slice(start, stop)
this_t = np.arange(start, stop) / info['sfreq']
stc_idxs = stc_indices[time_sl]
# simulate brain data
raw_data[meeg_picks, time_sl] = \
_interp(last_fwd['sol']['data'], fwd['sol']['data'],
stc.data[:, stc_idxs][src_sel], this_interp)
# add sensor noise, ECG, blink, cHPI
if cov is not None:
noise, zf = _generate_noise(fwd_info,
cov,
iir_filter,
rng,
len(stc_idxs),
zi=zf)
raw_data[meeg_picks, time_sl] += noise
if blink:
raw_data[meeg_picks, time_sl] += \
_interp(last_fwd_blink, fwd_blink, blink_data[:, time_sl],
this_interp)
if ecg:
raw_data[meg_picks, time_sl] += \
_interp(last_fwd_ecg, fwd_ecg, ecg_data[:, time_sl],
this_interp)
if chpi:
sinusoids = np.zeros((len(hpi_freqs), len(stc_idxs)))
for fidx, freq in enumerate(hpi_freqs):
sinusoids[fidx] = 2 * np.pi * freq * this_t
sinusoids[fidx] = hpi_mag * np.sin(sinusoids[fidx])
raw_data[meg_picks, time_sl] += \
_interp(last_fwd_chpi, fwd_chpi, sinusoids, this_interp)
assert used[offsets[fi - 1]:offsets[fi]].all()
# prepare for next iteration
last_fwd, last_fwd_blink, last_fwd_ecg, last_fwd_chpi = \
fwd, fwd_blink, fwd_ecg, fwd_chpi
assert used.all()
raw = RawArray(raw_data, info, first_samp=first_samp, verbose=False)
raw.verbose = raw_verbose
logger.info('Done')
return raw
def istft(y_r, y_i, window_size, stride, fft_size, window_type='hanning', center=True):
"""Computes the inverse shoft-time Fourier transform
Note: We use a constant square inverse window for the reconstruction
of the time-domain signal, therefore, the first and last
`window_size - stride` are not perfectly reconstructed.
Args:
y_r (~nnabla.Variable): Real part of STFT of size `batch_size x fft_size//2 + 1 x frame_size`.
y_i (~nnabla.Variable): Imaginary part of STFT of size `batch_size x fft_size//2 + 1 x frame_size`.
window_size (int): Size of STFT analysis window.
stride (int): Number of samples that we shift the window, also called `hop size`.
fft_size (int): Size of the FFT, (STFT has `fft_size // 2 + 1` frequency bins).
window_type (str): Analysis window, can be either `hanning`, `hamming` or `rectangular`.
For convenience, also `window_type=None` is supported which is equivalent to `window_type='rectangular'`.
center (bool): If `True`, then it is assumed that the time-domain signal has centered frames.
Returns:
~nnabla.Variable: Time domain sequence of size `batch_size x sample_size`.
"""
from nnabla.parameter import get_parameter, get_parameter_or_create
conv_cos = get_parameter('conv_cos')
conv_sin = get_parameter('conv_sin')
if conv_cos is None or conv_sin is None:
if window_type == 'hanning':
window_func = np.hanning(window_size + 1)[:-1]
elif window_type == 'hamming':
window_func = np.hamming(window_size + 1)[:-1]
elif window_type == 'rectangular' or window_type is None:
window_func = np.ones(window_size)
else:
raise ValueError("Unknown window type {}.".format(window_type))
# pad window if `fft_size > window_size`
if fft_size > window_size:
diff = fft_size - window_size
window_func = np.pad(
window_func, (diff//2, diff - diff//2), mode='constant')
elif fft_size < window_size:
raise ValueError(
"FFT size has to be as least as large as window size.")
# compute inverse STFT filter coefficients
if fft_size % stride != 0:
raise ValueError("FFT size needs to be a multiple of stride.")
inv_window_func = np.zeros_like(window_func)
for s in range(0, fft_size, stride):
inv_window_func += np.roll(np.square(window_func), s)
mat_cos = np.zeros((fft_size//2 + 1, 1, fft_size))
mat_sin = np.zeros((fft_size//2 + 1, 1, fft_size))
for w in range(fft_size//2+1):
alpha = 1.0 if w == 0 or w == fft_size//2 else 2.0
alpha /= fft_size
for t in range(fft_size):
mat_cos[w, 0, t] = alpha * \
np.cos(2. * np.pi * w * t / fft_size)
mat_sin[w, 0, t] = alpha * \
np.sin(2. * np.pi * w * t / fft_size)
mat_cos = mat_cos * window_func / inv_window_func
mat_sin = mat_sin * window_func / inv_window_func
conv_cos = get_parameter_or_create(
'conv_sin', initializer=mat_cos, need_grad=False)
conv_sin = get_parameter_or_create(
'conv_cos', initializer=mat_sin, need_grad=False)
# compute inverse STFT
x_cos = deconvolution(y_r, conv_cos, stride=(stride,))
x_sin = deconvolution(y_i, conv_sin, stride=(stride,))
x = reshape(x_cos - x_sin, (x_cos.shape[0], x_cos.shape[2]))
if center:
x = x[:, fft_size//2:-fft_size//2]
return x
def get_cos_window(sz):
w, h = sz
cos_window = np.hanning(h)[:, np.newaxis].dot(np.hanning(w)[np.newaxis, :])
return cos_window
import functions
from functions import plot_freq_db as plot_freq
from functions import PulseCompr, normalize
from numpy.fft import fftshift
from scipy import signal
freq = (coe.freq / 1e6)
distance = (coe.distance)
N = coe.N
mean = 0
std = 0.001
noise1 = np.random.normal(mean, std, size=N)
delay = 1000
win = signal.nuttall(N) #np.blackman(N)
win1 = np.hamming(N)
win2 = np.hanning(N)
#x = signal.hilbert(win)
x = win
x_delay = np.roll(x, delay)
x_win = np.multiply(x, win)
x_win1 = np.multiply(x, win1)
x_win2 = np.multiply(x, win2)
x_win_delay = np.multiply(np.roll(x_win, delay), 1)
plot_freq(freq, x, 'b')
plot_freq(freq, x_win, 'k')
plot_freq(freq, x_win1, 'm')
plot_freq(freq, x_win2, 'g')
plt.title('Frequency Response of a Linear Chirp')
plt.legend(
