def GenerateBLI(sampling_rate=48000.0,
cutoff=15000.0,
length=4,
ppiv=2700,
beta=8.3,
apodization_factor=0.5,
apodization_beta=0.5):
"""
Generates a bandlimited impulse
"""
kEpsilon = 1e-7
points_count = ppiv * length
xaxis = numpy.linspace(0.0, points_count, points_count)
x2 = length * 2.0 * (xaxis -
(points_count) / 2.0 + kEpsilon) / (points_count)
x3 = numpy.pi * cutoff / sampling_rate * x2
brickwall_impulse = numpy.sin(x3) / x3
kaiser_window = numpy.kaiser(points_count, beta)
bli_data = numpy.transpose(brickwall_impulse) * kaiser_window
# Apodization
apodization_window = (1.0 - apodization_factor) \
* numpy.kaiser(points_count,apodization_beta)
bli_data *= apodization_window
return bli_data
def GenerateBLI(sampling_rate = 48000.0,
cutoff = 15000.0,
length = 4,
ppiv = 2700,
beta = 8.3,
apodization_factor = 0.5,
apodization_beta = 0.5):
"""
Generates a bandlimited impulse
"""
kEpsilon = 1e-7
points_count = ppiv * length
xaxis = numpy.linspace(0.0, points_count, points_count)
x2 = length * 2.0 * (xaxis - (points_count) / 2.0 + kEpsilon) / (points_count)
x3 = numpy.pi * cutoff / sampling_rate * x2
brickwall_impulse = numpy.sin(x3) / x3
kaiser_window = numpy.kaiser(points_count, beta)
bli_data = numpy.transpose(brickwall_impulse) * kaiser_window
# Apodization
apodization_window = (1.0 - apodization_factor) \
* numpy.kaiser(points_count,apodization_beta)
bli_data *= apodization_window
return bli_data
def plot_fourier(t, y, subplotnums=[[2,1,1],[2,1,2]], savedata="none", kaiserwindowparameter=0):
''' Function for plotting fourier series of some given arrays t and y
:param t time variable (plotted along the x-axis)
:param y variable to be plotted along the y-axis
:subplotnums subplotnum for plotting multiple plots in one window
'''
if len(subplotnums) - 1 != len(np.atleast_1d(kaiserwindowparameter)):
print "Bad subplotnum vs kaiserwindowparameter"
return
# First check the t array whether it has a constant dt
dt = t[1] - t[0]
for i in xrange(len(t)-1):
if dt != t[i+1] - t[i]:
print "Gave bad timestep to plot_fourier, the time step in array t must be constant (for now)"
# Use kaiser window on y
_y = y*np.kaiser(len(y), np.atleast_1d(kaiserwindowparameter)[0])
# Plot the raw data as well as the fitted data (fourier series)
pl.subplot(subplotnums[0][0],subplotnums[0][1],subplotnums[0][2])
pl.plot(t,_y,'.',color='r')
# Do FFT on the data
fourier=np.fft.fft(_y)*(1/(float)(len(t)))
# Get frequencies of the fourier
freq=np.fft.fftfreq(len(fourier), d=dt)
# Declare t2 (Note: This is the same as t but we want the steps to be thicker so the data looks smoother
dt2=dt*0.01
t2=np.arange(len(t)*100)*dt2
# Declare y2
y2=np.array([np.sum(fourier*np.exp(complex(0,1)*2*np.pi*freq*T)) for T in t2])
pl.plot(t2,y2,'-',color='b')
pl.legend(["data", "fourier_fit"])
# Plot the frequency spectrums
j = 0
for i in subplotnums[1:]:
pl.subplot(i[0],i[1],i[2])
# Use window function on the data
_y = y*np.kaiser(len(y), np.atleast_1d(kaiserwindowparameter)[j])
# Do FFT on the data
fourier=np.fft.fft(_y)*(1/(float)(len(t)))
# Get frequencies of the fourier
freq=np.fft.fftfreq(len(fourier), d=dt)
# Get the indexes:
toIndex = (int)((len(freq)/2)/2.0 + 1)
#maxValue = np.max(np.abs(fourier[1:len(fourier)/2]))
#while True:
# if toIndex <= 2 or np.abs(fourier[toIndex-1]) > 0.02*maxValue:
# break
# toIndex = toIndex - 1
#pl.plot(freq[1:len(freq)/2],2*np.abs(fourier[1:len(fourier)/2]), marker='.', linestyle='-', linewidth=0.5)
if savedata != "none":
saveplotdata( freq[1:toIndex], np.log(2*np.abs(fourier[1:toIndex])), savedata + "_" + str(j) + ".npy" )
pl.plot(freq[1:toIndex],2*np.abs(fourier[1:toIndex]), marker='.', linestyle='-', linewidth=0.5)
pl.legend(["frequency_spectrum"])
pl.ylim([0,1.05*max(2*np.abs(fourier[1:len(fourier)/2]))])
#pl.xlim([0, 0.13])
#xTicks = np.arange(14)/100.0
#pl.xticks(xTicks)
# Put interactive mode on and show the plot:
#pl.ion()
#pl.show()
j = j + 1
def BM3D1D_S2(noisySignal, basicEstimate):
finalEstimate = np.zeros(noisySignal.shape, dtype=complex)
finalWeight = np.zeros(noisySignal.shape, dtype=complex)
Window = np.array(
np.kaiser(S2_blocksize, beta) + 1j * np.kaiser(S2_blocksize, beta),
dtype=complex) / np.sqrt(2)
finalKaiser = Window
BlockDCT_noisy = preDCT1D(noisySignal, S2_blocksize)
BlockDCT_basic = preDCT1D(basicEstimate, S2_blocksize)
count = 0
start_ = time.time()
all_ = int((basicEstimate.shape[0] - S2_blocksize) / S2_DownScale) + 2
for i in range(
int((basicEstimate.shape[0] - S2_blocksize) / S2_DownScale) + 2):
print('i={}; Processing {}% ({}/{}), consuming {} s'.format(
i, count * 100 / all_, count, all_,
time.time() - start_))
RefPoint = min(S2_DownScale * i,
basicEstimate.shape[0] - S2_blocksize - 1)
BlockPos, BlockGroup_basic, BlockGroup_noisy = S2_Grouping1D(
basicEstimate, noisySignal, RefPoint, S2_blocksize, S2_Threshold,
S2_MaxMatch, S2_WindowSize, BlockDCT_basic, BlockDCT_noisy)
BlockGroup_noisy, WienerWeight = S2_2DFiltering(
BlockGroup_basic, BlockGroup_noisy)
S2_Aggregation1D(BlockGroup_noisy, WienerWeight, BlockPos,
finalEstimate, finalWeight, finalKaiser)
count += 1
finalWeight = np.where(finalWeight == 0, 1, finalWeight)
finalEstimate[:] /= finalWeight[:]
return finalEstimate
def make_sense(self,u0):
st=self.st
L=numpy.shape(u0)[-1]
u0dims= numpy.ndim(u0)
rows=numpy.shape(u0)[0]
cols=numpy.shape(u0)[1]
# dpss rely on ctypes which are not suitable for cx_freeze
# [dpss_rows, eigens] = spectrum.mtm.dpss(rows, 50, 1)
# [dpss_cols, eigens] = spectrum.mtm.dpss(cols, 50, 1)
dpss_rows = numpy.kaiser(rows, 100)
dpss_cols = numpy.kaiser(cols, 100)
dpss_rows = numpy.fft.fftshift(dpss_rows)
dpss_cols = numpy.fft.fftshift(dpss_cols)
dpss_rows = appendmat(dpss_rows,cols)
dpss_cols = appendmat(dpss_cols,rows)
dpss_fil=dpss_rows*dpss_cols.T # low pass filter
rms=numpy.sqrt(numpy.mean(u0*u0.conj(),-1)) # Root of sum square
st['sensemap']=numpy.ones(numpy.shape(u0),dtype=numpy.complex64)
# print('L',L)
# print('rms',numpy.shape(rms))
for ll in numpy.arange(0,L):
st['sensemap'][:,:,ll]=(u0[:,:,ll]+1e-15)/(rms+1e-15)
st['sensemap'][:,:,ll]=scipy.fftpack.ifft2(scipy.fftpack.fft2(st['sensemap'][:,:,ll])*dpss_fil)
return st
def update_properties(sample_rate, number_of_samples, number_of_averages):
'''Send a control signal to the MCU to change the sample rate or number
of samples'''
global window_map, freq_axis, freq_mag_history
if int(sample_rate) != adc.sample_rate or int(
number_of_samples) != adc.number_of_samples:
# Requires board reset so only do if necessary.
status_reg_f = '\n'.join(
adc.modify_sample_properties(sample_rate, number_of_samples))
# rebuild the window map
window_map = {
'rect': [1] * adc.number_of_samples,
'blackman': np.blackman(adc.number_of_samples),
'kaiser5': np.kaiser(adc.number_of_samples, 5 * np.pi),
'kaiser7': np.kaiser(adc.number_of_samples, 7 * np.pi),
}
# Get, format, and log the status register.
logging.info(status_reg_f)
# set the size of the history deque, and in the process clear it..
freq_mag_history = deque(maxlen=number_of_averages)
# Create a new frequency axis.
freq_axis = np.fft.rfftfreq(n=adc.number_of_samples, d=1 / adc.sample_rate)
return ''
def window_kaiser(N, fade_in, fade_out, fs, beta=3):
L, M, n_ones = fade_vector_arange(N, fade_in, fade_out, fs)
w1 = np.kaiser(L, beta)[:L / 2]
w2 = np.ones(len(n_ones))
w3 = np.kaiser(M, beta)[M / 2:M]
return np.concatenate((w1, w2, w3))
def test_kaiser_1(self):
a = np.kaiser(12, 14)
print(a)
a = np.kaiser(3, 5)
print(a)
return
def main():
x = np.zeros(500)
x[100:150] = 1
X = fftpack.fft(x)
f, (ax0, ax1) = plt.subplots(2, 1, sharex=True)
ax0.plot(x)
ax0.set_ylim(-0.1, 1.1)
ax1.plot(fftpack.fftshift(np.abs(X)))
ax1.set_ylim(-5, 55)
plt.show()
t = np.linspace(0, 1, 500)
x = np.sin(10 * np.pi * t)
X = fftpack.fft(x)
f, (ax0, ax1) = plt.subplots(2, 1)
ax0.plot(x)
ax0.set_ylim(-1.1, 1.1)
ax1.plot(fftpack.fftfreq(len(t)), np.abs(X))
ax1.set_ylim(0, 190)
plt.show()
f, ax = plt.subplots()
N = 10
beta_max = 5
colormap = plt.cm.plasma
norm = plt.Normalize(vmin=0, vmax=beta_max)
lines = [
ax.plot(np.kaiser(100, beta), color=colormap(norm(beta)))
for beta in np.linspace(0, beta_max, N)
]
sm = plt.cm.ScalarMappable(cmap=colormap, norm=norm)
sm._A = []
plt.colorbar(sm).set_label(r'Kaiser $\beta$')
plt.show()
win = np.kaiser(len(t), 5)
X_win = fftpack.fft(x * win)
plt.plot(fftpack.fftfreq(len(t)), np.abs(X_win))
plt.ylim(0, 190)
plt.show()
def _kaiser_window(self, width, beta):
"""
Generates a kaiser window
beta Window shape
0 Rectangular
5 Similar to a Hamming
6 Similar to a Hann
8.6 Similar to a Blackman
"""
return np.kaiser(width[0], beta).reshape((-1,1,1)) * np.kaiser(width[1], beta).reshape((-1,1)) * np.kaiser(width[2], beta)
def window(img, beta):
win = np.outer(np.kaiser(img.shape[0], beta),
np.kaiser(img.shape[1], beta))
img = np.fft.fftshift(img)
img = np.fft.fft2(img)
img = np.fft.ifftshift(img)
img = win * img
img = np.fft.ifftshift(img)
img = np.fft.ifft2(img)
img = np.fft.fftshift(img)
return np.abs(img)
def _kaiser_window(self, width, beta):
"""
Generates a kaiser window
beta Window shape
0 Rectangular
5 Similar to a Hamming
6 Similar to a Hann
8.6 Similar to a Blackman
"""
return np.kaiser(width[0], beta).reshape(
(-1, 1, 1)) * np.kaiser(width[1], beta).reshape(
(-1, 1)) * np.kaiser(width[2], beta)
def smooth(self,
x=0,
y=0,
window='kaiser',
debug=False): #smoothes via adjacent averaging
"""
convolves the signal with a 2D window function
currently only equipped for kaiser window
'x' and 'y', both integers, are the nth nearest neighbor that get
included in the window
Decide whether to perform xaxis smoothing or yaxis by setting the
boolean true
"""
# n is the seed of the odd numbers: n is how many nearest neighbors
# in each direction
# make sure n is integer and n < grid dimension
# account for interpolation using grid factor
nx = x
ny = y
# create the window function
if window == 'kaiser':
# beta, a real number, is a form parameter of the kaiser window
# beta = 5 makes this look approximately gaussian in weighting
# beta = 5 similar to Hamming window, according to numpy
# over window (about 0 at end of window)
beta = 5.0
wx = np.kaiser(2 * nx + 1, beta)
wy = np.kaiser(2 * ny + 1, beta)
# for a 2D array, y is the first index listed
w = np.zeros((len(wy), len(wx)))
for i in range(len(wy)):
for j in range(len(wx)):
w[i, j] = wy[i] * wx[j]
# create a padded array of zi
# numpy 1.7.x required for this to work
temp_z = np.pad(self.zi, ((ny, ny), (nx, nx)), mode='edge')
from scipy.signal import convolve
out = convolve(temp_z, w / w.sum(), mode='valid')
if debug:
plt.figure()
sp1 = plt.subplot(131)
plt.contourf(self.zi, 100)
plt.subplot(132, sharex=sp1, sharey=sp1)
plt.contourf(w, 100)
plt.subplot(133)
plt.contourf(out, 100)
self.z = out
# reset zmax
self.zmax = self.z.max()
self.zmin = self.z.min()
def periodogram(x,y,z,t,name):
vel=x*x+y*y
components=[vel,z*z]
F=[]
A=[]
for i in range(0,len(components)):
window=np.kaiser(components[i].shape[-1],5)
vel=components[i]*window
f,a=DO_FFT(vel,20)
F.append(f)
A.append(a)
plt.figure(1,figsize=(11,7))
plt.title("Spectral Gap - LiCor Fontanella1 Precampagna")
plt.subplot(121)
plt.title("FFT horizontal velocity")
plt.xlabel("Frequency [Hz]")
plt.ylabel("Power Spectrum [dB]")
plt.loglog(F[0],A[0],'k', markersize=0.1)
plt.subplot(122)
plt.title("FFT vertical velocity")
plt.xlabel("Frequency [Hz]")
plt.ylabel("Power Spectrum [dB]")
plt.loglog(F[1],A[1],'r',markersize=0.1)
try:
plt.savefig("graph/"+name+"_FFT.png", figuresize=(8,6), dpi=320, format="png")
print_ok("Graph saved in: "+"graph/"+name+"_FFT.png")
except IOError as IoE:
print_fail("I/O Error! Erro number = {0}; {1}".format(IoE.errno,IoE.strerror))
exit(IoE.errno)
def plotWindowFunc(): plt.clf() plt.plot(np.arange(20), np.kaiser(20,3.5)) plt.plot(np.arange(20), np.bartlett(20)) plt.plot(np.arange(20), np.blackman(20)) plt.plot(np.arange(20), np.hamming(20)) plt.plot(np.arange(20), np.hanning(20))
def main():
import sys
from scipy import misc
softness = 2
r_scale = 3
windowmaker = lambda x: np.kaiser(x, softness)
for infilename in sys.argv[1:]:
print("File: %s" % infilename)
array = misc.imread(infilename)
circles = get_circles(array, 5)
l_pnoise, l_order, c_order, r_order, r_pnoise = circles
window = get_holed_window(windowmaker, l_order[2] * r_scale, 10)
mask = get_mask(array.shape, window, l_order[1])
window = windowmaker(l_pnoise[2] * r_scale)
mask *= 1 - get_mask(array.shape, window, l_pnoise[1])
window = windowmaker(c_order[2] * r_scale)
mask *= 1 - get_mask(array.shape, window, c_order[1])
# showimage(mask * 255)
# showimage(logscale(mask * array))
window = get_holed_window(windowmaker, r_order[2] * r_scale, 10)
mask = get_mask(array.shape, window, r_order[1])
window = windowmaker(r_pnoise[2] * r_scale)
mask *= 1 - get_mask(array.shape, window, r_pnoise[1])
window = windowmaker(c_order[2] * r_scale)
mask *= 1 - get_mask(array.shape, window, c_order[1])
def signal_filter(self, channel, freqs=(1, 15)):
"""Filter signal from specific channel. A FFT is performed in
the signal, and the result is multiplied by a window function
(kaiser function), which nulls the undesired beating
frequencies, that are outside of 'freqs'. The signal is then
recreated with an IFFT."""
# zero padding size:
zer_pad_filter = 4
# alias for sweep_size
N = int(self.sweep_size)
# FFT with zero padding
fft = np.fft.rfft(self.single_sweep_data[channel], zer_pad_filter * N)
# bp=fft[:] #used for other plot functions
fmin, fmax = freqs
# creates the beating frequency axis, and finds the position of
# the frequency limits in the axis
fft_freq = np.linspace(0, self.rate / 2., num=zer_pad_filter * N / 2)
cmin = (abs(fft_freq - fmin)).argmin()
cmax = (abs(fft_freq - fmax)).argmin()
# creates window function for filter. Second argument of kaiser
# function must be float
window_func = np.concatenate(
(np.zeros(cmin + 1), np.kaiser(cmax - cmin, 2.),
np.zeros(zer_pad_filter * N / 2 - cmax)))
# multiply the window by the signal's FFT.
bp = np.multiply(fft, window_func)
# Since the signal is REAL, we use IRFFT, and takes only the
# first half, since the other half is symmetric.
newsig = np.fft.irfft(bp)[:N]
return newsig
def get_kaiserWindow(kHW):
'''
返回kaiser窗
'''
k = np.kaiser(kHW, 2)
k_2d = k[:, np.newaxis] @ k[np.newaxis, :]
return k_2d
def test_snr(param, freq):
"""Test the SNR using a test tone at the given frequency.
This works by computing the FFT of the result, zeroing the FFT
corresponding to the test tone, and comparing the signal power
with the signal power of the output signal. Returns the SNR ratio
(as a ratio, not dB).
"""
w = 2 * math.pi * freq / param.RATE_IN
length = param.TEST_LENGTH
beta = param.TEST_BETA
indata = (0.5 * numpy.sin(w * numpy.arange(length, dtype='float64')))
outdata = resample_arr(param, indata)
window = numpy.kaiser(len(outdata), beta)
outdata *= window
fft = numpy.fft.rfft(outdata)
nbins = NBINS
fbin = round(freq * len(outdata) / param.RATE_OUT)
bin0 = min(max(fbin - nbins / 2, 0), len(fft))
bin1 = min(max(fbin - nbins / 2 + nbins, 0), len(fft))
fft[bin0:bin1] = 0
noise = numpy.std(fft) / math.sqrt(len(outdata))
signal = numpy.average(window)
return signal / noise
def Myfft(df,time,value,windowname,dst,feature,count):
## Add time interpolate
x = time - time[0]
y = value
x_new = np.arange(x[0],x[0]+x[len(x)-1],dst)
f = interpolate.interp1d(x,y,kind='slinear')
#'linear', 'nearest', 'zero', 'slinear', 'quadratic', 'cubic'
y_new = f(x_new)
# 采样率
Fs = len(x_new)/x_new[len(x_new)-1]
# 添加自定义噪声
nx = np.linspace(0,x[len(x)-1],x[len(x)-1]*1/dst) #100采样率
sinu1 = 8*np.cos(2*np.pi*0.3*Fs*nx-np.pi*30/180)
sinu2 = 5*np.cos(2*np.pi*0.2*Fs*nx-np.pi*30/180)
noise = sinu1 + sinu2
y_new = y_new + noise
# 数据长度
L = len(x_new)
# 删减数据为fft做准备
NFFT = int(math.pow(2,ceillog2(L+1)-1))
use_y = y_new[0:NFFT]
windowdata = 0
if windowname == 'Hamming':
windowdata = np.hamming(NFFT)
elif windowname == 'Kaiser': #需要两个输入参数
windowdata = np.kaiser(NFFT)
elif windowname == 'Blackman':
windowdata = np.blackman(NFFT)
elif windowname == 'Hanning':
windowdata = np.hanning(NFFT)
else:
windowdata = np.ones(1,NFFT)
use_y = use_y*windowdata
# fft
Y = np.fft.fft(use_y,n=NFFT)/NFFT
Y = 2*abs(Y[0:NFFT/2+1])
f = np.linspace(0,Fs/2,NFFT/2+1)
[Pxx,F] = plt.psd(use_y,NFFT=NFFT,Fs = Fs)
col = []
for columns in df:
col.append(columns)
sta = df.iloc[:,1:2].describe() #只分析前一列。可修改
sta.loc['range'] = sta.loc['max']-sta.loc['min']#极差
sta.loc['var'] = sta.loc['std']/sta.loc['mean']#变异系数
sta.loc['dis'] = sta.loc['75%']-sta.loc['25%']#四分位数间距
sta.loc['peak']=time_feature.peak(use_y)
sta.loc['rms']=time_feature.rms(use_y)
sta.loc['pfactor']=time_feature.pfactor(use_y)
sta.loc['kfactor']=time_feature.kfactor(use_y)
sta.loc['pulse']=time_feature.pulse(use_y)
sta.loc['margin']=time_feature.margin(use_y)
sta.loc['waveform']=time_feature.waveform(use_y)
sta.loc['sqa']=time_feature.sqa(use_y)
sta.loc['absma']=time_feature.absma(use_y)
sta.loc['skewness']=time_feature.skewness(use_y)
sta.loc['kurtosis']=time_feature.kurtosis(use_y)
sta.loc['controid_f']=freq_feature.centroid_f(Pxx,F)
sta.loc['f_variance']=freq_feature.f_variance(Pxx,F)
sta.loc['ms_f']=freq_feature.ms_f(Pxx,F)
feature['Speed%d'%(count)] = sta['Speed']
def _resample_window_oct(p, q):
"""Port of Octave code to Python"""
gcd = np.gcd(p, q)
if gcd > 1:
p /= gcd
q /= gcd
# Properties of the antialiasing filter
log10_rejection = -3.0
stopband_cutoff_f = 1. / (2 * max(p, q))
roll_off_width = stopband_cutoff_f / 10
# Determine filter length
rejection_dB = -20 * log10_rejection
L = np.ceil((rejection_dB - 8) / (28.714 * roll_off_width))
# Ideal sinc filter
t = np.arange(-L, L + 1)
ideal_filter = 2 * p * stopband_cutoff_f \
* np.sinc(2 * stopband_cutoff_f * t)
# Determine parameter of Kaiser window
if (rejection_dB >= 21) and (rejection_dB <= 50):
beta = 0.5842 * (rejection_dB - 21)**0.4 \
+ 0.07886 * (rejection_dB - 21)
elif rejection_dB > 50:
beta = 0.1102 * (rejection_dB - 8.7)
else:
beta = 0.0
# Apodize ideal filter response
h = np.kaiser(2 * L + 1, beta) * ideal_filter
return h
def kaiser(x, width=None, weights=None, do_fit_edges=False):
"""Smooth the values in `x` with the Kaiser windowed filter.
See: https://en.wikipedia.org/wiki/Kaiser_window
Parameters
----------
x : array-like
1-dimensional numeric data set.
width : float
Fraction of x's total length to include in the rolling window (i.e. the
proportional window width), or the integer size of the window.
"""
if len(x) < 2:
return x
if width is None:
width = guess_window_size(x, weights)
x, wing, signal = check_inputs(x, width, False)
# Apply signal smoothing
window = np.kaiser(2 * wing + 1, 14)
if weights is not None:
y, _w = convolve_weighted(window, signal, weights)
else:
y = convolve_unweighted(window, signal, wing)
if do_fit_edges:
_fit_edges(x, y, wing) # In-place
return y
def init(img, _blk_size, _Beta_Kaiser):
m_shape = img.shape
m_img = numpy.matrix(numpy.zeros(m_shape, dtype=float))
m_wight = numpy.matrix(numpy.zeros(m_shape, dtype=float))
K = numpy.matrix(numpy.kaiser(_blk_size, _Beta_Kaiser))
m_Kaiser = numpy.array(K.T * K)
return m_img, m_wight, m_Kaiser
def kaiser(active):
"""Kaiser tapering window."""
idx = _windowidx(active)
# compute coefficients
window = np.zeros(active.shape)
window[idx] = np.kaiser(len(idx), 2)
return window
def create_windowing_function(
self,
a_len: int,
key='hann',
sigma: int = None,
is_show_info_prints: bool = False) -> np.ndarray:
""" Creates a real-valued (float64) vector for i.e. spectrally shaping an A-scan """
if sigma is None:
sigma = a_len // 10
if key.lower() == 'hann':
return np.asarray(np.hanning(a_len))
elif key.lower() == 'hamm':
if is_show_info_prints:
print("[INFO:] Using Hamming-Window - not Hanning-window")
return np.asarray(np.hamming(a_len))
elif key.lower() == 'kaiser':
if is_show_info_prints:
print("[INFO:] Using Kaiser-Window - not Hanning-window")
return np.asarray(np.kaiser(a_len, beta=sigma))
elif key.lower() == 'gauss':
if is_show_info_prints:
print("[INFO:] Using Gaussian-Window - not Hanning-window")
return np.asarray(signal.gaussian(a_len, sigma))
else:
raise ValueError(
"You have passed an unrecognized key for the windowing-parameter"
)
def tunedhps(x,
fs=44100,
lf=255,
harmonics=3,
precision=1,
window=lambda x: _np.kaiser(x, 7.14285)):
""" Estimates the pitch (fundamental frequency) of the given sample array by an HPS implementation that evaluates
the spectrum only in tuned note frequencies (e.g. frequencies of notes in an assumed tuning). """
x -= _np.mean(x)
N = x.size
w = x * window(N)
if fs / N > precision:
delta = int(fs / precision) - N
w = _np.append(w, _np.zeros(delta))
N = w.size
frequencies = [
f for f in _mt.notes if f >= lf and f < fs / (2 * harmonics)
]
X = _np.log(_np.abs(_np.fft.rfft(w)))
Y = _np.ones(len(frequencies))
for i in range(0, len(frequencies)):
for h in range(1, harmonics + 1):
f_idx = int(round(frequencies[i] * h / 2) * 2 * N / fs)
Y[i] += X[f_idx] * (0.9**(h - 1))
arg_peak = _np.argmax(Y)
return frequencies[arg_peak]
def sfdr(x, fs): # attempt of a python version of MATLABs sfdr function
xw = x * np.kaiser(len(x), beta=38) / len(x)
xw -= np.mean(xw)
Y = np.fft.rfft(xw)
freqs = np.fft.rfftfreq(len(xw), d=1.0 / fs)
mag = np.abs(Y)
YdB = 20 * np.log10(mag)
peakind = find_peaks(YdB, distance=5)
pksf = freqs[peakind[0]]
pksY = YdB[peakind[0]]
isorted = np.argsort(pksY)
sfdrval = pksY[isorted[-1]] - pksY[isorted[-2]]
#fig, ax = plt.subplots()
ax = plt.gca()
pkfa = pksf[isorted[-1]]
pkYa = pksY[isorted[-1]]
pkfb = pksf[isorted[-2]]
pkYb = pksY[isorted[-2]]
plt.fill_between((0, fs / 2), (pkYb, pkYb), (pkYa, pkYa),
label='SFDR',
color="lightblue")
ax.plot(pkfa, pkYa, marker="s", label='fundamental')
ax.plot(pkfb, pkYb, marker="s", label='spurs')
ax.plot(freqs, YdB)
ax.set(xlabel='Frequency (Hz)',
ylabel='Power (dB)',
title="SFDR %.2f dB" % sfdrval)
ax.set_xlim(0, fs / 2)
ax.set_ylim(-400, 10)
ax.legend(loc="upper right")
return sfdrval
def main():
import sys
from scipy import misc
softness = 2
r_scale = 3
windowmaker = lambda x: np.kaiser(x, softness)
for infilename in sys.argv[1:]:
print("File: %s" % infilename)
array = misc.imread(infilename)
circles = get_circles(array, 5)
l_pnoise, l_order, c_order, r_order, r_pnoise = circles
window = get_holed_window(windowmaker, l_order[2] * r_scale, 10)
mask = get_mask(array.shape, window, l_order[1])
window = windowmaker(l_pnoise[2] * r_scale)
mask *= 1 - get_mask(array.shape, window, l_pnoise[1])
window = windowmaker(c_order[2] * r_scale)
mask *= 1 - get_mask(array.shape, window, c_order[1])
# showimage(mask * 255)
# showimage(logscale(mask * array))
window = get_holed_window(windowmaker, r_order[2] * r_scale, 10)
mask = get_mask(array.shape, window, r_order[1])
window = windowmaker(r_pnoise[2] * r_scale)
mask *= 1 - get_mask(array.shape, window, r_pnoise[1])
window = windowmaker(c_order[2] * r_scale)
mask *= 1 - get_mask(array.shape, window, c_order[1])
def resample(s, p, q, h=None):
"""Change sampling rate by rational factor. This implementation is based on
the Octave implementation of the resample function. It designs the
anti-aliasing filter using the window approach applying a Kaiser window with
the beta term calculated as specified by [2].
Ref [1] J. G. Proakis and D. G. Manolakis,
Digital Signal Processing: Principles, Algorithms, and Applications,
4th ed., Prentice Hall, 2007. Chap. 6
Ref [2] A. V. Oppenheim, R. W. Schafer and J. R. Buck,
Discrete-time signal processing, Signal processing series,
Prentice-Hall, 1999
"""
gcd = fractions.gcd(p,q)
if gcd>1:
p=p/gcd
q=q/gcd
if h is None: #design filter
#properties of the antialiasing filter
log10_rejection = -3.0
stopband_cutoff_f = 1.0/(2.0 * max(p,q))
roll_off_width = stopband_cutoff_f / 10.0
#determine filter length
#use empirical formula from [2] Chap 7, Eq. (7.63) p 476
rejection_db = -20.0*log10_rejection;
l = numpy.ceil((rejection_db-8.0) / (28.714 * roll_off_width))
#ideal sinc filter
t = numpy.arange(-l, l + 1)
ideal_filter=2*p*stopband_cutoff_f*numpy.sinc(2*stopband_cutoff_f*t)
#determine parameter of Kaiser window
#use empirical formula from [2] Chap 7, Eq. (7.62) p 474
beta = signal.kaiser_beta(rejection_db)
#apodize ideal filter response
h = numpy.kaiser(2*l+1, beta)*ideal_filter
ls = len(s)
lh = len(h)
l = (lh - 1)/2.0
ly = numpy.ceil(ls*p/float(q))
#pre and postpad filter response
nz_pre = numpy.floor(q - numpy.mod(l,q))
hpad = h[-lh+nz_pre:]
offset = numpy.floor((l+nz_pre)/q)
nz_post = 0;
while numpy.ceil(((ls-1)*p + nz_pre + lh + nz_post )/q ) - offset < ly:
nz_post += 1
hpad = hpad[:lh + nz_pre + nz_post]
#filtering
xfilt = upfirdn(s, hpad, p, q)
return xfilt[offset-1:offset-1+ly]
def signal_filter(self, channel, freqs=(1, 15)):
"""Filter signal from specific channel. A FFT is performed in
the signal, and the result is multiplied by a window function
(kaiser function), which nulls the undesired beating
frequencies, that are outside of 'freqs'. The signal is then
recreated with an IFFT."""
# zero padding size:
zer_pad_filter = 4
# alias for sweep_size
N = int(self.sweep_size)
# FFT with zero padding
fft = np.fft.rfft(self.single_sweep_data[channel], zer_pad_filter * N)
# bp=fft[:] #used for other plot functions
fmin, fmax = freqs
# creates the beating frequency axis, and finds the position of
# the frequency limits in the axis
fft_freq = np.linspace(0, self.rate / 2.,
num=zer_pad_filter * N / 2)
cmin = (abs(fft_freq - fmin)).argmin()
cmax = (abs(fft_freq - fmax)).argmin()
# creates window function for filter. Second argument of kaiser
# function must be float
window_func = np.concatenate((np.zeros(cmin + 1),
np.kaiser(cmax - cmin, 2.), np.zeros(zer_pad_filter * N / 2 - cmax)))
# multiply the window by the signal's FFT.
bp = np.multiply(fft, window_func)
# Since the signal is REAL, we use IRFFT, and takes only the
# first half, since the other half is symmetric.
newsig = np.fft.irfft(bp)[:N]
return newsig
def lowpass_filter(self,x,width):
#wndw = np.sinc(np.r_[-15:16]/np.pi)/np.pi
wndw = np.kaiser(width,6)
wndw /= np.sum(wndw)
new_array = signal.fftconvolve(x, wndw)
return new_array[int(width/2):x.size+int(width/2)]
def smooth(x,beta):
""" kaiser window smoothing """
window_len=11
s = numpy.r_[x[window_len-1:0:-1],x,x[-1:-window_len:-1]]
w = numpy.kaiser(window_len,beta)
y = numpy.convolve(w/w.sum(),s,mode='valid')
return y[5:len(y)-5]
def fourier_array(t, y, kaiserwindowparameter=0):
''' Function for returning fourier series of some given arrays t and y
:param t time variable (along the x-axis)
:param y variable along the y-axis
:returns numpy array of the fourier series [t2, y2] and frequency [freq]: np.array([t2,y2], freq)
'''
# First check the t array whether it has a constant dt
dt = t[1] - t[0]
for i in range(len(t) - 1):
if dt != t[i + 1] - t[i]:
print(
"Gave bad timestep to plot_fourier, the time step in array t must be constant (for now)"
)
# Use kaiser window on y
y = y * np.kaiser(len(y), kaiserwindowparameter)
# Do FFT on the data
fourier = np.fft.fft(y) * (1 / (float)(len(t)))
# Get frequencies of the fourier
freq = np.fft.fftfreq(len(fourier), d=dt)
# Declare t2 (Note: This is the same as t but we want the steps to be thicker so the data looks smoother
dt2 = dt * 0.01
t2 = np.arange(len(t) * 100) * dt2
# Declare y2
y2 = np.array([
np.sum(fourier * np.exp(complex(0, 1) * 2 * np.pi * freq * T))
for T in t2
])
return np.array([[t2, y2], freq])
def single_taper_spectrum(data, delta, taper_name=None):
"""
Returns the spectrum and the corresponding frequencies for data with the
given taper.
"""
length = len(data)
good_length = length // 2 + 1
# Create the frequencies.
# XXX: This might be some kind of hack
freq = abs(np.fft.fftfreq(length, delta)[:good_length])
# Create the tapers.
if taper_name == 'bartlett':
taper = np.bartlett(length)
elif taper_name == 'blackman':
taper = np.blackman(length)
elif taper_name == 'boxcar':
taper = np.ones(length)
elif taper_name == 'hamming':
taper = np.hamming(length)
elif taper_name == 'hanning':
taper = np.hanning(length)
elif 'kaiser' in taper_name:
taper = np.kaiser(length, beta=14)
# Should never happen.
else:
msg = 'Something went wrong.'
raise Exception(msg)
# Detrend the data.
data = detrend(data)
# Apply the taper.
data *= taper
spec = abs(np.fft.rfft(data)) ** 2
return spec, freq
def test_snr(param, freq):
"""Test the SNR using a test tone at the given frequency.
This works by computing the FFT of the result, zeroing the FFT
corresponding to the test tone, and comparing the signal power
with the signal power of the output signal. Returns the SNR ratio
(as a ratio, not dB).
"""
w = 2 * math.pi * freq / param.RATE_IN
length = param.TEST_LENGTH
beta = param.TEST_BETA
indata = (
0.5 * numpy.sin(w * numpy.arange(length, dtype='float64')))
outdata = resample_arr(param, indata)
window = numpy.kaiser(len(outdata), beta)
outdata *= window
fft = numpy.fft.rfft(outdata)
nbins = NBINS
fbin = round(freq * len(outdata) / param.RATE_OUT)
bin0 = min(max(fbin-nbins/2, 0), len(fft))
bin1 = min(max(fbin-nbins/2 + nbins, 0), len(fft))
fft[bin0:bin1] = 0
noise = numpy.std(fft) / math.sqrt(len(outdata))
signal = numpy.average(window)
return signal / noise
def fft_1d(self, window_length=1000, n_offset=0, padding_ratio=0, window=None, beta=None):
'''
simply calculate the 1D fast Fourier transform of the provided signal in a least intervened way
window_length: length of the tapering window
n_offset: number of IQ pairs to be skipped over
padding_ratio: >= 1, ratio of the full frame length after zero padding to the window length
note that the final frame length will be rounded up to the next power of base 2
any illegal values disable zero padding
window: to be chosen from ["bartlett", "blackman", "hamming", "hanning", "kaiser"]
if None, a rectangular window is implied
if "kaiser" is given, an additional argument of beta is expected
'''
# handling various windows
if window is None:
window_sequence = np.ones(window_length)
elif window == "kaiser":
if beta is None:
raise ValueError("additional argument beta is empty!")
else:
window_sequence = np.kaiser(window_length, beta)
else:
window_function = getattr(np, window)
window_sequence = window_function(window_length)
# round the padded frame length up to the next radix-2 power
n_point = int( np.power(2, np.ceil(np.log2(window_length*padding_ratio))) ) if padding_ratio >= 1 else window_length
# build the frequency sequence
frequencies = np.linspace(-self.sampling_rate/2, self.sampling_rate/2, n_point+1)[:-1] # Hz
if n_point % 2 == 1: frequencies += self.sampling_rate / (2*n_point)
# load the data, apply the window function
signal = super().load(window_length, n_offset)[1] * window_sequence
# create an FFT plan
dummy = pyfftw.empty_aligned(window_length)
fft = pyfftw.builders.fft(dummy, n=n_point, overwrite_input=True, threads=self.n_thread)
spectrum = np.fft.fftshift(fft(signal)) # V, complex-valued, orth-ordered Fourier transform
return frequencies*1e-3, spectrum # kHz, V
def plot_Temperature(fig_size=None):
#{{{
N = 256
hammingWindow = np.hamming(N)
hanningWindow = np.hanning(N)
kaiserWindow = np.kaiser(N,5)
fig = plt.figure()
if fig_size != None:
fig.set_size_inches(fig_size[0], fig_size[1])
for i in range(0,10):
Time = Array[i-1][:,0]
PlData1 = Array[i-1][:, 5]
PlData2 = Array[i-1][:, 6]
PlData3 = Array[i-1][:, 7]
PlData4 = Array[i-1][:, 8]
PlData5 = Array[i-1][:, 9]
PlData6 = Array[i-1][:,10]
PlData7 = Array[i-1][:,16]
ax = fig.add_subplot(5,2,i)
#plt.legend((NameIndex[5],NameIndex[6],NameIndex[7],NameIndex[8],NameIndex[9],NameIndex[10]),'upper left')
#plt.plot(Time,PlData1,label=' 5-OriTemp')
#plt.plot(Time,PlData2,label=' 6-InjTemp')
#plt.plot(Time,PlData3,label=' 7-NUWTemp')
plt.plot(Time,PlData4,label=' 8-NUCTemp')
plt.plot(Time,PlData5,label=' 9-NDCTemp')
plt.plot(Time,PlData6,label='10-FrnTemp')
plt.plot(Time,PlData7,label='16-MixBoil')
plt.legend(fontsize=15,loc = 'upper right')
plt.xlabel('Time[s]')
plt.ylabel('Temperature[K]')
plt.xlim(0,10)
plt.ylim(-200,1400)
def hps(x, fs=44100, lf=255, harmonics=3, precision=2, window=lambda l:_np.kaiser(l, 7.14285)):
""" Estimates the pitch (fundamental frequency) of the given sample array by a standard HPS implementation. """
x -= _np.mean(x)
N = x.size
w = x*window(N)
# Append zeros to the end of the window so that each bin has at least the desired precision.
if fs/N > precision:
delta = int(fs/precision) - N
w = _np.append(w, _np.zeros(delta))
N = w.size
X = _np.log(_np.abs(_np.fft.rfft(w)))
# Sequentially decimate 'X' 'harmonics' times and add it to itself.
# 'precision < fs/N' must hold, lest the decimation loses all the precision we'd gain.
hps = _np.copy(X)
for h in range(2, 2 + harmonics):
dec = _sig.decimate(X, h)
hps[:dec.size] += dec*(0.8**h)
# Find the bin corresponding to the lowest detectable frequency.
lb = lf*N/fs
# And then the bin with the highest spectral content.
arg_peak = lb + _np.argmax(hps[lb:dec.size])
# TODO: Return the full array? A ranked list of identified notes?
return fs*arg_peak/N
def kaiser():
from numpy import kaiser
from matplotlib.pyplot import plot, show
window = kaiser(42, 14)
plot(window)
show()
def preprocess(X, y=None, box_width=256, overlap=32, pad_width=0):
X = pre_flow(X)
out_X = []
out_y = []
m = int(X.shape[0] / box_width) * box_width
w = np.kaiser(box_width + pad_width, 14)
for start in range(0, m, overlap):
end = start + box_width
if end >= len(X):
break
x = X[start:end,]
if pad_width > 0:
x = np.vstack([x, np.zeros((pad_width, x.shape[1]))])
x = (x.T * w).T
psd = abs(np.fft.rfft(x, axis=0))
#freqs, psd = signal.welch(X[start:end,], axis=0)
out_X.append(psd.flatten())
if y != None:
out_y.append(stats.mode(y[start:end])[0][0])
if y != None:
return np.array(out_X), np.array(out_y)
else:
return np.array(out_X)
def construct_window(width, family, scale):
if family == 'bartlett':
return numpy.bartlett(width) * scale
if family == 'blackman':
return numpy.blackman(width) * scale
if family == 'hamming':
return numpy.hamming(width) * scale
if family == 'hann':
import scipy.signal
return scipy.signal.hann(width) * scale
if family == 'hanning':
return numpy.hanning(width) * scale
if family == 'kaiser':
beta = 14
return numpy.kaiser(width, beta) * scale
if family == 'tukey':
import scipy.signal
return scipy.signal.tukey(width) * scale
print('window family %s not supported' % family)
def calc_specgram(data, axis):
N = data.shape[0]
Fs = N / (data[-1, 0] - data[0, 0])
# Round up to a power of 2 for faster FFT
M = 1 << int(.5 * Fs - 1).bit_length()
window = np.kaiser(M, 6.)
def _specgram(x):
return matplotlib.mlab.specgram(x,
Fs=Fs,
NFFT=M,
noverlap=M // 2,
window=window,
mode='psd',
detrend='mean',
scale_by_freq=False)
d = {'x': data[:, 1], 'y': data[:, 2], 'z': data[:, 3]}
if axis != 'all':
pdata, bins, t = _specgram(d[axis])
else:
pdata, bins, t = _specgram(d['x'])
for ax in 'yz':
pdata += _specgram(d[ax])[0]
return pdata, bins, t
def simple_segmentation( wav_data, sample_rate, db_diff = 17, max_silence = 0.8 ):
# filter data
filtered_data = filter_chain(wav_data, sample_rate, 1000, 0.6)
# create figure and axis
f, ax = plt.subplots()
# get spectograma nd spectogram plot (i.e. STFT)
NFFT = 1024
noverlap = 256
window = np.kaiser(NFFT, 8)
spectogram, freqs, time_array, im = ax.specgram(filtered_data, NFFT=NFFT,
Fs=sample_rate, noverlap=noverlap,
window=window, cmap = 'Greys')
ax.set_xlim(0, len(wav_data)/float(sample_rate)) # remove empty plot region
ax.set_ylim(0, sample_rate/2.) # remove empty plot region
syllables = find_syllables(spectogram, time_array, db_diff)
segments = join_in_segments(syllables, max_silence)
# add segments to plot as red shadowed areas
hspans = []
for segment in segments:
hspans.append(ax.axvspan(segment[0], segment[1], facecolor='r', alpha = 0.2))
return segments, f, ax
def gen_map(vals, n=nbins, hue=False): # saturation fvals = vals.flatten() yh, xh, patches = plt.hist(fvals, bins=n, range=(0,1), normed=False , cumulative=False , histtype='step') if hue: # apply window M = 9 win = np.kaiser(M, 3.0) yh = np.insert(yh, 0, np.zeros(M/2)) yh = np.append(yh, np.zeros(M/2)) yh = rolling_window(yh.T, M) yh = np.dot(yh, win) yh /= sum(yh) if hue: # adapted norm #yh = np.minimum(yh, hcut) yh[yh<=hcut] = 0 yh /= sum(yh) yh = np.cumsum(yh) xhi = np.linspace(0,1,256) yhi = np.interp(xhi, yh, xh[1:]) yhinv = np.interp(xhi, xh[1:], yh) #plt.plot(xhi, yhi) return (yhi, yhinv)
def smooth_curve(x):
"""손실함수의 그래프를 매끄럽게 하기 위해서 사용한다"""
window_len = 11
s = np.r_[x[window_len - 1:0:-1], x, x[-1:-window_len:-1]]
w = np.kaiser(window_len, 2)
y = np.convolve(w / w.sum(), s, mode='valid')
return y[5:len(y) - 5]
def lowpass(cutout, delta_w, atten):
beta = 0
if atten > 50:
beta = 0.1102 * (atten - 8.7)
elif atten < 21:
beta = 0
else:
beta = 0.5842 * (atten - 21)**0.4 + 0.07886 * (atten - 21)
length = math.ceil((atten - 8) / (2.285 * delta_w * math.pi)) + 1
if length % 2 == 0:
length += 1
coeffs = np.kaiser(length, beta)
for i, n in enumerate(
range(int(-(length - 1) / 2),
int((length - 1) / 2) + 1)):
if n == 0:
coeffs[i] *= cutout
else:
coeffs[i] *= math.sin(n * math.pi * cutout) / (n * math.pi)
return coeffs
def SINAD(self,
samples,
sample_rate,
test_tone_frequency=1000,
freq_range_min=50,
freq_range_max=15000,
psophometric_weighting=False):
'''Return SINAD (signal to noise and distortion) in dB of real-valued sinusoidal signal.
Arguments:
samples... a numpy array of input audio samples. This needs at least a few k of samples to ensure the accuracy.
sample_rate... sampling frequency in Hz
test_tone_frequency... frequency of the tone (default: 1000)
freq_range_min... high pass filter cutoff in Hz (default: 50, same as HP8920)
freq_range_max... low pass filter cutoff in Hz (default: 15000, same as HP8920)
psophometric_weighting... apply psophometric weighting if True (default: False)
'''
# Ensure input is an array of floats
samples = np.array(samples, np.float)
n_samples = len(samples)
samples_w = samples * np.kaiser(n_samples, beta=16.0)
notch_width = 0.1 # notch width depends on the kaiser Beta coefficient
# Zero pad to adjust the size to the next power of two
n_fft = int(2**np.ceil(np.log2(n_samples)))
samples_w = np.concatenate((samples_w, np.zeros(n_fft - n_samples)))
# Go to frequency domain
samples_fft = np.fft.rfft(samples_w)
# Apply the band pass filter
samples_fft_filt = samples_fft
hpf_bin = int(n_fft * float(freq_range_min) / sample_rate)
samples_fft_filt[:hpf_bin] = 1e-99
lpf_bin = int(n_fft * float(freq_range_max) / sample_rate)
samples_fft_filt[lpf_bin:] = 1e-99
# Apply the psophometric weighting
if psophometric_weighting:
samples_fft_filt = self.apply_psophometric_weighting(
samples_fft_filt, sample_rate)
# Transform the filtered signal + noise back to time domain and measure the power
samples_filt = np.fft.irfft(samples_fft_filt)
signal_plus_noise_power = np.mean(np.absolute(samples_filt)**2)
# Notch out the test tone
notch_low_bin = int(n_fft * (1.0 - 0.5 * notch_width) *
test_tone_frequency / sample_rate)
notch_high_bin = int(n_fft * (1.0 + 0.5 * notch_width) *
test_tone_frequency / sample_rate)
samples_fft_filt[notch_low_bin:notch_high_bin] = 1e-99
# Transform the left over noise (+ distortion) back to time domain and measure the power
noise_filt = np.fft.irfft(samples_fft_filt)
noise_power = np.mean(np.absolute(noise_filt)**2)
# Return the SINAD in dB
return 10 * np.log10(signal_plus_noise_power / noise_power)
def smooth(x, beta, window_len=11):
""" kaiser window smoothing """
# extending the data at beginning and at the end
# to apply the window at the borders
s = numpy.r_[x[window_len - 1 : 0 : -1], x, x[-1:-window_len:-1]]
w = numpy.kaiser(window_len, beta)
y = numpy.convolve(w / w.sum(), s, mode="valid")
return y[(window_len / 2) : -(window_len / 2)]
def __init__(self,freq,N_samples):
QtGui.QMainWindow.__init__(self)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.createQtConnections()
self.sample_rate = 2.4e5 ###1e6
#self.decim_r1 = 1e6/2e5 # for wideband fm
self.decim_r2 = 2.4e5/48000 # for baseband recovery
self.center_freq = freq #+250e3
self.gain = 38
self.N_samples = N_samples
self.is_sampling = False
self.spectrogram = np.zeros((328,200))
self.chspectrogram = np.zeros((328,200))
self.plspectrogram = np.zeros((164,200))
self.sdr = RtlSdr()
#self.sdr.direct_sampling = 1
self.sdr.sample_rate = self.sample_rate
self.sdr.center_freq = self.center_freq
self.sdr.gain = self.gain
self.pa = pyaudio.PyAudio()
self.stream = self.pa.open( format = pyaudio.paFloat32,
channels = 2,
rate = 48000,
output = True)
adj = 0
hamming = np.kaiser(self.N_samples/4 + adj,1)
lpf = np.append( np.zeros(self.N_samples*3/8),hamming)
self.lpf = np.fft.fftshift(np.append(lpf,np.zeros(self.N_samples*3/8))) #,int(-.25*self.N_samples))
hamming = 10*signal.hamming(self.N_samples/16)
lpf = np.append(np.zeros(self.N_samples*15/32),hamming)
self.lpf_s1 = (np.append(lpf,np.zeros(int(self.N_samples*15/32))))
#self.lpf_s1 = np.roll(temp,int(.5*self.N_samples*67/120))
#self.lpf_s1 += np.roll(temp,int(-.5*self.N_samples*67/120))
self.lpf_s1 = np.fft.fftshift(self.lpf_s1)
#self.lpf_s1 += np.fft.fftshift(self.lpf_s1)
# fig = plt.figure()
# ax = fig.add_subplot(111)
# ax.plot(range(self.lpf_s1.size),self.lpf_s1)
# fig.show()
hamming = 10*signal.hamming(self.N_samples/32)
lpf = np.append(np.zeros(self.N_samples*31/64),hamming)
self.lpf_s2 = (np.append(lpf,np.zeros(int(self.N_samples*31/64))))
#self.lpf_s2 = np.roll(temp,int(.5*self.N_samples*92/120))
#self.lpf_s2 += np.roll(temp,int(-.5*self.N_samples*92/120))
self.lpf_s2 = np.fft.fftshift(self.lpf_s2)
def smooth(x,beta, window_len): """ kaiser window smoothing """ # extending the data at beginning and at the end # to apply the window at the borders s = numpy.r_[x[window_len-1:0:-1], x, x[-2:-window_len-1:-1]] w = numpy.kaiser(window_len,beta) y = numpy.convolve(w/w.sum(), s, mode='valid') offset = window_len/2 return y[offset:len(y)-offset]
def fft(data, sample_rate=1, window=lambda x:np.kaiser(x,2)):
if window:
w = window(len(data))
data = [data[i]*w[i] for i in xrange(len(w))]
fs = 1/float(sample_rate)
y = map(abs,np.fft.rfft(data))
fstep = fs/len(y)
#return (y,[fstep*i for i in xrange(0,len(y))])
return y
def smooth(x,beta): """ kaiser window smoothing """ window_len=11 # extending the data at beginning and at the end # to apply the window at the borders s = np.r_[x[window_len-1:0:-1],x,x[-1:-window_len:-1]] w = np.kaiser(window_len,beta) y = np.convolve(w/w.sum(),s,mode='valid') return y[5:len(y)-5]
def smoothWKaiserWindow(self):
"""
kaiser window smoothing
"""
# extending the data at beginning and at the end in oder to apply the window at the borders
s = np.r_[self.flux[self.windowSizeInBin-1:0:-1], self.flux, self.flux[-1:-self.windowSizeInBin:-1]]
w = np.kaiser(self.windowSizeInBin, self.beta)
y = np.convolve(w/w.sum(), s, mode='valid')
return y[(self.windowSizeInBin-1)/2:len(y) - (self.windowSizeInBin-1)/2]
def smooth(x,beta): """ Smooths a spectrum *x* using a Kaiser-Bessel smoothing window of narrowness *beta* (~1 => very smooth, ~100 => not smooth) """ window_len = 11 s = np.r_[x[window_len-1:0:-1], x, x[-1:-window_len:-1]] w = np.kaiser(window_len,beta) y = np.convolve(w/w.sum(), s, mode='valid') return y[5:len(y)-5]*(x.unit if hasattr(x, 'unit') else 1)
def smooth_curve(x):
"""손실 함수의 그래프를 매끄럽게 하기 위해 사용
참고：http://glowingpython.blogspot.jp/2012/02/convolution-with-numpy.html
"""
window_len = 11
s = np.r_[x[window_len-1:0:-1], x, x[-1:-window_len:-1]]
w = np.kaiser(window_len, 2)
y = np.convolve(w/w.sum(), s, mode='valid')
return y[5:len(y)-5]
def build_window(size, shape, method='numpy'):
if method == 'numpy':
return np.kaiser(size, shape)
else:
N = size - 1
n = np.arange(0, size)
K = (2 * n * (1/N)) - 1
A = np.sqrt(1 - (K*K))
win = zeroeth_order_bessel(shape*A) * (1/zeroeth_order_bessel(shape))
return win
def fid_to_spec(self, window_f = ' ', beta = 2, t_start = 0., t_end = 100.0):
'''
FFT with zero-padding of the FID.
Saves the result in self.spec
Parameters
----------
window_f: is the applied window function. The following window functions are
applicable: hanning, hamming, blackman, bartlett, kaiser (beta (float) is only used
by the kaiser window)
t_start (float): specifies the beginning of the FID. The corresponding data points
will be cut away.
t_end (float): specifies the end of the FID. The corresponding data points
will be cut away.
Returns
-------
none
Notes
-----
none
'''
if len(self.fid) != 0:
fid = slice_fid(self.fid, t_start, t_end)
window_f = window_f.lower() # Choose the window function (default: rect / none)
if window_f == 'hanning':
fid[:,1] = fid[:,1] * np.hanning(len(fid))
elif window_f == 'hamming':
fid[:,1] = fid[:,1] * np.hamming(len(fid))
elif window_f == 'blackman':
fid[:,1] = fid[:,1] * np.blackman(len(fid))
elif window_f == 'bartlett':
fid[:,1] = fid[:,1] * np.bartlett(len(fid))
elif window_f == 'kaiser':
fid[:,1] = fid[:,1] * np.kaiser(len(fid), beta)
h = (int(np.sqrt(len(fid))) + 1) ** 2 # Zero padding to n**2 length to enhance computing speed
spec = np.absolute(np.fft.rfft(fid[:,1], h)) ** 2 / h
spec = spec[0:int(h/2)]
freq = np.fft.fftfreq(h, np.abs(fid[2,0] - fid[1,0])) / 1.E6
freq = freq[0:int(h/2)] # Combine FFT and frequencies
self.spec = np.column_stack([freq, spec])
self.spec_params['npoints'] = len(spec)
self.spec_params['max_f'] = np.max(freq)
self.spec_params['min_f'] = np.min(freq)
self.spec_params['delta_f'] = np.abs(freq[1]-freq[0])