def test_default_level():
# default level is the maximum permissible for the transformed axes
data = np.ones((128, 32, 4))
wavelet = ('db8', 'db1')
for dec_func in [pywt.wavedec2, pywt.wavedecn]:
for axes in [(0, 1), (2, 1), (0, 2)]:
c = dec_func(data, wavelet, axes=axes)
max_lev = np.min([pywt.dwt_max_level(data.shape[ax], wav)
for ax, wav in zip(axes, wavelet)])
assert_equal(len(c[1:]), max_lev)
for ax in [0, 1]:
c = pywt.wavedecn(data, wavelet[ax], axes=(ax, ))
assert_equal(len(c[1:]),
pywt.dwt_max_level(data.shape[ax], wavelet[ax]))
def my_waverec(data, wavelet, mode='sym', level=None):
"""
Multilevel 1D Discrete Wavelet Transform of data.
Returns coefficients list - [cAn, cDn, cDn-1, ..., cD2, cD1]
data - input data
wavelet - wavelet to use (Wavelet object or name string)
mode - signal extension mode, see MODES
level - decomposition level. If level is None then it will be
calculated using `dwt_max_level` function.
"""
if not isinstance(wavelet, pywt.Wavelet):
wavelet = pywt.Wavelet(wavelet)
if level is None:
level = pywt.dwt_max_level(len(data), wavelet.dec_len)
elif level < 0:
raise ValueError("Level value of %d is too low . Minimum level is 0." % level)
a = data[0:2]
d = data[2:4]
for i in xrange(int(level)):
offs = pow(2,i+2)
a = pywt.idwt(a, d, wavelet, mode)
d = data[offs:2*offs]
return a
def test_wavedecn_coeff_reshape_even():
# verify round trip is correct:
# wavedecn - >coeffs_to_array-> array_to_coeffs -> waverecn
# This is done for wavedec{1, 2, n}
rng = np.random.RandomState(1234)
params = {'wavedec': {'d': 1, 'dec': pywt.wavedec, 'rec': pywt.waverec},
'wavedec2': {'d': 2, 'dec': pywt.wavedec2, 'rec': pywt.waverec2},
'wavedecn': {'d': 3, 'dec': pywt.wavedecn, 'rec': pywt.waverecn}}
N = 28
for f in params:
x1 = rng.randn(*([N] * params[f]['d']))
for mode in pywt.Modes.modes:
for wave in wavelist:
w = pywt.Wavelet(wave)
maxlevel = pywt.dwt_max_level(np.min(x1.shape), w.dec_len)
if maxlevel == 0:
continue
coeffs = params[f]['dec'](x1, w, mode=mode)
coeff_arr, coeff_slices = pywt.coeffs_to_array(coeffs)
coeffs2 = pywt.array_to_coeffs(coeff_arr, coeff_slices,
output_format=f)
x1r = params[f]['rec'](coeffs2, w, mode=mode)
assert_allclose(x1, x1r, rtol=1e-4, atol=1e-4)
def my_wavedec(data, wavelet, mode='sym', level=None):
"""
Multilevel 1D Discrete Wavelet Transform of data.
Returns coefficients list - [cAn, cDn, cDn-1, ..., cD2, cD1]
data - input data
wavelet - wavelet to use (Wavelet object or name string)
mode - signal extension mode, see MODES
level - decomposition level. If level is None then it will be
calculated using `dwt_max_level` function.
"""
if not isinstance(wavelet, pywt.Wavelet):
wavelet = pywt.Wavelet(wavelet)
if level is None:
level = pywt.dwt_max_level(len(data), wavelet.dec_len)
elif level < 0:
raise ValueError("Level value of %d is too low . Minimum level is 0." % level)
coeffs_list = []
a = data
for i in xrange(level):
a, d = pywt.dwt(a, wavelet, mode)
d = list(d)
#d.reverse()
coeffs_list.append(d)
a = list(a)
#a.reverse()
coeffs_list.append(a)
#coeffs_list.reverse()
return coeffs_list
def wp(S, costf, wavelet="db4", mode=pywt.MODES.ppd, level=None):
'''
Returns the 1D discrete wavelet packet transformation, with the best basis according
to the given cost function, for the given 1D input signal.
@param S: Input signal.
Both single and double precision floating-point data types are supported
and the output type depends on the input type. If the input data is not
in one of these types it will be converted to the default double precision
data format before performing computations.
@param costf: The (single parameter) cost function that must be used while
searching for the best basis.
@param wavelet: Wavelet to use in the transform.
This must be a name of the wavelet from the wavelist() list.
@param mode: Signal extension mode to deal with the border distortion problem.
The default mode is periodic-padding.
@param level: Number of decomposition steps to perform. If the level is None, then the
full decomposition up to the level computed with dwt_max_level() function for
the given data and wavelet lengths is performed.
@return: A list containing the nodes of the 1D discrete wavelet packet transformation,
with the best basis according to the given cost function, for the given input signal.
'''
if (level == None):
level = pywt.dwt_max_level(S.shape[0], pywt.Wavelet(wavelet))
#Data collection step
Nodes = collect(S, wavelet=wavelet, mode=mode, level=level)
#Dynamic programming upstream traversal
mark(Nodes, costf)
#node.print_nodes(Nodes)
#Dynamic programming downstream traversal
Result = []
traverse(Nodes[0][0], Nodes, Result)
traverse(Nodes[0][1], Nodes, Result)
return sorted(Result, cmp=node.compare_low_level_first, reverse=False)
def filterData(self, icurr, Fs): """ Denoise an ionic current time-series and store it in self.eventData :Parameters: - `icurr` : ionic current in pA - `Fs` : original sampling frequency in Hz """ # self.eventData=icurr self.Fs=Fs # Set up the wavelet w=pywt.Wavelet(self.waveletType) # Calculate the maximum wavelet level for the data length self.maxWaveletLevel=pywt.dwt_max_level(len(icurr), filter_len=w.dec_len) # Perform a wavelet decomposition to the specified level wcoeff = pywt.wavedec(icurr, w, mode='sym', level=self.waveletLevel) # Perform a simple threshold by setting all the detailed coefficients # up to level n-1 to zero thresh=np.std(wcoeff[-1])*self._thselect(wcoeff, self.waveletThresholdSubType) thrfunc=self.thrtypedict[self.waveletThresholdType] # print thresh, np.std(wcoeff[-1]) wcoeff[1:] = [ thrfunc(wc, thresh) for wc in wcoeff[1:] ] # for i in range(1, self.waveletLevel): # wcoeff[-i]=np.zeros(len(wcoeff[-i])) # Reconstruct the signal with the thresholded wavelet coefficients self.eventData = pywt.waverec(wcoeff, self.waveletType, mode='sym')
def c_dists(Y,use_swt=True,level_weights=False):
w = pywt.Wavelet('sym2')
if use_swt:
L = pywt.swt_max_level(Y.shape[0])
C = [pywt.swt(Y[:,i],w,level=L) for i in range(Y.shape[1])]
C = [[list(reshape(l[0],-1)) + list(reshape(l[1],-1)) for l in c] for c in C]
else:
L = pywt.dwt_max_level(Y.shape[0],w)
C = [pywt.wavedec(Y[:,i],w,level=L) for i in range(Y.shape[1])]
if level_weights:
if use_swt:
raise NameError('No level weights with SWT')
Wc = [1. for x in range(1,L+1)]
D = zeros((len(C),len(C)))
for i in range(len(C)):
for j in range(i+1,len(C)):
d = sum([distance.cosine(C[i][x],C[j][x])*Wc[x] for x in range(L)])/sum(Wc)
D[i,j] = d
D[j,i] = d
return D
else:
Cn = []
for c in C:
cn = []
for l in c:
cn += list(l)
Cn.append(cn)
return abs(pdist(Cn,'cosine'))
def test_wavelet_denoising_levels():
rstate = np.random.RandomState(1234)
ndim = 2
N = 256
wavelet = 'db1'
# Generate a very simple test image
img = 0.2*np.ones((N, )*ndim)
img[[slice(5, 13), ] * ndim] = 0.8
sigma = 0.1
noisy = img + sigma * rstate.randn(*(img.shape))
noisy = np.clip(noisy, 0, 1)
denoised = restoration.denoise_wavelet(noisy, wavelet=wavelet)
denoised_1 = restoration.denoise_wavelet(noisy, wavelet=wavelet,
wavelet_levels=1)
psnr_noisy = compare_psnr(img, noisy)
psnr_denoised = compare_psnr(img, denoised)
psnr_denoised_1 = compare_psnr(img, denoised_1)
# multi-level case should outperform single level case
assert_(psnr_denoised > psnr_denoised_1 > psnr_noisy)
# invalid number of wavelet levels results in a ValueError
max_level = pywt.dwt_max_level(np.min(img.shape),
pywt.Wavelet(wavelet).dec_len)
assert_raises(ValueError, restoration.denoise_wavelet, noisy,
wavelet=wavelet, wavelet_levels=max_level+1)
assert_raises(ValueError, restoration.denoise_wavelet, noisy,
wavelet=wavelet, wavelet_levels=-1)
def wavelet_trans(l, keep_proportion = 0.5):
#TODO binning per decomposition level?
#TODO explain why db4
if not (l is None or l == []):
coeffs = pywt.wavedec(l, 'db4', level=pywt.dwt_max_level(len(l),pywt.Wavelet('db4')))
return merge(*coeffs[0:int(len(coeffs)*keep_proportion)])
else:
return l
def full_coeff_len(datalen, filtlen, mode):
max_level = wt.dwt_max_level(datalen, filtlen)
total_len = 0
for i in xrange(max_level):
datalen = wt.dwt_coeff_len(datalen, filtlen, mode)
total_len += datalen
return total_len + datalen
def test_wavedec():
x = [3, 7, 1, 1, -2, 5, 4, 6]
db1 = pywt.Wavelet('db1')
cA3, cD3, cD2, cD1 = pywt.wavedec(x, db1)
assert_almost_equal(cA3, [8.83883476])
assert_almost_equal(cD3, [-0.35355339])
assert_allclose(cD2, [4., -3.5])
assert_allclose(cD1, [-2.82842712, 0, -4.94974747, -1.41421356])
assert_(pywt.dwt_max_level(len(x), db1) == 3)
def wavelet_levels(Y):
w = pywt.Wavelet('sym2')
levels = pywt.dwt_max_level(Y.shape[0],w)
w0 = pywt.wavedec(Y[:,0],w,level=levels)[1:]
L = [np.empty((Y.shape[1],len(x))) for x in w0]
for i in range(Y.shape[1]):
wd = pywt.wavedec(Y[:,i],w)[1:]
for j,x in enumerate(wd):
L[j][i,:] = x
return L,[Y.shape[0]/len(x) for x in w0]
def startup():
global w, N, L0, mode, level
print pywt.families()
print pywt.wavelist('db')
w = pywt.Wavelet('db6')
mode = pywt.MODES.per
print w
print "vanishing_moments_psi:", w.vanishing_moments_psi
print "vanishing_moments_phi:", w.vanishing_moments_phi
N = 2**9
print "max level = ", pywt.dwt_max_level(N, w.dec_len)
L0 = numpy.zeros((N,N), 'double')
if True:
for i in xrange(0,N):
L0[i][i-1], L0[i][i], L0[i-1][i] = (1., -2., 1.)
else:
for i in xrange(1,N):
L0[i][i-1], L0[i][i], L0[i-1][i] = (1., -2., 1.)
L0[0][0] = -2.
#L0[0][N-1], L0[0][0], L0[N-1][0] = (1, -2, 1)
#L0 = numpy.eye(N)
#for i in xrange(0,N):
#L0[i] = [1,2,3,4,5,6,7,8]
numpy.core.arrayprint.set_printoptions(threshold=N*N+1, linewidth=100000)
#print L0
#coeffs = pywt.wavedec2(L0, w) #, level=pywt.dwt_max_level(N, w.dec_len))
#print coeffs
#print pywt.waverec2(coeffs, w)
#
#coeffs = pywt.wavedec2(L0, w) #, level=pywt.dwt_max_level(N, w.dec_len))
#print coeffs
print "max level = ", pywt.dwt_max_level(N, w.dec_len)
def haar_decomp(img_file_name):
img = Image.open(img_file_name).convert('L')
x,y = img.size
coeffs = pywt.wavedec2(img, 'haar', level=pywt.dwt_max_level(max(x,y), pywt.Wavelet('haar')))
params = coeffs[0]
final_arr = []
for i in xrange(1,len(coeffs)):
for j in coeffs[i]:
final_arr = np.concatenate((final_arr, np.ndarray.flatten(j)))
return params, coeffs[1:], final_arr
def wavelet_avg(Y,X=None,reshape=False,plot_xy=False,zero_thresh=1*10**-7,Names=None,Title=None):
if not X:
X = range(Y.shape[0])
w = pywt.Wavelet('sym2')
L = pywt.dwt_max_level(Y.shape[0],w)
#L = pywt.swt_max_level(Y.shape[0])
Zavg = zeros((L,len(X)))
Zavgabs = zeros((L,len(X)))
if reshape:
e = [0,L,0,L]
else:
e = [X[0],X[-1],0,L]
sp = 1
if not Names:
Names = ["Series "+str(y+1) for y in range(Y.shape[1])]
if Title:
pylab.suptitle(Title)
if plot_xy:
tp = str(Y.shape[1]+3)
pylab.subplot(int(''.join([tp,'1',str(sp)])))
P = pylab.plot(X,Y)
pylab.legend(P,Names,prop={'size':6})
pylab.xlim([0,Y.shape[0]-1])
pylab.title("Relative Abundance Time Series")
sp += 1
else:
tp = str(Y.shape[1]+2)
for y in range(Y.shape[1]):
C = pywt.wavedec(Y[:,y],w,level=L)
#C = pywt.swt(Y[:,y],w,level=L)
#C = ['dummy'] + [c[1] for c in C]
Z = wavelet_matrix(C,L,len(X))
pylab.subplot(int(''.join([tp,'1',str(sp)])))
pylab.imshow(abs(Z),extent=e)
pylab.title(Names[y])
sp += 1
Zavg += Z
Zavgabs += abs(Z)
Zavg /= Y.shape[1]
Zavg[Zavg<zero_thresh] = 0
pylab.subplot(int(''.join([tp,'1',str(sp)])))
pylab.imshow(abs(Zavg),extent=e)
pylab.title("Decomposition Avg")
sp += 1
Zavgabs /= Y.shape[1]
Zavgabs[Zavgabs<zero_thresh] = 0
pylab.subplot(int(''.join([tp,'1',str(sp)])))
pylab.imshow(abs(Zavgabs),extent=e)
pylab.title("abs(Decomposition) Sum")
sp += 1
pylab.show()
return Zavg
def test_compare_downcoef_coeffs():
rstate = np.random.RandomState(1234)
r = rstate.randn(16)
# compare downcoef against wavedec outputs
for nlevels in [1, 2, 3]:
for wavelet in pywt.wavelist():
wavelet = pywt.Wavelet(wavelet)
max_level = pywt.dwt_max_level(r.size, wavelet.dec_len)
if nlevels <= max_level:
a = pywt.downcoef('a', r, wavelet, level=nlevels)
d = pywt.downcoef('d', r, wavelet, level=nlevels)
coeffs = pywt.wavedec(r, wavelet, level=nlevels)
assert_allclose(a, coeffs[0])
assert_allclose(d, coeffs[1])
def test_dwt_max_level():
assert_(pywt.dwt_max_level(16, 2) == 4)
assert_(pywt.dwt_max_level(16, 8) == 1)
assert_(pywt.dwt_max_level(16, 9) == 1)
assert_(pywt.dwt_max_level(16, 10) == 0)
assert_(pywt.dwt_max_level(16, np.int8(10)) == 0)
assert_(pywt.dwt_max_level(16, 10.) == 0)
assert_(pywt.dwt_max_level(16, 18) == 0)
# accepts discrete Wavelet object or string as well
assert_(pywt.dwt_max_level(32, pywt.Wavelet('sym5')) == 1)
assert_(pywt.dwt_max_level(32, 'sym5') == 1)
# string input that is not a discrete wavelet
assert_raises(ValueError, pywt.dwt_max_level, 16, 'mexh')
# filter_len must be an integer >= 2
assert_raises(ValueError, pywt.dwt_max_level, 16, 1)
assert_raises(ValueError, pywt.dwt_max_level, 16, -1)
assert_raises(ValueError, pywt.dwt_max_level, 16, 3.3)
def wavelet_filter(data, thresh, scale, dyadmin):
ndat = np.size(data)
# Use the Coiflet 3 wavelet (18 data points)
wavelet = pywt.Wavelet('coif3')
#per - periodization - is like periodic-padding but gives the smallest possible number
#of decomposition coefficients. IDWT must be performed with the same mode.
mode = 'per'
# dwt_max_level() == floor( log(data_len/(filter_len-1)) / log(2) )
max_level = pywt.dwt_max_level(data_len=len(data), filter_len=wavelet.dec_len)
# Perform the DWT using the the full decomposition up to the level computed
# with dwt_max_level() function for the given data and wavelet lengths.
coeff = pywt.wavedec(data, wavelet, mode, level=max_level)
# Use max line width as criterion for removing wavelet
# coefficients with features on smaller scales
width = np.where(thresh > 2, thresh, 2) # this is in points
# find next power of 2
pow2 = 0
while width > 2**pow2: pow2 = pow2 + 1
# figure out which indices in the wavelet array to zero
dyadmin = int(np.log(ndat)/np.log(2)) - dyadmin # Hard set min
dyadlw = int(np.log(ndat)/np.log(2)) - pow2 - scale # LW multiplier set
windex = np.where(dyadlw < dyadmin, dyadlw, dyadmin)
# based on coarsest value for the given mother wavelet, get min set of coeffs
minwindex = int(thresh)
windex = np.where(windex > minwindex, windex, minwindex)
# Calculate the number of coefficients that need to be zeroed (windex)
windex = int(np.log2(len(data))) - windex
# Zero the last 'windex' coefficents where windex is the number of zeroed coefficients
ncoeff = len(coeff)
for i in range(ncoeff - windex, ncoeff):
coeff[i] = 0.0 * np.array(coeff[i])
res = pywt.waverec(coeff, wavelet, mode)
return res
def test_wavelet_denoising_levels():
rstate = np.random.RandomState(1234)
ndim = 2
N = 256
wavelet = 'db1'
# Generate a very simple test image
img = 0.2*np.ones((N, )*ndim)
img[(slice(5, 13), ) * ndim] = 0.8
sigma = 0.1
noisy = img + sigma * rstate.randn(*(img.shape))
noisy = np.clip(noisy, 0, 1)
with expected_warnings([PYWAVELET_ND_INDEXING_WARNING]):
denoised = restoration.denoise_wavelet(noisy, wavelet=wavelet)
denoised_1 = restoration.denoise_wavelet(noisy, wavelet=wavelet,
wavelet_levels=1)
psnr_noisy = compare_psnr(img, noisy)
psnr_denoised = compare_psnr(img, denoised)
psnr_denoised_1 = compare_psnr(img, denoised_1)
# multi-level case should outperform single level case
assert_(psnr_denoised > psnr_denoised_1 > psnr_noisy)
# invalid number of wavelet levels results in a ValueError or UserWarning
max_level = pywt.dwt_max_level(np.min(img.shape),
pywt.Wavelet(wavelet).dec_len)
if Version(pywt.__version__) < '1.0.0':
# exceeding max_level raises a ValueError in PyWavelets 0.4-0.5.2
with testing.raises(ValueError):
with expected_warnings([PYWAVELET_ND_INDEXING_WARNING]):
restoration.denoise_wavelet(
noisy, wavelet=wavelet, wavelet_levels=max_level + 1)
else:
# exceeding max_level raises a UserWarning in PyWavelets >= 1.0.0
with expected_warnings([
'all coefficients will experience boundary effects']):
restoration.denoise_wavelet(
noisy, wavelet=wavelet, wavelet_levels=max_level + 1)
with testing.raises(ValueError):
with expected_warnings([PYWAVELET_ND_INDEXING_WARNING]):
restoration.denoise_wavelet(
noisy,
wavelet=wavelet, wavelet_levels=-1)
def wavedec(data, wavelet, mode='sym', level=None): if level is None: level = dwt_max_level(len(data), wavelet.dec_len) elif level < 0: raise ValueError( "Level value of %d is too low . Minimum level is 0." % level) coeffs_list = [] a = data for i in xrange(level): a, d = dwt(a, wavelet, mode) coeffs_list.append(d) coeffs_list.append(a) coeffs_list.reverse() return coeffs_list
def dwt_transform(self, crops, wavelet, sfreq):
(n_windows, n_elecs, n_samples_in_window) = crops.shape
max_level = dwt_max_level(data_len=n_samples_in_window,
filter_len=wavelet)
pseudo_freqs = [sfreq / 2**i for i in range(1, max_level)]
# don't take pseudo freqs < 2
pseudo_freqs = [
pseudo_freq for pseudo_freq in pseudo_freqs if pseudo_freq >= 2
]
n_levels = len(pseudo_freqs)
# list of length n_bands of ndarray: x n_epochs x n_channels x
# n_band_coeffs
multi_level_coeffs = wavedec(data=crops,
wavelet=wavelet,
level=n_levels - 1,
axis=2)
# multi_level_coeffs = np.abs(multi_level_coeffs)
return multi_level_coeffs
def __fn(self, x, classes_num):
x_list = [x]
data_len = x.get_shape()[1]
if self.__mode == 'dwt':
wavelet = pywt.Wavelet(self.__hps['wavelet'])
max_level = min(
pywt.dwt_max_level(data_len, wavelet), self.__hps['max_level'])
# c = lambda i, x, x_list: i < max_level
# b = lambda i, x, x_list: [i+1, Net.__dwt(x, wavelet), x_list.append(x)]
# _, x_list = tf.while_loop(c, b, [0, x, x_list])
for _ in range(max_level - 1):
x = Net.__dwt(x, wavelet)
x_list.append(x)
y_list = []
for o in x_list:
y_list.append(self.__resnet(o))
y = tf.concat(y_list, 1)
return tf.layers.dense(y, classes_num)
def compose_vec_from_wvlt(p_wvlt,imshape,wavelet='db4',mode='symmetric'):
#currently limited to square geometry
w=pywt.Wavelet(wavelet)
Nl=pywt.dwt_max_level(max(imshape),w.dec_len)
levlens=[pywt.dwt_coeff_len(max(imshape),w.dec_len,mode=mode)]
for j in range(1,Nl):
levlens.append( pywt.dwt_coeff_len(levlens[-1],w.dec_len,mode=mode) )
levlens.append(levlens[-1])
levlens=levlens[::-1]
Na=sum(levlens)
ret_arr = empty( (Na*Na,),float)
ret_arr[0:levlens[0]**2] = ravel(p_wvlt[0])
celem=levlens[0]**2
for j in range(1,Nl+1):
for k in range(3):
ret_arr[celem:celem+levlens[j]**2]=ravel(p_wvlt[j][k])
celem+=levlens[j]**2
return ret_arr
def compose_vec_from_wvlt(p_wvlt, imshape, wavelet='db4', mode='symmetric'):
#currently limited to square geometry
w = pywt.Wavelet(wavelet)
Nl = pywt.dwt_max_level(max(imshape), w.dec_len)
levlens = [pywt.dwt_coeff_len(max(imshape), w.dec_len, mode=mode)]
for j in range(1, Nl):
levlens.append(pywt.dwt_coeff_len(levlens[-1], w.dec_len, mode=mode))
levlens.append(levlens[-1])
levlens = levlens[::-1]
Na = sum(levlens)
ret_arr = empty((Na * Na, ), float)
ret_arr[0:levlens[0]**2] = ravel(p_wvlt[0])
celem = levlens[0]**2
for j in range(1, Nl + 1):
for k in range(3):
ret_arr[celem:celem + levlens[j]**2] = ravel(p_wvlt[j][k])
celem += levlens[j]**2
return ret_arr
def transformBasis(numNode, para):
if para['transform'] == 'DCT':
transformMatrix = dct(np.eye(numNode), type=3, axis=0, norm='ortho')
transformMatrix = transformMatrix.T # note inverse == transpose
elif 'DWT' in para['transform']:
wt = para['transform'].split('-')[1]
dwtMaxLevel = pywt.dwt_max_level(numNode, filter_len=pywt.Wavelet(wt).dec_len)
eyeMatrix = np.eye(numNode)
transformMatrix = []
for i in xrange(numNode):
coeffs = pywt.wavedec(eyeMatrix[:, i], wt, level=dwtMaxLevel)
transformMatrix.append(np.hstack(coeffs))
transformMatrix = np.vstack(transformMatrix).T
transformMatrix = LA.pinv(transformMatrix)
else:
print 'para[\'transform\'] error!'
sys.exit()
return transformMatrix
def dwt_I_recomp(wt_coeffs, DWT_list, level = 1.):
"""This function computes the inverse disctrete wavelet transform on a union of wavelet basis.
wt_coeff : matrix of decompostion coefficients (approximation and details in two columns).
signal_length = length of the original signal we want retrieve.
DWT_list : list of the used wavelet's name."""
N2 = wt_coeffs[DWT_list[0]].shape[0] #image is supposed to be square
res = np.zeros((N2,N2))
tmp = list(DWT_list)
tmp.remove('I')
DWT_list=tuple(tmp)
for i in DWT_list:
ima_dec = wt_coeffs[i]
level = pywt.dwt_max_level(N2, pywt.Wavelet(i)) ## modif 04-04-17
wt_coeffs_2D = organize_dwt_coeff(ima_dec, level)
ima_rec = pywt.waverec2(wt_coeffs_2D, i, 'per')
res = res + ima_rec
res = res + wt_coeffs['I'] ##
return res
def test_compare_downcoef_coeffs():
rstate = np.random.RandomState(1234)
r = rstate.randn(16)
# compare downcoef against wavedec outputs
for nlevels in [1, 2, 3]:
for wavelet in pywt.wavelist():
if wavelet in ['cmor', 'shan', 'fbsp']:
# skip these CWT families to avoid warnings
continue
wavelet = pywt.DiscreteContinuousWavelet(wavelet)
if isinstance(wavelet, pywt.Wavelet):
max_level = pywt.dwt_max_level(r.size, wavelet.dec_len)
if nlevels <= max_level:
a = pywt.downcoef('a', r, wavelet, level=nlevels)
d = pywt.downcoef('d', r, wavelet, level=nlevels)
coeffs = pywt.wavedec(r, wavelet, level=nlevels)
assert_allclose(a, coeffs[0])
assert_allclose(d, coeffs[1])
def test_compare_downcoef_coeffs():
rstate = np.random.RandomState(1234)
r = rstate.randn(16)
# compare downcoef against wavedec outputs
for nlevels in [1, 2, 3]:
for wavelet in pywt.wavelist():
if wavelet in ['cmor', 'shan', 'fbsp']:
# skip these CWT families to avoid warnings
continue
wavelet = pywt.DiscreteContinuousWavelet(wavelet)
if isinstance(wavelet, pywt.Wavelet):
max_level = pywt.dwt_max_level(r.size, wavelet.dec_len)
if nlevels <= max_level:
a = pywt.downcoef('a', r, wavelet, level=nlevels)
d = pywt.downcoef('d', r, wavelet, level=nlevels)
coeffs = pywt.wavedec(r, wavelet, level=nlevels)
assert_allclose(a, coeffs[0])
assert_allclose(d, coeffs[1])
def wavelet_baseline(intensities, filter_len=4, level=9):
'''Perform wavelet baseline correction.
"Automatic Baseline Correction by Wavelet Transform for Quantitative
Open-Path Fourier Transform Infrared Spectroscopy", Shao & Griffiths 2007
http://staff.ustc.edu.cn/~lshao/papers/paper03.pdf
filter_len : length of the Daubechies wavelet. Must be an even number.
level : number of wavelet decompositions to perform.
'''
mode = 'cpd' # constant padding
w = pywt.Wavelet('db%d' % (filter_len//2))
max_level = pywt.dwt_max_level(len(intensities), w.dec_len)
res = pywt.wavedec(intensities, w, mode, level=min(level, max_level))
res[0][:] = 0 # zero out approximation, keep details
bc = pywt.waverec(res, w, mode)
bc = bc[:len(intensities)] # accounts for off-by-one issues in waverec
baseline = intensities - bc # hack, to make int - bl = bc
return baseline
def do_wavedec(dataset):
w=pywt.Wavelet("db5")
data_length=len(dataset)
print(data_length)
title=["PH","DO(mg/L)","CODmn(mg/L)","NH3-N(mg/L)"]
coeffss=[]
for i in range(1,data_length):
data=dataset[i]
data_length=len(data)
fit_level=pywt.dwt_max_level(data_len=len(data), filter_len=w.dec_len)
coeffs=pywt.wavedec(data,'db5',level=fit_level)
rec_coef(coeffs,w,data_length)
plt.xlabel("second")
plt.ylabel(title[i-1])
plt.savefig("./result/result"+str(i)+".jpg")
plt.close()
coeffss.append(coeffs)
return coeffss
def test_waverecn_coeff_reshape_odd():
# verify round trip is correct:
# wavedecn - >coeffs_to_array-> array_to_coeffs -> waverecn
rng = np.random.RandomState(1234)
x1 = rng.randn(35, 33)
for mode in pywt.Modes.modes:
for wave in ['haar', ]:
w = pywt.Wavelet(wave)
maxlevel = pywt.dwt_max_level(np.min(x1.shape), w.dec_len)
if maxlevel == 0:
continue
coeffs = pywt.wavedecn(x1, w, mode=mode)
coeff_arr, coeff_slices = pywt.coeffs_to_array(coeffs)
coeffs2 = pywt.array_to_coeffs(coeff_arr, coeff_slices)
x1r = pywt.waverecn(coeffs2, w, mode=mode)
# truncate reconstructed values to original shape
x1r = x1r[[slice(s) for s in x1.shape]]
assert_allclose(x1, x1r, rtol=1e-4, atol=1e-4)
def wavelet_baseline(intensities, filter_len=4, level=9):
'''Perform wavelet baseline correction.
"Automatic Baseline Correction by Wavelet Transform for Quantitative
Open-Path Fourier Transform Infrared Spectroscopy", Shao & Griffiths 2007
http://staff.ustc.edu.cn/~lshao/papers/paper03.pdf
filter_len : length of the Daubechies wavelet. Must be an even number.
level : number of wavelet decompositions to perform.
'''
mode = 'constant' # constant padding
w = pywt.Wavelet('db%d' % (filter_len // 2))
max_level = pywt.dwt_max_level(len(intensities), w.dec_len)
res = pywt.wavedec(intensities, w, mode, level=min(level, max_level))
res[0][:] = 0 # zero out approximation, keep details
bc = pywt.waverec(res, w, mode)
bc = bc[:len(intensities)] # accounts for off-by-one issues in waverec
baseline = intensities - bc # hack, to make int - bl = bc
return baseline
def apply_wavelet_reconstruction_denoising(x):
wavelet = 'sym4'
w = pywt.Wavelet(wavelet)
# Get max reconstruction level possible
maxlev = pywt.dwt_max_level(len(x), w.dec_len)
# Calculate coefficients at all levels
coeffs = pywt.wavedec(x, wavelet, level=maxlev)
# Calculate threshold using universal formula
sigma = (1/0.6745) * madev(coeffs[-1])
threshold = sigma * np.sqrt(2 * np.log(len(x)))
threshold = 0.04
for i in range(1, len(coeffs)):
coeffs[i] = pywt.threshold(coeffs[i], threshold * max(coeffs[i]))
return pywt.waverec(coeffs, wavelet)
def multiscale_apply(ys, ):
# print len(ys)
wl = pywt.Wavelet(wavelet_name)
if max_level is None:
level = pywt.dwt_max_level(len(ys), wl)
else:
level = max_level
coeffs_list = []
a = ys
for i in range(level):
a, d = pywt.dwt(a, wavelet=wl)
f = func(approx=a, detail=d)
coeffs_list.append(f)
coeffs_list.append(a)
coeffs_list.reverse()
return coeffs_list
def details_coefficients(signal, level='max', wavelet=DEFAULT_WAVELET):
"""Calculates the details coefficients \\(c_D\\) of the given level
wavelet transform.
Args:
signal (numpy.ndarray): (n_samples, window_size)-dimensional numpy array.
level (int): Level of wavelet transform, defaults to maximum possible.
wavelet (str): Wavelet to use, defaults to haar (db1).
Returns:
numpy.ndarray: Details coefficients as a (n_samples, window_size)-dimensional array.
"""
if level == 'max':
level = pywt.dwt_max_level(signal.shape[1], wavelet)
dwt = pywt.wavedec(signal, wavelet, level=level, axis=1)
return dwt[1]
def test_waverecn_coeff_reshape_odd():
# verify round trip is correct:
# wavedecn - >coeffs_to_array-> array_to_coeffs -> waverecn
rng = np.random.RandomState(1234)
x1 = rng.randn(35, 33)
for mode in pywt.Modes.modes:
for wave in ['haar', ]:
w = pywt.Wavelet(wave)
maxlevel = pywt.dwt_max_level(np.min(x1.shape), w.dec_len)
if maxlevel == 0:
continue
coeffs = pywt.wavedecn(x1, w, mode=mode)
coeff_arr, coeff_slices = pywt.coeffs_to_array(coeffs)
coeffs2 = pywt.array_to_coeffs(coeff_arr, coeff_slices)
x1r = pywt.waverecn(coeffs2, w, mode=mode)
# truncate reconstructed values to original shape
x1r = x1r[[slice(s) for s in x1.shape]]
assert_allclose(x1, x1r, rtol=1e-4, atol=1e-4)
def discrete_wavelet_decomp(X,
f_s,
max_level=6,
plot=False,
signal_name=None,
seizure_time=None,
wavelet_type='db4'):
"""
The function performs discrete wavelet transform on the given signal. The level of decomposition depends on the size of the signal.
and has a maximum of 10.
:param X: raw single channel signal data vector with shape (number of samples, 1)
:param f_s: sampling frequency
:param plot: Boolean value. True if plot signal and scalogram; False otherwise.
:param signal_name: None if a title is not needed for the plot, otherwise put in a string
:return: multilevel DWT coefficients. A list of arrays from the lowest frequency band to the hightest.
Some options: normalize signal? (call normalize); using multiple families of wavelets; level of decomposition.
"""
n = len(X)
# NOTE: wavelet decomposition, wavelet db4 recommended in Subasi's survey on EEG methods
wvlt = pywt.Wavelet(wavelet_type)
# decomposition level should be no more than max_level
if len(X) > 2**max_level:
#print "True!"
coeffs = pywt.wavedec(X, wvlt, level=max_level)
level = max_level
#print level
else:
coeffs = pywt.wavedec(X, wvlt)
level = pywt.dwt_max_level(len(X), wvlt)
print level
coeff_matrix = make_coeff_matrix(coeffs, level, n, f_s)
print "shape of the coefficient matrix", coeff_matrix.shape
if plot == True:
plot_dwt(X, f_s, coeff_matrix, signal_name, seizure_time)
return coeff_matrix
def discardNoise(data):
"""
Discarding sections of the input signal that are noisy
Parameters
----------
data : array_like
1-dimensional array with input signal data
Returns
-------
data : array_like
1-dimensional array with cleaned up signal data
"""
left_limit = 0
right_limit = 200
dataSize = data.size
data = data.tolist()
cleanData = []
while True:
if right_limit > dataSize: window = data[left_limit:]
else: window = data[left_limit:right_limit]
if len(window) < 50:
cleanData += window
break
w = pywt.Wavelet('sym4')
residual = calculate_residuals(np.asarray(window),
levels=pywt.dwt_max_level(
len(window), w))
if residual <= 0.001 and np.std(window) < 1:
cleanData += window
left_limit += 200
right_limit += 200
return np.asarray(cleanData)
def detransform(diciPlanos):
destransformacion = []
for plano in diciPlanos:
n = 31 - plano
if plano == 0:
for bloque in diciPlanos[plano]:
for bit in reversed(range(0, 32)):
temp = ((bloque & (2**bit)) >> bit)
if temp == 1:
# Un truco para almacenar el signo ya que es
# imposible almacenar -0
temp = c_int32(-1)
else:
temp = c_int32(temp << n)
destransformacion.append(temp.value)
else:
cuentaBloque = 0
for bloque in diciPlanos[plano]:
for bit in reversed(range(0, 32)):
temp = ((bloque & (2**bit)) >> bit)
temp = temp << n
if destransformacion[cuentaBloque] >= 0:
destransformacion[cuentaBloque] += temp
else:
destransformacion[cuentaBloque] -= temp
cuentaBloque += 1
# Resto 1 por que hemos almacenado -1 para los negativos
destransformacion = list(map(sumaUnoNegativos, destransformacion))
coeffs = []
stack = 0
w = wt.Wavelet('db1')
values = wt.dwt_max_level(len(destransformacion), w) - ITERACIONESDWT
for x in range(0, ITERACIONESDWT + 1):
trick = ((2**(values)) * (2**x))
coeffs.append(destransformacion[stack:trick])
stack = trick
destransformacion = wt.waverec(coeffs, 'db1')
print(list(map(len, coeffs)))
destransformacion = destransformacion.tolist()
destransformacion = list(map(round, destransformacion))
return destransformacion
def compute_wavelet_feature_vector(image, wavelet='db6'):
image_np = np.array(image)
rgb = [image_np[:, :, i] for i in (0, 1, 2)]
if isinstance(wavelet, basestring):
wavelet = pywt.Wavelet(wavelet)
feature_vector = []
for c in rgb:
level = pywt.dwt_max_level(min(c.shape[0], c.shape[1]), wavelet.dec_len)
levels = pywt.wavedec2(c, wavelet, mode='sym', level=level)
for coeffs in levels:
if not isinstance(coeffs, tuple):
coeffs = (coeffs,)
for w in coeffs:
w_flat = w.flatten()
feature_vector += [float(np.mean(w_flat)), float(np.std(w_flat))]
return feature_vector
def decomposition(data, waveletname, level=None):
epochs = len(data)
chanels = len(data[0])
samples = len(data[0][0])
level = pywt.dwt_max_level(samples, waveletname)
ret = []
for dec_lvl in range(0, level + 1):
size = len(
pywt.wavedec(data[0][0], waveletname, mode=0,
level=level)[dec_lvl])
one_level_dec = np.zeros((epochs, chanels, size))
for epoch in range(0, epochs):
for chanel in range(0, chanels):
one_level_dec[epoch][chanel] = pywt.wavedec(
data[epoch][chanel], waveletname, mode=0,
level=level)[dec_lvl]
#print(type(pywt.wavedec(data[epoch,chanel],waveletname,level)))
ret.append([one_level_dec])
return ret[::-1]
def transform(self,
data: torch.Tensor,
max_level: Optional[int] = None) -> "WaveletPacket":
"""Calculate the 1d wavelet packet transform for the input data.
Args:
data (torch.Tensor): The input data array of shape [time]
or [batch_size, time].
max_level (int, optional): The highest decomposition level to compute.
If None, the maximum level is determined from the input data shape.
Defaults to None.
"""
self.data = {}
if max_level is None:
max_level = pywt.dwt_max_level(data.shape[-1],
self.wavelet.dec_len)
self.max_level = max_level
self._recursive_dwt(data, level=0, path="")
return self
def wavelet_frequency_responses(wavename, levels, Fs=1.0, N=1000):
wl = pywt.Wavelet(wavename)
max_levels = pywt.dwt_max_level(N, wavename)
if levels is None:
levels = max_levels
elif levels > max_levels:
print('Number of wavelet levels should be <= {}'.format(max_levels))
wave = wl.dec_hi #/ np.sqrt(2)
scale = wl.dec_lo #/ np.sqrt(2)
om, h = signal.freqz(wave, worN=2**12)
resps = [h]
for v in range(1, levels):
wave = signal.convolve(upsample(wave, 2), scale) / np.sqrt(2)
scale = signal.convolve(upsample(scale, 2), scale) / np.sqrt(2)
om, h = signal.freqz(wave, worN=2**12)
resps.append(h)
om, h = signal.freqz(scale, worN=2**12)
resps.append(h)
return om * Fs / 2 / np.pi, np.array(resps)
def apply_filter(self, array):
if len(array.shape)!=1:
return False
mlv = pywt.dwt_max_level(array.shape[0],pywt.Wavelet(self.type))
coeffs = pywt.wavedec(array.data, self.type, level=mlv, mode='per')
if self.auto_threshold:
sigma = stand_mad(coeffs[-1])
uthresh = sigma*np.sqrt(2*np.log(len(coeffs)))
self.threshold = uthresh
else:
uthresh = self.threshold
denoised = coeffs[:]
if self.thresholding==0: # Hard thresholding
denoised[1:] = (pywt.thresholding.hard(i, value=uthresh) for i in denoised[1:])
elif self.thresholding==1: # Soft thresholding
denoised[1:] = (pywt.thresholding.soft(i, value=uthresh) for i in denoised[1:])
signal = pywt.waverec(denoised, self.type, mode='per')
array.data = signal[0:array.shape[0]]
return True
def h_measure(single, wavelet_type='db2'):
# 离散小波计算
max_level = pywt.dwt_max_level(len(single), pywt.Wavelet(wavelet_type))
coefficients = pywt.wavedec(single, wavelet_type, level=max_level)
# wavelet energy in different level
energy = np.array(list(map(lambda c: c.dot(c), coefficients)))
# relative wavelet energy
rwe = energy / energy.sum()
# 熵
entropy = -np.multiply(rwe, np.log(rwe))
# Shannon wavelet energy
swe = np.sum(entropy)
swe_max = np.log(max_level+1)
return swe / swe_max
def calc_energyspectrum(data, wave):
'''
data:要进行小波分解的能量数据
w:小波名称
'''
#When we calc the cofficient of the wavelet transfpom it requeie the length must be 2^x，
#so we calc the datelen is 2*log2(T),where T is the length of data
datalen = int(pow(2, np.log2(len(data))))
#print len(data)
#print datalen
w = pywt.Wavelet(wave)
a = data[0:datalen]
#print a
#energy_spectrum=[]
#$ca= [] #
#cd = []#detail cofficient the de wavelet decompress
max_level = pywt.dwt_max_level(len(a), w)
#print max_level
coeffs = pywt.wavedec(data, 'haar', level=max_level)
#print len(coeffs)
coeffs = list(reversed(coeffs))[:-1]
#print "{}}}}}}}}}}}}}}"
#print coeffs
energy_specum = [0] * 16
for i in range(max_level):
energy_specum[i] = sum([dcf * dcf for dcf in coeffs[i]])
#print("=-------------------=====")
#print(energy_specum)
return energy_specum, max_level
#spectrum_a={}
#spectrum_d={}
#spectrum={}
#cofficients = {}
#level = "level_%d"
#for i in range(8):
# (a,d) = pywt.dwt(a,w,mode)
# ca.append(a)
# cd.append(d)
# cofficients[level % i]=(a,d)
#cofficients.append((a,d))
#计算能量谱，密度
'''
def DWT(data, waveName, catChannel=None, level=None):
db = pywt.Wavelet(waveName)
levelMax = pywt.dwt_max_level(len(data[0]), db)
if level == None:
level = levelMax
elif level > levelMax:
level = levelMax
else:
level = level
mwOutput = []
for i in data:
a = pywt.wavedec(i, db, mode='zpd')
mwOutput.append(a)
cat_mWave = []
for i in mwOutput:
temp = arrayListCat(i, level, catChannel)
temp = temp
cat_mWave.append(temp)
return cat_mWave
def wavedec(data, wavelet, mode='sym', level=None):
if level is None:
level = dwt_max_level(len(data), wavelet.dec_len)
elif level < 0:
raise ValueError("Level value of %d is too low . Minimum level is 0." %
level)
coeffs_list = []
a = data
for i in xrange(level):
a, d = dwt(a, wavelet, mode)
coeffs_list.append(d)
coeffs_list.append(a)
coeffs_list.reverse()
return coeffs_list
def test_wavelet_denoising_levels(rescale_sigma):
rstate = np.random.RandomState(1234)
ndim = 2
N = 256
wavelet = 'db1'
# Generate a very simple test image
img = 0.2 * np.ones((N, ) * ndim)
img[(slice(5, 13), ) * ndim] = 0.8
sigma = 0.1
noisy = img + sigma * rstate.randn(*(img.shape))
noisy = np.clip(noisy, 0, 1)
denoised = restoration.denoise_wavelet(noisy,
wavelet=wavelet,
rescale_sigma=rescale_sigma)
denoised_1 = restoration.denoise_wavelet(noisy,
wavelet=wavelet,
wavelet_levels=1,
rescale_sigma=rescale_sigma)
psnr_noisy = peak_signal_noise_ratio(img, noisy)
psnr_denoised = peak_signal_noise_ratio(img, denoised)
psnr_denoised_1 = peak_signal_noise_ratio(img, denoised_1)
# multi-level case should outperform single level case
assert_(psnr_denoised > psnr_denoised_1 > psnr_noisy)
# invalid number of wavelet levels results in a ValueError or UserWarning
max_level = pywt.dwt_max_level(np.min(img.shape),
pywt.Wavelet(wavelet).dec_len)
# exceeding max_level raises a UserWarning in PyWavelets >= 1.0.0
with expected_warnings(
['all coefficients will experience boundary effects']):
restoration.denoise_wavelet(noisy,
wavelet=wavelet,
wavelet_levels=max_level + 1,
rescale_sigma=rescale_sigma)
with testing.raises(ValueError):
restoration.denoise_wavelet(noisy,
wavelet=wavelet,
wavelet_levels=-1,
rescale_sigma=rescale_sigma)
def processFullQueue(self):
threshold = 0.1
volts = []
for i in self.queue.queue:
volts.append(i['volt'])
w = pywt.Wavelet('db8') # 选用Daubechies8小波
maxlev = pywt.dwt_max_level(len(volts), w.dec_len)
# Decompose into wavelet components, to the level selected:
coeffs = pywt.wavedec(volts, 'db8', level=maxlev) # 将信号进行小波分解
for li in coeffs[1:]:
rms_sum = 0
sum = 0
for i in li:
sum += i**2
rms_sum += math.sqrt(sum / len(li))
return rms_sum
def wavelet(data, wlf, threshold): """ wavelet: this function . Arguments: data (numpy array): input data. wlf: wavelet fucntion. threshold: threshold of high pass filter. -------- Returns: filtered data. """ wavelet = pywt.Wavelet(wlf) levels = pywt.dwt_max_level(data.shape[0], wavelet) WaveletCoeffs = pywt.wavedec2(data, wavelet, level=levels) NewWaveletCoeffs = map (lambda x: pywt.threshold(x,threshold,'greater'),WaveletCoeffs) data = pywt.waverec2( NewWaveletCoeffs, wavelet) return data
def farge_denoise(sig, wtname, mode):
# @sig : 1d signal
# @wtname : wavelet name
# @mode: signal extension mode for reconstruction
# bulid wavelet, calculate maxlevel coeffs
w = pywt.Wavelet(wtname)
lev = pywt.dwt_max_level(len(sig), w)
coeffs = pywt.wavedec(sig, w, level=lev)
# total number of wavelet coefficients
N = sum([len(i) for i in coeffs[1:]])
# initial sigma square, eps, Sc, Si
sigma2 = sum([sum([i * i for i in j]) for j in coeffs[1:]]) / N
eps = np.sqrt(2. * np.log(N) * sigma2)
Sc = pywt.wavedec(sig, w, level=lev)
Si = pywt.wavedec(sig, w, level=lev)
for i in range(len(coeffs[0])):
Si[0][i] = 0.
# main loop
Ni_old = -1
Ni = 0
while Ni_old != Ni:
Ni_old = Ni
Nc = 0
Ni = 0
for i in range(1, len(coeffs)):
for j in range(len(coeffs[i])):
isNoise = abs(coeffs[i][j]) <= eps
Ni += int(isNoise)
Nc += int(not isNoise)
Si[i][j] = float(isNoise) * coeffs[i][j]
Sc[i][j] = float(not isNoise) * coeffs[i][j]
sigma2 = sigma2 = sum([sum([i * i for i in j]) for j in Si]) / N
eps = np.sqrt(2. * np.log(N) * sigma2)
#print Ni, Nc, eps
rec = pywt.waverec(Sc, w, mode)
return rec
def prepare(self, object_info, time, flux, flux_err):
wavelet = "sym6"
w = pywt.Wavelet(wavelet)
maxlev = pywt.dwt_max_level(len(flux), w.dec_len)
# maxlev = 2 # Override if desired
print("maximum level is " + str(maxlev))
threshold = 0.2 # Threshold for filtering
clean_flux = flux
# Decompose into wavelet components, to the level selected:
coeffs = pywt.wavedec(clean_flux, wavelet, level=maxlev)
# cA = pywt.threshold(cA, threshold*max(cA))
for i in range(1, len(coeffs)):
coeffs[i] = pywt.threshold(coeffs[i],
threshold * max(coeffs[i]),
mode="soft")
clean_flux = pywt.waverec(coeffs, wavelet)
# TODO ensure clean_flux has the same length and take action if not
clean_flux = clean_flux if len(clean_flux) == len(
time) else clean_flux[0:(len(clean_flux) - 1)]
return time, clean_flux, flux_err
def test_feature_names_wavelet_coef_energy(wavelet_name='db4'):
n_chans = 2 # keep only 2 channels for the sake of simplicity
_data = data[:, :n_chans, :]
selected_funcs = ['wavelet_coef_energy']
# number of coefficients of the DWT
wavelet = pywt.Wavelet(wavelet_name)
levdec = min(pywt.dwt_max_level(_data.shape[-1], wavelet.dec_len), 6)
col_names = [
'ch%s_%s' % (ch, i) for ch in range(n_chans) for i in range(levdec)
]
df = extract_features(
_data,
sfreq,
selected_funcs,
funcs_params={'wavelet_coef_energy__wavelet_name': wavelet_name},
return_as_df=True)
assert_equal(df.columns.get_level_values(1).values, col_names)
def compose_wvlt_from_vec(pin,imshape,wavelet='db4',mode='symmetric'):
#currently limited to square geometry
w=pywt.Wavelet(wavelet)
Nl=pywt.dwt_max_level(max(imshape),w.dec_len)
levlens=[pywt.dwt_coeff_len(max(imshape),w.dec_len,mode=mode)]
for j in range(1,Nl):
levlens.append( pywt.dwt_coeff_len(levlens[-1],w.dec_len,mode=mode) )
levlens.append(levlens[-1])
levlens=levlens[::-1]
p_wvlt=[reshape(array(pin[0:levlens[0]**2],float),(levlens[0],levlens[0]))]
celem=levlens[0]**2
for j in range(1,Nl+1):
t1=reshape(array(pin[celem:celem+levlens[j]**2],float),(levlens[j],levlens[j]))
celem+=levlens[j]**2
t2=reshape(array(pin[celem:celem+levlens[j]**2],float),(levlens[j],levlens[j]))
celem+=levlens[j]**2
t3=reshape(array(pin[celem:celem+levlens[j]**2],float),(levlens[j],levlens[j]))
celem+=levlens[j]**2
p_wvlt.append( (t1,t2,t3) )
return p_wvlt
def get_feature(events, wname='db5'):
wavelet = pywt.Wavelet(wname)
level = pywt.dwt_max_level(len(events[:, 0]), wavelet)
print("DWT by wavelet = '%s' and level = %d\n" % (wname, level))
for k in range(np.size(events, 1)):
coeff = pywt.wavedec(events[:, k], wavelet, level=level)
feature_i = []
for i in range(level + 1):
feature_i = np.append(feature_i, coeff[i])
if k == 0:
feature = feature_i
length = []
for j in range(len(coeff)):
length.append(len(coeff[j]))
else:
feature = np.column_stack((feature, feature_i))
return [feature, length]
def WTfilt_1d(ecg):
data = []
for i in range(len(ecg) - 1):
data.append(float(ecg[i]))
w = pywt.Wavelet('db4') # 选用Daubechies4小波
maxlev = pywt.dwt_max_level(len(data), w.dec_len)
threshold = 0.1 # Threshold for filtering
# Decompose into wavelet components, to the level selected:
coeffs = pywt.wavedec(data, 'db4', level=maxlev) # 将信号进行小波分解
coeffs[6] = pywt.threshold(coeffs[6], threshold * max(coeffs[6])) # 将噪声滤波
for i in range(7, len(coeffs)):
coeffs[i] = np.zeros(len(coeffs[i]))
datarec = pywt.waverec(coeffs, 'db4') # 将信号进行小波重构
mintime = 0
maxtime = mintime + len(data) + 1
return datarec.reshape(fs * 10, 1)
def test_wavedecn_coeff_ravel():
# verify round trip is correct:
# wavedecn - >ravel_coeffs-> unravel_coeffs -> waverecn
# This is done for wavedec{1, 2, n}
rng = np.random.RandomState(1234)
params = {
'wavedec': {
'd': 1,
'dec': pywt.wavedec,
'rec': pywt.waverec
},
'wavedec2': {
'd': 2,
'dec': pywt.wavedec2,
'rec': pywt.waverec2
},
'wavedecn': {
'd': 3,
'dec': pywt.wavedecn,
'rec': pywt.waverecn
}
}
N = 12
for f in params:
x1 = rng.randn(*([N] * params[f]['d']))
for mode in pywt.Modes.modes:
for wave in wavelist:
w = pywt.Wavelet(wave)
maxlevel = pywt.dwt_max_level(np.min(x1.shape), w.dec_len)
if maxlevel == 0:
continue
coeffs = params[f]['dec'](x1, w, mode=mode)
coeff_arr, slices, shapes = pywt.ravel_coeffs(coeffs)
coeffs2 = pywt.unravel_coeffs(coeff_arr,
slices,
shapes,
output_format=f)
x1r = params[f]['rec'](coeffs2, w, mode=mode)
assert_allclose(x1, x1r, rtol=1e-4, atol=1e-4)
def smooth_for_trend(y_values: np.ndarray,
smooth_params: configparser.ConfigParser) -> np.ndarray:
"""
Method that smooth a time series using wavelet transforms. In the configuration file ([file])
the type of wavelet, the number of transforms and the desired length of the results is given
in order to perform the operation.
Remember that if the length of the result is smaller than the desired length, the
computation of the transformations will be halted. Moreover, if the first iteration
already gives a shorter time series an exception will be raised.
An example of configuration is:
```\n
[file]\n
...\n
wavelet=db8 #wavelet type\n
levels=5 #transformation levels\n
data_points=300 #desired length\n
```
:param y_values: y values of the original time series
:param smooth_params: parameters relative to the smoothing
:return: smoothed time series that will be used as trend
"""
wavelet = smooth_params[WAVELET]
levels = pywt.dwt_max_level(y_values.shape[0], wavelet)
data_points = int(smooth_params[DATA_PTS])
# Decompose getting only the details
for _ in range(levels):
y_values = downcoef(part='a', data=y_values, wavelet=wavelet)
for _ in range(levels):
details = np.zeros(y_values.shape)
y_values = pywt.idwt(y_values, details, wavelet=wavelet)
if y_values.shape[0] > data_points:
return y_values[:data_points]
else:
raise ValueError(
'The original time series is to short to perform this operation')
def test_fswavedecn_fswaverecn_variable_wavelets_and_modes():
# test with differing number of transform levels per axis
rstate = np.random.RandomState(0)
ndim = 3
data = rstate.standard_normal((16, )*ndim)
wavelets = ('haar', 'db2', 'sym3')
modes = ('periodic', 'symmetric', 'periodization')
T = pywt.fswavedecn(data, wavelet=wavelets, mode=modes)
for ax in range(ndim):
# expect approx + dwt_max_level detail coeffs along each axis
assert_equal(len(T.coeff_slices[ax]),
pywt.dwt_max_level(data.shape[ax], wavelets[ax])+1)
rec = pywt.fswaverecn(T)
assert_allclose(rec, data, atol=1e-14)
# number of wavelets doesn't match number of axes
assert_raises(ValueError, pywt.fswavedecn, data, wavelets[:2])
# number of modes doesn't match number of axes
assert_raises(ValueError, pywt.fswavedecn, data, wavelets[0], mode=modes[:2])
