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)
