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