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 _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 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 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 _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 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_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 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_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 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 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 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 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_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_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 __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"]