def __init__(self, dim=1, wavelet='sym4', mode='per', maxlevel=None): """Initialize _WaveletMapper mapper :Parameters: dim : int or tuple of int dimensions to work across (for now just scalar value, ie 1D transformation) is supported wavelet : basestring one from the families available withing pywt package mode : basestring periodization mode maxlevel : int or None number of levels to use. If None - automatically selected by pywt """ Mapper.__init__(self) self._dim = dim """Dimension to work along""" self._maxlevel = maxlevel """Maximal level of decomposition. None for automatic""" if not wavelet in pywt.wavelist(): raise ValueError, \ "Unknown family of wavelets '%s'. Please use one " \ "available from the list %s" % (wavelet, pywt.wavelist()) self._wavelet = wavelet """Wavelet family to use""" if not mode in pywt.MODES.modes: raise ValueError, \ "Unknown periodization mode '%s'. Please use one " \ "available from the list %s" % (mode, pywt.MODES.modes) self._mode = mode """Periodization mode"""
def __init__(self, dim=1, wavelet='sym4', mode='per', maxlevel=None): """Initialize _WaveletMapper mapper Parameters ---------- dim : int or tuple of int dimensions to work across (for now just scalar value, ie 1D transformation) is supported wavelet : str one from the families available withing pywt package mode : str periodization mode maxlevel : int or None number of levels to use. If None - automatically selected by pywt """ Mapper.__init__(self) self._dim = dim """Dimension to work along""" self._maxlevel = maxlevel """Maximal level of decomposition. None for automatic""" if not wavelet in pywt.wavelist(): raise ValueError("Unknown family of wavelets '%s'. Please use one " \ "available from the list %s" % (wavelet, pywt.wavelist())) self._wavelet = wavelet """Wavelet family to use""" if not mode in pywt.MODES.modes: raise ValueError("Unknown periodization mode '%s'. Please use one " \ "available from the list %s" % (mode, pywt.MODES.modes)) self._mode = mode """Periodization mode"""
def _plot_wavelet_families(all=False): '''Plotting waveletes approximations''' lvl = 4 # because! for name in pywt.families(): if not all: _plot_wavelet(pywt.wavelist(name)[0], lvl) else: for wv in pywt.wavelist(name): _plot_wavelet(wv, lvl, True)
def DWT(self, nsamp, wtype='db', mode='per', level=None): if level != None: self.dwt_coef = pywt.wavedec(self.data[:nsamp], pywt.wavelist(family='db')[1], mode, level) else: self.dwt_coef = pywt.wavedec(self.data[:nsamp], pywt.wavelist(family='db')[1], mode)
def handle(self, *args, **options): substance_names = [ 'Painted', 'Wood', 'Fabric/cloth', 'Tile', 'Metal', 'Carpet/rug', 'Ceramic', 'Leather', 'Food', 'Brick', 'Stone', 'Skin' ] try: os.makedirs('svm') except Exception as e: print e all_samples = ShapeImageSample.objects.filter( shape__substance__name__in=substance_names).order_by('?') train = [] test = [] # split training and testing print 'splitting training/test...' users = all_samples.distinct('shape__photo__flickr_user').values_list( 'shape__photo__flickr_user', flat=True).order_by() for u in progress.bar(users): if len(test) > len(train): train += all_samples.filter(shape__photo__flickr_user_id=u) else: test += all_samples.filter(shape__photo__flickr_user_id=u) print 'train size: %s' % len(train) print 'test size: %s' % len(test) for wavelet in progress.bar( pywt.wavelist('db') + pywt.wavelist('haar')): for training in [True, False]: print 'features for %s (training=%s)...' % (wavelet, training) cur_samples = train if training else test image_paths = [s.image.path for s in cur_samples] p = Pool(32) features = p.map(functools.partial(compute_features, wavelet), image_paths) p.close() with open( 'svm/%s-%s.svm' % (wavelet, 'train' if training else 'test'), 'w') as outfile: for i_s, s in enumerate(cur_samples): class_str = substance_names.index( s.shape.substance.name) feature_str = ' '.join([ '%s:%s' % (i_f + 1, f) for (i_f, f) in enumerate(features[i_s]) ]) print >> outfile, class_str, feature_str
def wavelet_tr(self): wavelet_snr = np.zeros(len(pywt.wavelist(kind='discrete'))) wavelet_types = pywt.wavelist(kind='discrete') for i in range(len(wavelet_types)): [cA, cD] = pywt.dwt(self.signal, wavelet_types[i]) y = pywt.idwt(cA, None, wavelet_types[i]) clt = SNR(norm_clean_sig[self.last:self.next], y) wavelet_snr[i] = clt.signal_to_noise() return wavelet_snr
def test_wavelist(): for name in pywt.wavelist(family="coif"): assert_(name.startswith("coif")) assert_("cgau7" in pywt.wavelist(kind="continuous")) assert_("sym20" in pywt.wavelist(kind="discrete")) assert_( len(pywt.wavelist(kind="continuous")) + len(pywt.wavelist(kind="discrete")) == len(pywt.wavelist(kind="all")) ) assert_raises(ValueError, pywt.wavelist, kind="foobar")
def rbiorthogonal_wavelets_transf(X, parameter1=1, parameter2=1): parameter1, parameter2 = str(parameter1), str(parameter2) pars = [parameter1, parameter2] possible = [pywt.wavelist('rbio')[i][4:].split('.') for i in range(len(pywt.wavelist('rbio')))] pars = pars if pars in possible else ['1', '1'] funct = 'rbio'+'.'.join(pars) funct = funct if funct in pywt.wavelist('rbio') else 'rbio1.1' Xt = np.array([np.concatenate(pywt.dwt(X[:, i], funct)) for i in range(X.shape[1])]) return Xt
def decompose(signal, signal_extension='symmetric', wavelets_family='haar', decompose_level=3): if signal_extension not in SIGNAL_EXTENSIONS: raise SignalExtensionError if wavelets_family not in wavelist(): raise WaveletFamilyError(wavelist()) coefficients = wavedec(data=signal, wavelet=wavelets_family, mode=signal_extension, level=decompose_level) return coefficients
def r_square(matrix_signal, vect_sigma, wavelet_family, ortho='no', significance_level=5): r_sq_values = [] ajusted_r_sq_values = [] wavelet_indexes = [] for i in xrange(len(pywt.wavelist(wavelet_family))): dictionary_t = Classes.DictT(level=None, name=wavelet_family + str(i + 1)) ortho_basis_t = dictionary_t.dot(np.identity(matrix_signal.shape[0])) if ortho == 'yes': ortho_basis_t = np.linalg.qr(ortho_basis_t.T)[0].T ortho_basis_t /= np.sqrt(np.sum(ortho_basis_t**2, axis=0)) matrix_x, matrix_z, err, atoms_list = multi_channel_omp( ortho_basis_t.T, ortho_basis_t, matrix_signal, vect_sigma, significance_level) r2 = np.var(matrix_z) / np.var(matrix_signal) r_sq_values.append(r2) ajusted_r_sq_values.append( r2 - (1 - r2) * len(atoms_list) / (matrix_signal.shape[0] - len(atoms_list) - 1)) wavelet_indexes.append(i + 1) return r_sq_values, ajusted_r_sq_values, wavelet_indexes
def aicc_criterion(matrix_signal, vect_sigma, wavelet_family, ortho='no', significance_level=5): aicc_values = [] wavelet_indexes = [] for i in xrange(len(pywt.wavelist(wavelet_family))): dictionary_t = Classes.DictT(level=None, name=wavelet_family + str(i + 1)) ortho_basis_t = dictionary_t.dot(np.identity(matrix_signal.shape[0])) if ortho == 'yes': ortho_basis_t = np.linalg.qr(ortho_basis_t.T)[0].T ortho_basis_t /= np.sqrt(np.sum(ortho_basis_t**2, axis=0)) matrix_x, matrix_z, err, atoms_list = multi_channel_omp( ortho_basis_t.T, ortho_basis_t, matrix_signal, vect_sigma, significance_level) n = matrix_signal.shape[0] k = len(atoms_list) aicc_values.append(n * np.log(np.var(matrix_signal - matrix_z)) + k + 2 * k * (k + 1) / (n - k - 1)) wavelet_indexes.append(i + 1) return aicc_values, wavelet_indexes
def __init__(self, wavelet_name, nb_scale=4, undecimated=False, mode='zero'): """ Initialize the 'pyWavelet3' class. Parameters ---------- wavelet_name: str the wavelet name to be used during the decomposition. nb_scales: int, default 4 the number of scales in the decomposition. undecimated: bool, default False enable the use of undecimated wavelet transform. mode : str or tuple of str, optional Signal extension mode, see :ref:`Modes <ref-modes>`. This can also be a tuple containing a mode to apply along each axis in ``axes``. """ if wavelet_name not in pywt.wavelist(): raise ValueError( "Unknown transformation '{}'".format(wavelet_name)) self.pywt_transform = pywt.Wavelet(wavelet_name) self.nb_scale = nb_scale self.undecimated = undecimated self.unflatten = unflatten_swtn if undecimated else unflatten_wave self.flatten = flatten_swtn if undecimated else flatten_wave self.coeffs = None self.coeffs_shape = None self.mode = mode
def __init__(self, domain, elecs, agg, sfreq, wavelet, band_limits): super(WaveletFeatureGenerator, self).__init__(domain=domain, electrodes=elecs, agg_mode=agg) self.wt_feats = sorted([ feat_func for feat_func in dir(features_wavelets) if not feat_func.startswith('_') ]) assert wavelet in wavelist(), "unknown wavelet {}".format(wavelet) if wavelet in wavelist(kind="discrete"): self.wavelet = Wavelet(wavelet) else: self.wavelet = ContinuousWavelet(wavelet) self.sfreq = sfreq self.band_limits = band_limits self.levels = None
def wavelet_tr(self, pywt_sig, pywt_norm_sig): wavelet_snr = np.zeros(len(pywt.wavelist(kind='discrete'))) wavelet_types = pywt.wavelist(kind='discrete') for i in range(len(wavelet_types)): [cA, cD] = pywt.dwt(pywt_sig, wavelet_types[i]) cD = pywt.threshold(cD, np.mean(cD), 'soft') y = pywt.idwt(cA, None, wavelet_types[i]) clt = SNR(pywt_norm_sig, y) wavelet_snr[i] = clt.signal_to_noise() wavelet_snr = check_zero(wavelet_snr) index_val_w = np.unravel_index(np.argmax(wavelet_snr, axis=None), wavelet_snr.shape) return index_val_w[0], round(wavelet_snr[index_val_w], 3), wavelet_snr
def Discret_Wavelet_Transform(X, wavelet=None, *a, **k): ''' The nature of DWT is to send raw signal S into one pair of filters, high pass filter H and low pass filter L, which are actually the wavelet you choose. Next, convolve S with H and L, thus generating two filtered signal Sh and Sl with length of ( len(S) + len(H) - 1 ) Then, downsample Sh and Sl and cut off len(H) / 2 points at each end of signals to avoid distortion( Sh = Sh[len(H) / 2 : -len(H) / 2] ). That's all! What we get now is entirely high-freq part and low-freq part of raw signal, and this process is the DWT in my understanding. high pass downsampling +--------+ +====>[ H ]=========>[ 2! ]====>+ Sh(cD) | | filter +--------+ +---+ | | S +==>+ +---+ | | low pass downsampling +--------+ +====>[ L ]=========>[ 2! ]====>+ Sl(cA) | filter +--------+ Sometimes DWT is called FWT as well, which stands for Fast-WT. Indeed, DWT is really really fast and efficient. By constructing special QMFs the corresponding DWT can be computed via filtering and downsampling, which is the state-of-the-art algorithm to compute DWTs today. You do not need the scaling function to compute the DWT, it is just an implementation detail that FWT process. P.S. Sh, Sl is more known as cD(detailed coefficients vector) and cA(approximate coefficients vector) in some tutorials. ''' if wavelet not in pywt.wavelist(): wavelet = 'haar' return pywt.dwt(X, wavelet)
def cross_validation(matrix_signal, vect_sigma, wavelet_family, significance_level=5): matrix_signal_sh = np.copy(matrix_signal) #np.random.shuffle(matrix_signal_sh) cross_val = [] wavelet_indexes = [] training_database = matrix_signal_sh[:floor(matrix_signal.shape[0] / 2)] testing_database = matrix_signal_sh[floor(matrix_signal.shape[0] / 2):] for i in xrange(len(pywt.wavelist(wavelet_family))): dictionary_t = Classes.DictT(level=None, name=wavelet_family + str(i + 1)) ortho_basis_t = np.linalg.qr( dictionary_t.dot(np.identity(training_database.shape[0])).T)[0].T ortho_basis_t /= np.sqrt(np.sum(ortho_basis_t**2, axis=0)) cross_val.append( cross_val_procedure(ortho_basis_t.T, ortho_basis_t, training_database, testing_database, vect_sigma, significance_level)) wavelet_indexes.append(i + 1) return cross_val, wavelet_indexes
def test_swt2_iswt2_integration(wavelets=None): # This function performs a round-trip swt2/iswt2 transform test on # all available types of wavelets in PyWavelets - except the # 'dmey' wavelet. The latter has been excluded because it does not # produce very precise results. This is likely due to the fact # that the 'dmey' wavelet is a discrete approximation of a # continuous wavelet. All wavelets are tested up to 3 levels. The # test validates neither swt2 or iswt2 as such, but it does ensure # that they are each other's inverse. max_level = 3 if wavelets is None: wavelets = pywt.wavelist(kind='discrete') if 'dmey' in wavelets: # The 'dmey' wavelet is a special case - disregard it for now wavelets.remove('dmey') for current_wavelet_str in wavelets: current_wavelet = pywt.Wavelet(current_wavelet_str) input_length_power = int(np.ceil(np.log2(max( current_wavelet.dec_len, current_wavelet.rec_len)))) input_length = 2**(input_length_power + max_level - 1) X = np.arange(input_length**2).reshape(input_length, input_length) with warnings.catch_warnings(): warnings.simplefilter('ignore', FutureWarning) coeffs = pywt.swt2(X, current_wavelet, max_level) Y = pywt.iswt2(coeffs, current_wavelet) assert_allclose(Y, X, rtol=1e-5, atol=1e-5)
def is_wname_allowed(wname): list = pywt.wavelist() if ((wname is not None) and wname != ''): if wname in list: return True else: return False
def library_wavelet(image): print(pywt.wavelist()) if not (image.shape[0] % 4 == 0) or not (image.shape[1] % 4 == 0): print("The size of your image must bea multiple of 4!") return None wav_result = np.zeros(image.shape) print len(image.shape) nchannels = 3 if len(image.shape) == nchannels: for channel in range(nchannels): data0 = image[:, :, channel] coeffs0 = pywt.dwt2(data0, 'db4') cA, (cH, cV, cD) = coeffs0 aux0 = np.concatenate((cA, cV), axis=1) aux1 = np.concatenate((cH, cD), axis=1) wav_result0 = np.concatenate((aux0, aux1), axis=0) wav_result[:, :, channel] = wav_result0 else: coeffs = pywt.dwt2(image, 'db2') cA, (cH, cV, cD) = coeffs aux0 = np.concatenate((cA, cV), axis=1) aux1 = np.concatenate((cH, cD), axis=1) wav_result = np.concatenate((aux0, aux1), axis=0) return wav_result
def wavelet_descomposition_experiment(): dataset = '../datasets/grabado como el libro super bien' experiment_rsult = './descomposition experiment con entonema 6' if not os.path.exists(experiment_rsult): os.mkdir(experiment_rsult) name = os.path.basename(dataset) for family in pywt.families(): wavelet = pywt.wavelist(family=family, kind='discrete')[0] if wavelet in pywt.wavelist(kind='discrete'): directory = '{}/{}'.format(experiment_rsult, wavelet) if not os.path.exists(directory): os.mkdir(directory) for wav in os.listdir('{}/6'.format(dataset)): plot_descomposition(dataset, 6, wav, wavelet, directory) print('Finish')
def coiflets_wavelets_transf(X, parameter1=1): parameter1 = parameter1 if parameter1 in range(1, 6) else 1 funct = 'coif'+str(parameter1) funct = funct if funct in pywt.wavelist('coif') else 'coif1' Xt = np.array([np.concatenate(pywt.dwt(X[:, i], funct)) for i in range(X.shape[1])]) return Xt
def test_swt_iswt_integration(): # This function performs a round-trip swt/iswt transform test on # all available types of wavelets in PyWavelets - except the # 'dmey' wavelet. The latter has been excluded because it does not # produce very precise results. This is likely due to the fact # that the 'dmey' wavelet is a discrete approximation of a # continuous wavelet. All wavelets are tested up to 3 levels. The # test validates neither swt or iswt as such, but it does ensure # that they are each other's inverse. max_level = 3 wavelets = pywt.wavelist(kind='discrete') if 'dmey' in wavelets: # The 'dmey' wavelet seems to be a bit special - disregard it for now wavelets.remove('dmey') for current_wavelet_str in wavelets: current_wavelet = pywt.Wavelet(current_wavelet_str) input_length_power = int( np.ceil( np.log2(max(current_wavelet.dec_len, current_wavelet.rec_len)))) input_length = 2**(input_length_power + max_level - 1) X = np.arange(input_length) for norm in [True, False]: if norm and not current_wavelet.orthogonal: # non-orthogonal wavelets to avoid warnings when norm=True continue for trim_approx in [True, False]: coeffs = pywt.swt(X, current_wavelet, max_level, trim_approx=trim_approx, norm=norm) Y = pywt.iswt(coeffs, current_wavelet, norm=norm) assert_allclose(Y, X, rtol=1e-5, atol=1e-7)
def __init__(self): QMainWindow.__init__(self) loadUi("../ui/Continious.ui", self) self.setWindowTitle("Wavelet Transform Data Analyzer Tool") self.setWindowIcon(QtGui.QIcon('../icon/icon.png')) self.setFixedSize(1087, 642) Features.center(self) self.signals = [] self.audio = [] self.time = [] self.load_check = False self.analyze_check = False self.actionClose.triggered.connect(self.close_window) self.cont_signal_Load.triggered.connect(self.load_signal) self.actionFolder.triggered.connect(self.load_folder)#load signal via menubar self.addToolBar(NavigationToolbar(self.widget_1DCont_Original.canvas, self)) # embedding matplotlib to widget self.pushButton_1DCont_Analyze.clicked.connect(self.analyze_cont) # self.pushButton_save_db_cont.clicked.connect(self.save_to_db) wave_types = pywt.wavelist(kind='continuous') self.comboBox_1DCont_Type.addItems(wave_types) self.checkBox_1D_Average.setChecked(True), self.checkBox_1D_Entropy.setChecked(True) self.checkBox_1D_Kurtosis.setChecked(True) self.checkBox_1D_Max.setChecked(True) # discrete page statistic functions checks self.checkBox_1D_Median.setChecked(True) self.checkBox_1D_Min.setChecked(True) self.checkBox_1D_Skewness.setChecked(True) self.checkBox_1D_StandartDeviation.setChecked(True)
def symlets_wavelets_transf(X, parameter1=2): parameter1 = parameter1 if parameter1 in range(2, 21) else 2 funct = 'sym'+str(parameter1) funct = funct if funct in pywt.wavelist('sym') else 'sym2' Xt = np.array([np.concatenate(pywt.dwt(X[:, i], funct)) for i in range(X.shape[1])]) return Xt
def test_swt2_iswt2_integration(wavelets=None): # This function performs a round-trip swt2/iswt2 transform test on # all available types of wavelets in PyWavelets - except the # 'dmey' wavelet. The latter has been excluded because it does not # produce very precise results. This is likely due to the fact # that the 'dmey' wavelet is a discrete approximation of a # continuous wavelet. All wavelets are tested up to 3 levels. The # test validates neither swt2 or iswt2 as such, but it does ensure # that they are each other's inverse. max_level = 3 if wavelets is None: wavelets = pywt.wavelist(kind='discrete') if 'dmey' in wavelets: # The 'dmey' wavelet is a special case - disregard it for now wavelets.remove('dmey') for current_wavelet_str in wavelets: current_wavelet = pywt.Wavelet(current_wavelet_str) input_length_power = int(np.ceil(np.log2(max( current_wavelet.dec_len, current_wavelet.rec_len)))) input_length = 2**(input_length_power + max_level - 1) X = np.arange(input_length**2).reshape(input_length, input_length) coeffs = pywt.swt2(X, current_wavelet, max_level) Y = pywt.iswt2(coeffs, current_wavelet) assert_allclose(Y, X, rtol=1e-5, atol=1e-5)
def dwt_library(cls, img_arr): '''Display all the availbale DWT (single level) for the input array ''' t1 = time.time() count = 0 for fam in pywt.families(): for mothwv in pywt.wavelist(fam): for mod in pywt.Modes.modes: print '\tWavelet: {0} / Mode: {1}'.format(mothwv, mod) (c_A, (c_H, c_V, c_D)) = pywt.dwt2(img_arr, pywt.Wavelet(mothwv), mod) count += 1 fig = plt.figure(figsize=(6, 11)) ax1 = fig.add_subplot(221) ax2 = fig.add_subplot(222) ax3 = fig.add_subplot(223) ax4 = fig.add_subplot(224) ax1.imshow(c_A, cmap='seismic') #'flag' ax2.imshow(c_V, cmap='seismic') ax3.imshow(c_H, cmap='seismic') ax4.imshow(c_D, cmap='seismic') plt.title('Wavelet: {0} / Mode: {1}'.format(mothwv, mod)) plt.subplots_adjust(left=.06, bottom=0.05, right=0.99, top=0.99, wspace=0., hspace=0.) plt.show() t2 = time.time() print( '\nTotal time in all {1} modes+mother wavelets: {0:.2f}\''.format( (t2 - t1) / 60., count))
def daubechies_wavelet_transf(X, parameter1=1): parameter1 = parameter1 if parameter1 in range(1, 21) else 1 funct = 'db'+str(parameter1) funct = funct if funct in pywt.wavelist('db') else 'db1' Xt = np.array([np.concatenate(pywt.dwt(X[:, i], funct)) for i in range(X.shape[1])]) return Xt
def test_swt_iswt_integration(): # This function performs a round-trip swt/iswt transform test on # all available types of wavelets in PyWavelets - except the # 'dmey' wavelet. The latter has been excluded because it does not # produce very precise results. This is likely due to the fact # that the 'dmey' wavelet is a discrete approximation of a # continuous wavelet. All wavelets are tested up to 3 levels. The # test validates neither swt or iswt as such, but it does ensure # that they are each other's inverse. max_level = 3 wavelets = pywt.wavelist() if 'dmey' in wavelets: # The 'dmey' wavelet seems to be a bit special - disregard it for now wavelets.remove('dmey') for current_wavelet_str in wavelets: current_wavelet = pywt.Wavelet(current_wavelet_str) input_length_power = int(np.ceil(np.log2(max( current_wavelet.dec_len, current_wavelet.rec_len)))) input_length = 2**(input_length_power + max_level - 1) X = np.arange(input_length) coeffs = pywt.swt(X, current_wavelet, max_level) Y = pywt.iswt(coeffs, current_wavelet) assert_allclose(Y, X, rtol=1e-5, atol=1e-7)
def _wavelet_family_callback(option, optstr, value, parser): """Callback for -w|--wavelet-family cmdline option """ wl_list = pywt.wavelist() wl_list_str = ", ".join( ['-1: None'] + ['%d:%s' % w for w in enumerate(wl_list)]) if value == "list": print "Available wavelet families: " + wl_list_str raise SystemExit, 0 wl_family = value try: # may be int? ;-) wl_family_index = int(value) if wl_family_index >= 0: try: wl_family = wl_list[wl_family_index] except IndexError: print "Index is out of range. " + \ "Following indexes with names are known: " + \ wl_list_str raise SystemExit, -1 else: wl_family = 'None' except ValueError: pass # Check the value wl_family = wl_family.lower() if wl_family == 'none': wl_family = None elif not wl_family in wl_list: print "Uknown family '%s'. Known are %s" % (wl_family, ', '.join(wl_list)) raise SystemExit, -1 # Store it in the parser setattr(parser.values, option.dest, wl_family)
def discreteWaveletAnalysis(vx, wDict): from utilities import dataFromDict try: import pywt except: sys.exit(' Library pywt not installed. Exiting ...') # nlevel = 4 order = 'freq' # "normal" wavelet = dataFromDict('wavelet', wDict, allowNone=False) nlevel = dataFromDict('nlevel', wDict, allowNone=False) if (wavelet in pywt.wavelist()): try: wp = pywt.WaveletPacket(vx, wavelet, 'sym', maxlevel=nlevel) except: print(" Wrong wavelet type given. Reverting to default 'db2'. ") wavelet = 'db2' wp = pywt.WaveletPacket(vx, wavelet, 'sym', maxlevel=nlevel) nodes = wp.get_level(nlevel, order=order) labels = [n.path for n in nodes] values = np.array([n.data for n in nodes], 'd') values = abs(values) return values, labels
def print_wavelets(): """" Prints available wavelets """ wavlist = ['morlet', 'ricker'] + pywt.wavelist(kind='continuous') print(wavlist)
def checkWavelet(value, rule_obj, path): if not isinstance(value, six.string_types): raise TypeError('Wavelet not expected type (str)') wavelist = pywt.wavelist() if value not in wavelist: raise ValueError('Wavelet "%s" not available in pyWavelets %s' % (value, wavelist)) return True
def handle(self, *args, **options): substance_names = [ 'Painted', 'Wood', 'Fabric/cloth', 'Tile', 'Metal', 'Carpet/rug', 'Ceramic', 'Leather', 'Food', 'Brick', 'Stone', 'Skin' ] try: os.makedirs('svm') except Exception as e: print e all_samples = ShapeImageSample.objects.filter( shape__substance__name__in=substance_names ).order_by('?') train = [] test = [] # split training and testing print 'splitting training/test...' users = all_samples.distinct('shape__photo__flickr_user').values_list('shape__photo__flickr_user', flat=True).order_by() for u in progress.bar(users): if len(test) > len(train): train += all_samples.filter(shape__photo__flickr_user_id=u) else: test += all_samples.filter(shape__photo__flickr_user_id=u) print 'train size: %s' % len(train) print 'test size: %s' % len(test) for wavelet in progress.bar(pywt.wavelist('db') + pywt.wavelist('haar')): for training in [True, False]: print 'features for %s (training=%s)...' % (wavelet, training) cur_samples = train if training else test image_paths = [s.image.path for s in cur_samples] p = Pool(32) features = p.map(functools.partial(compute_features, wavelet), image_paths) p.close() with open('svm/%s-%s.svm' % (wavelet, 'train' if training else 'test'), 'w') as outfile: for i_s, s in enumerate(cur_samples): class_str = substance_names.index(s.shape.substance.name) feature_str = ' '.join(['%s:%s' % (i_f+1, f) for (i_f, f) in enumerate(features[i_s])]) print >>outfile, class_str, feature_str
def dwt(x, wavelet, level=1, mode='symmetric'): if wavelet not in pywt.wavelist(): msg = 'input wavelet %s is not supported' % wavelet raise AlgoError(message=msg) coef = np.array(pywt.wavedec(x, wavelet, mode, level)) a = coef[0] d_vec = coef[1:] return a, d_vec
def denoise(self, data): wavelet = pywt.wavelist()[18] noiseSigma = median(absolute(data - median(data))) / 0.6745 levels = int(floor(log(len(data)))) WC = pywt.wavedec(data, wavelet, level=levels) threshold = noiseSigma * sqrt(2 * log(len(data))) NWC = map(lambda x: pywt.thresholding.hard(x, threshold), WC) return pywt.waverec(NWC, wavelet)[1:]
def basic_example(): print('Family =', pywt.families()) for family in pywt.families(): print('\t%s family: ' % family + ', '.join(pywt.wavelist(family))) # Discrete wavelet object: # haar family: # 'haar'. # db family: # 'db1', 'db2', 'db3', 'db4', 'db5', 'db6', 'db7', 'db8', 'db9', 'db10', 'db11', 'db12', 'db13', 'db14', 'db15', 'db16', 'db17', 'db18', 'db19', 'db20', 'db21', 'db22', 'db23', 'db24', 'db25', 'db26', 'db27', 'db28', 'db29', 'db30', 'db31', 'db32', 'db33', 'db34', 'db35', 'db36', 'db37', 'db38'. # sym family: # 'sym2', 'sym3', 'sym4', 'sym5', 'sym6', 'sym7', 'sym8', 'sym9', 'sym10', 'sym11', 'sym12', 'sym13', 'sym14', 'sym15', 'sym16', 'sym17', 'sym18', 'sym19', 'sym20'. # coif family: # 'coif1', 'coif2', 'coif3', 'coif4', 'coif5', 'coif6', 'coif7', 'coif8', 'coif9', 'coif10', 'coif11', 'coif12', 'coif13', 'coif14', 'coif15', 'coif16', 'coif17'. # bior family: # 'bior1.1', 'bior1.3', 'bior1.5', 'bior2.2', 'bior2.4', 'bior2.6', 'bior2.8', 'bior3.1', 'bior3.3', 'bior3.5', 'bior3.7', 'bior3.9', 'bior4.4', 'bior5.5', 'bior6.8'. # rbio family: # 'rbio1.1', 'rbio1.3', 'rbio1.5', 'rbio2.2', 'rbio2.4', 'rbio2.6', 'rbio2.8', 'rbio3.1', 'rbio3.3', 'rbio3.5', 'rbio3.7', 'rbio3.9', 'rbio4.4', 'rbio5.5', 'rbio6.8'. # dmey family: # 'dmey'. # Continuous wavelet object: # gaus family: # 'gaus1', 'gaus2', 'gaus3', 'gaus4', 'gaus5', 'gaus6', 'gaus7', 'gaus8'. # mexh family: # 'mexh'. # morl family: # 'morl'. # cgau family: # 'cgau1', 'cgau2', 'cgau3', 'cgau4', 'cgau5', 'cgau6', 'cgau7', 'cgau8'. # Discrete continuous wavelet object: # shan family: # 'shan'. # fbsp family: # 'fbsp'. # cmor family: # 'cmor'. #-------------------- w = pywt.Wavelet('db3') print('Summary =', w) print('Name = {}, short family name = {}, family name = {}.'.format( w.name, w.short_family_name, w.family_name)) # Decomposition (dec_len) and reconstruction (rec_len) filter lengths. print('dec_len = {}, rec_len = {}.'.format(int(w.dec_len), int(w.rec_len))) # Orthogonality and biorthogonality. print('Orthogonal = {}, biorthogonal = {}.'.format(w.orthogonal, w.biorthogonal)) # Symmetry. print('Symmetry = {}.'.format(w.symmetry)) # Number of vanishing moments for the scaling function phi (vanishing_moments_phi) and the wavelet function psi (vanishing_moments_psi) associated with the filters. print('vanishing_moments_phi = {}, vanishing_moments_psi = {}.'.format( w.vanishing_moments_phi, w.vanishing_moments_psi)) # Lowpass and highpass decomposition filters and lowpass and highpass reconstruction filters. print('Filter bank? =', w.filter_bank == (w.dec_lo, w.dec_hi, w.rec_lo, w.rec_hi))
def setupContent(self, content_widget: QWidget): self.ui = Ui_Wavelet() self.ui.setupUi(content_widget) self.ui.level_spin.setMinimum(1) families = pywt.families(False) self.ui.wavelet_family_combo.addItems(families) self.ui.wavelet_combo.addItems(pywt.wavelist(pywt.families()[self.ui.wavelet_family_combo.currentIndex()])) self.ui.wavelet_family_combo.currentIndexChanged.connect(self._onFamilyChanged)
def make_entropy_vector(curve, level = 3, wavelet_list = pywt.wavelist(kind='discrete')): vector = [] features_name = [] for wavelet in wavelet_list: #cA, cD = pywt.dwt(curve, wavelet, mode='symmetric', axis=-1) cD = get_cD(curve, wavelet, level = level)[-1][1] vector.append(entropy(cD)) features_name.append('entr_{}'.format(wavelet)) return vector, features_name
def run(self): self.average, self.entropy, self.kurtosis, self.max_v, self.median, self.min_v, self.skewness, self.standart_dev = Features.check_statistics( self) #self.wavelet_type, self.sampling_per, self.min_scale, self.max_scale, self.scale_step = Features.cont_check_wavelet(self) self.sampling_per = 1 self.min_scale = 1 self.max_scale = 8 self.scale_step = 1 wave_types = pywt.wavelist(kind='continuous') self.scaling = np.arange(self.min_scale, self.max_scale, self.scale_step) for wave_func in wave_types: self.wavelet_type = wave_func self.wavelet_level = len(self.scaling) - 1 col, self.header, self.db_header = Features.init_table( self, len(self.all_signals)) self.db_matrix = np.zeros( (len(self.all_signals), 8 * (self.wavelet_level + 1)), dtype=complex) for iter in range(0, len(self.all_signals)): #print(self.all_signals[iter]) self.signals.clear() self.audio, self.sample = librosa.load(self.all_signals[iter]) self.signals.append(self.audio) self.time = np.arange(0, len(self.audio)) / self.sample coef, freqs = pywt.cwt(self.audio, self.scaling, self.wavelet_type, int(self.sampling_per)) for i in range(0, self.wavelet_level + 1): self.signals.append( coef[i]) # adding signals array to coeffs self.db_matrix[iter] = Features.insertTableComplex( self, iter, col) w_name = str(self.wavelet_type) table_name = "Db_GTZAN_function_" + w_name + "_Scale_1_to_8_Period_1" Database.create_table( Database.database_name, table_name, self.db_header, "") # creating new table with statistic function Database.create_table(Database.database_name, table_name, self.db_header, "Comp_") for index in range(0, len(self.all_signals)): name = self.all_signals[index].split(sep='/') Database.add_values_to_table(Database.database_name, table_name, name[-1], self.db_header, self.db_matrix[index], "") Database.add_values_to_table(Database.database_name, table_name, name[-1], self.db_header, self.db_matrix[index], "Comp_") print(table_name)
def _set_ui_tab2(self): """" _set_ui_tab2 @:brief Set user interface of the second tab : wavelet processing tab see pywt documentation @:parameter self @:return None """ lay = QGridLayout(self.tab2) label = QLabel("Wavelet family :") lay.addWidget(label, 0, 1) # all possible method for wevelet processing for i, (key, text) in enumerate(( ("haar", "Haar"), ("db", "daubechies"), ("sym", "Symlets"), ("coif", "Coiflets"), ("bior", "biorthogonal"), ("rbio", "reverse-biorthogonal"), ("dmey", "Discret FIR Meyer"), ("gaus", "gaussian"), ("mexh", "Mexican hat"), ("morl", "morlet"), ("cgau", "Complex Gaussian"), ("shan", "Shanon"), ("fbsp", "Frequency B-Spline"), ("cmor", "Complex Morlet"), )): checkbox = QCheckBox(text) checkbox.setChecked(False) lay.addWidget(checkbox, i + 1, 1) self.checkbox_states[key] = checkbox # set combo box with method self.wavelet_combo_box[key] = QComboBox() l = pywt.wavelist(key) self.wavelet_combo_box[key].addItems(l) lay.addWidget(self.wavelet_combo_box[key], i + 1, 2) # choose order of decomposition label_order_decomp = QLabel("choose order of decomposition : \t") lay.addWidget(label_order_decomp, 0, 0) self.order_decomp = QLineEdit() lay.addWidget(self.order_decomp, 1, 0) self.process_wavelet = QPushButton("Process") QObject.connect(self.process_wavelet, SIGNAL('clicked()'), self._on_process_wavelet) lay.addWidget(self.process_wavelet, i + 2, 3) self.tab2.setLayout(lay)
def test_wavelet_coefficients(): families = ('db', 'sym', 'coif', 'bior', 'rbio') wavelets = sum([pywt.wavelist(name) for name in families], []) for wavelet in wavelets: if (pywt.Wavelet(wavelet).orthogonal): check_coefficients_orthogonal(wavelet) elif (pywt.Wavelet(wavelet).biorthogonal): check_coefficients_biorthogonal(wavelet) else: check_coefficients(wavelet)
def pltWL(wn): famlist = pywt.wavelist(family=wn, kind='discrete') for i in range(len(famlist)): wpln = wn + str(int(famlist[0].replace(wn, '')) + i) wavelet = pywt.Wavelet(wpln) phi, psi, x = wavelet.wavefun(level=8) print(wpln) plt.plot(x, phi) plt.plot(x, psi) plt.show()
def test_accuracy(): # list of mode names in pywt and matlab modes = [('zpd', 'zpd'), ('cpd', 'sp0'), ('sym', 'sym'), ('ppd', 'ppd'), ('sp1', 'sp1'), ('per', 'per')] families = ('db', 'sym', 'coif', 'bior', 'rbio') wavelets = sum([pywt.wavelist(name) for name in families], []) for pmode, mmode in modes: for wavelet in wavelets: yield check_accuracy, pmode, mmode, wavelet
def test_wavelet_coefficients(): families = ('db', 'sym', 'coif', 'bior', 'rbio') wavelets = sum([pywt.wavelist(name) for name in families], []) for wavelet in wavelets: if (pywt.Wavelet(wavelet).orthogonal): yield check_coefficients_orthogonal, wavelet elif(pywt.Wavelet(wavelet).biorthogonal): yield check_coefficients_biorthogonal, wavelet else: yield check_coefficients, wavelet
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 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(): 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_dwdtn_idwtn_allwavelets(): rstate = np.random.RandomState(1234) r = rstate.randn(16, 16) # test 2D case only for all wavelet types wavelist = pywt.wavelist() if 'dmey' in wavelist: wavelist.remove('dmey') for wavelet in wavelist: for mode in pywt.Modes.modes: coeffs = pywt.dwtn(r, wavelet, mode=mode) assert_allclose(pywt.idwtn(coeffs, wavelet, mode=mode), r, rtol=1e-7, atol=1e-7)
def test_perfect_reconstruction(): families = ("db", "sym", "coif", "bior", "rbio") wavelets = sum([pywt.wavelist(name) for name in families], []) # list of mode names in pywt and matlab modes = [("zpd", "zpd"), ("cpd", "sp0"), ("sym", "sym"), ("ppd", "ppd"), ("sp1", "sp1"), ("per", "per")] dtypes = (np.float32, np.float64) for wavelet in wavelets: for pmode, mmode in modes: for dt in dtypes: yield check_reconstruction, pmode, mmode, wavelet, dt
def settings(self): global wavelet_coefficients wavelets = pywt.wavelist() wavelet, ok = QtGui.QInputDialog.getItem(self, 'Change Wavelet' , 'Change your current mother wavelet:', wavelets, wavelets.index(self.wavelet), False) if ok: self.wavelet = str(wavelet) wavelet_coefficients = self.getWaveletCoeffs() self.painter.drawWavelets()
def test_perfect_reconstruction(): families = ('db', 'sym', 'coif', 'bior', 'rbio') wavelets = sum([pywt.wavelist(name) for name in families], []) # list of mode names in pywt and matlab modes = [('zpd', 'zpd'), ('cpd', 'sp0'), ('sym', 'sym'), ('ppd', 'ppd'), ('sp1', 'sp1'), ('per', 'per')] dtypes = (np.float32, np.float64) for wavelet in wavelets: for pmode, mmode in modes: for dt in dtypes: yield check_reconstruction, pmode, mmode, wavelet, dt
def __init__(self): Filter.__init__(self) self.wl_filter_list = [] self.wl_filter_code = [] self.threshold = 0.1 self.auto_threshold = True for x in pywt.wavelist(): p = pywt.Wavelet(x) self.wl_filter_list.append(p.family_name + " " + str(p.number)) self.wl_filter_code.append(p.name) self.type = 'bior6.8' self.thresholding = 0 self.config = ["threshold","auto_threshold","type","thresholding"]
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.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 __init__(self, wavelet = None, mode = 'sym', *args, **kwargs): super(PywtWaveletNode, self).__init__(*args, **kwargs) if not wavelet in pywt.wavelist(): warnings.warn("No or wrong wavelet specified (%s). Using 'haar'."%str(wavelet)) wavelet = "haar" if not mode in pywt.MODES.modes: warnings.warn("Wrong mode (%s) specified. Using 'sym'."%mode) mode = 'sym' self.set_permanent_attributes(wavelet=wavelet, mode=mode, feature_names=None, channel_names=None)
def test_dwdtn_idwtn_allwavelets(): rstate = np.random.RandomState(1234) r = rstate.randn(16, 16) # test 2D case only for all wavelet types wavelist = pywt.wavelist() if 'dmey' in wavelist: wavelist.remove('dmey') for wavelet in wavelist: if wavelet in ['cmor', 'shan', 'fbsp']: # skip these CWT families to avoid warnings continue if isinstance(pywt.DiscreteContinuousWavelet(wavelet), pywt.Wavelet): for mode in pywt.Modes.modes: coeffs = pywt.dwtn(r, wavelet, mode=mode) assert_allclose(pywt.idwtn(coeffs, wavelet, mode=mode), r, rtol=1e-7, atol=1e-7)
def test_wavelist(): for name in pywt.wavelist(family='coif'): assert_(name.startswith('coif')) assert_('cgau7' in pywt.wavelist(kind='continuous')) assert_('sym20' in pywt.wavelist(kind='discrete')) assert_(len(pywt.wavelist(kind='continuous')) + len(pywt.wavelist(kind='discrete')) == len(pywt.wavelist(kind='all'))) assert_raises(ValueError, pywt.wavelist, kind='foobar')
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 bic_criterion(matrix_signal, vect_sigma, wavelet_family, ortho='no', significance_level=5): bic_values = [] wavelet_indexes = [] for i in xrange(len(pywt.wavelist(wavelet_family))): dictionary_t = Classes.DictT(level=None, name=wavelet_family+str(i+1)) ortho_basis_t = dictionary_t.dot(np.identity(matrix_signal.shape[0])) if ortho == 'yes': ortho_basis_t = np.linalg.qr(ortho_basis_t.T)[0].T ortho_basis_t /= np.sqrt(np.sum(ortho_basis_t ** 2, axis=0)) matrix_x, matrix_z, err, atoms_list = multi_channel_omp(ortho_basis_t.T, ortho_basis_t, matrix_signal, vect_sigma, significance_level) n = matrix_signal.shape[0] bic_values.append(n*np.log(np.var(matrix_signal-matrix_z)) + len(atoms_list)*np.log(n)) wavelet_indexes.append(i+1) return bic_values, wavelet_indexes
def get_all_filters(wavlevel=5,lenlimit=100): wavs = [] filters = [] filternames = [] #fas = pywt.families() fas = ['db','sym', 'coif','dmey'] for fa in fas: falist = pywt.wavelist(fa) wavs = wavs + falist for wav in wavs: wavelet = pywt.Wavelet(wav) for i in xrange(wavlevel): [phi, psi, x] = wavelet.wavefun(level=i+1) llen = len(psi) if llen<lenlimit: print wav,' len:', len(psi),min(x),max(x) filters.append(psi) filternames.append(wav+'-'+str(i+1)) return filternames, filters
def select_wavelet(data, r, method='median'): comparison = {} level = 5 r.initial = data for family in pywt.families(): for wv in pywt.wavelist(family): values = pywt.Wavelet(wv).wavefun(level=level) r('coef <- ccf(initial, %s)$acf' % Str4R(values[-2])) #psi if method == 'mean': r('med <- mean(coef)') elif method == 'sum': r('med <- sum(coef)') elif method == 'median': r('med <- coef[length(coef)/2]') else: r('med <- coef[length(coef)/2]') comparison[r.med] = (family, wv) #it's okay to rewrite keys return comparison
def main(): # verify input wtype = pick_option(sys.argv, 't', 'db7') if len(sys.argv) > 4: image = piio.read(sys.argv[1]) prefix = sys.argv[2] levels = int(sys.argv[3]) suffix = sys.argv[4] else: print("Incorrect syntax, use:") print(" > " + sys.argv[0] + " input prefix levels suffix [-t type]") print(" multiscale decomposition using wavelets") print(" available types:") for family in pywt.families(): print "%s family:" % family, ', '.join(pywt.wavelist(family)) sys.exit(1) if pywt.Wavelet(wtype).orthogonal == False: print "Warning \'%s\' is not orthogonal"%wtype decompose(image, prefix, levels, suffix, wtype)