wavelettrans.h

Go to the documentation of this file.

#pragma once
 
/*@+
________________________________________________________________________
 
 (C) dGB Beheer B.V.; (LICENSE) http://opendtect.org/OpendTect_license.txt
 Author:        Kristofer Tingdahl
 Date:          10-12-1999
 RCS:           $Id$
________________________________________________________________________
 
@$*/
 
#include "algomod.h"
#include "transform.h"
#include "enums.h"
#include "arraynd.h"
#include "arrayndimpl.h"
#include "fourier.h"
#include "ranges.h"
 
mExpClass(Algo) WaveletTransform
{
public:
    enum                WaveletType { Haar, Daubechies4, Daubechies6,
                                        Daubechies8, Daubechies10,
                                        Daubechies12, Daubechies14,
                                        Daubechies16, Daubechies18,
                                        Daubechies20, Beylkin, Coiflet1,
                                        Coiflet2, Coiflet3, Coiflet4,
                                        Coiflet5, Symmlet4, Symmlet5,
                                        Symmlet6, Symmlet7, Symmlet8,
                                        Symmlet9, Symmlet10, Vaidyanathan };
 
                        mDeclareEnumUtils(WaveletType);
 
    static void         getInfo(WaveletType tp,int& len,TypeSet<float>&);
 
    static const float  haar[3];
 
    static const float  daub4[5];
    static const float  daub6[7];
    static const float  daub8[9];
    static const float  daub10[11];
    static const float  daub12[13];
    static const float  daub14[15];
    static const float  daub16[17];
    static const float  daub18[19];
    static const float  daub20[21];
 
    static const float  beylkin[19];
 
    static const float  coiflet1[7];
    static const float  coiflet2[13];
    static const float  coiflet3[19];
    static const float  coiflet4[25];
    static const float  coiflet5[31];
 
    static const float  symmlet4[9];
    static const float  symmlet5[11];
    static const float  symmlet6[13];
    static const float  symmlet7[15];
    static const float  symmlet8[17];
    static const float  symmlet9[19];
    static const float  symmlet10[21];
 
    static const float  vaidyanathan[25];
 
    static bool         isCplx( WaveletType );
};
 
 
mExpClass(Algo) DWT : public GenericTransformND
{
public:
                        DWT( WaveletTransform::WaveletType );
    bool                setup();
 
protected:
 
    mExpClass(Algo) FilterWT1D : public GenericTransformND::Transform1D
    {
    public:
        
        bool            init();
        bool            run(bool);
                        FilterWT1D()
                            : cc_( 0 )
                            , cr_( 0 )
                            , wt_( WaveletTransform::Haar )
                        {}      
 
                        ~FilterWT1D() { delete [] cr_; delete [] cc_; }
 
        void            setWaveletType( WaveletTransform::WaveletType );
    protected:
 
#include "templ_wavlttransimpl.h"
 
        WaveletTransform::WaveletType           wt_;
 
        float*                  cc_;            // Filter Parameters
        float*                  cr_;
        int                     filtersz_;
        int                     joff_;
        int                     ioff_;
    };
 
    Transform1D*                createTransform() const
                                { return new FilterWT1D; }
 
    WaveletTransform::WaveletType       wt_;
};
 
 
mExpClass(Algo) CWT 
{
public:
                        CWT();
                        ~CWT();
 
    bool                init();
 
 
    enum                WaveletType { Morlet, Gaussian, MexicanHat };
                        mDeclareEnumUtils(WaveletType);
 
    void                setWavelet(CWT::WaveletType);
 
    void                setTransformRange( const StepInterval<float>& rg )
                        { freqrg_ = rg; }
    void                setDeltaT( float dt )           { dt_ = dt; }
                        
    bool                setInputInfo(const ArrayNDInfo&);
    const ArrayNDInfo&  getInputInfo() const            { return *info_; }
 
    bool                real2real() const               { return true; }
    bool                real2complex() const            { return false; }
    bool                complex2real() const            { return false; }
    bool                complex2complex() const         { return true; }
 
    bool                biDirectional() const           { return false; }
    bool                setDir(bool forw);
    bool                getDir() const                  { return true; }
 
 
    bool                transform(const ArrayND<float>&,
                                   ArrayND<float>& ) const
                        { return false; }
    bool                transform(const ArrayND<float_complex>&,
                                   ArrayND<float_complex>& ) const
                        { return false; }
    bool                transform(const ArrayND<float_complex>& input,
                                        ArrayND<float>& output);
 
    float               getScale(int ns,float dt,float freq) const;
 
    void                setFreqIdxs( const TypeSet<int>& outfreqidxs )
                        { outfreqidxs_ = outfreqidxs; }
 
protected:
 
    struct CWTWavelets
    {
                                CWTWavelets()   {}
 
        void                    createWavelet(WaveletType,int nrsamples,
                                              float scale);
        const TypeSet<float>*   getWavelet(float scale) const;
        void                    createMorletWavelet(int,float,TypeSet<float>&);
        void                    createMexhatWavelet(int,float,TypeSet<float>&);
        void                    createGaussWavelet(int,float,TypeSet<float>&);
 
 
        TypeSet<float>          scales_;
        TypeSet< TypeSet<float> > wavelets_;
    };
 
 
    CWTWavelets         wvlts_;
 
    bool                isPossible(int sz) const;
    bool                isFast( int ) const { return true; }
 
    void                transform(int,float,int,
                                  const Array1DImpl<float_complex>&,
                                  Array2DImpl<float>&);
 
    Fourier::CC*        fft_;
    Fourier::CC*        ifft_;
 
    ArrayNDInfo*        info_;
                                     
    bool                inited_;
    float               dt_;
    WaveletType         wt_;
 
    StepInterval<float> freqrg_;
    TypeSet<int>        outfreqidxs_;
};