fourier.h

Go to the documentation of this file.

#pragma once

/*
________________________________________________________________________

 (C) dGB Beheer B.V.; (LICENSE) http://opendtect.org/OpendTect_license.txt
 Author:        K. Tingdahl/Y. Liu
 Date:          August 2001
________________________________________________________________________

*/

#include "algomod.h"
#include "transform.h"
#include "paralleltask.h"
#include "factory.h"


namespace Fourier
{

class FFTCC1D;

mExpClass(Algo) CC : public GenericTransformND
{ mODTextTranslationClass(CC);
public:
    mDefaultFactoryCreatorImpl( CC, CC );
    mDefaultFactoryInstanciationBase( "PFAFFT", tr("FFT") );
    static ::Factory<CC>& factory();

    static CC*          createDefault();

                        CC();
    void                setNormalization(bool yn);
    static float        getNyqvist(float samplespacing);
    static float        getDf(float samplespacing,int nrsamples);
    static void         getFrequencies(float samplespacing,int nrsamples,
                                       TypeSet<float>&);
    bool                isFast(int sz) const;
    virtual int         getFastSize(int sz) const;
    static void pfarc(int isign,int n,const float* rz,float_complex* cz);
    static void pfacr(int isign,int n,const float_complex*,float* rz);
    static int npfaro(int nmin, int nmax);
    static int npfao(int nmin, int nmax);

protected:
    static uiString* legalInfo();
    static void pfacc(char dir,int sz,int step,float_complex* signal);
    static void pfacc(char dir,int sz,int step,int nr,const int* starts,
                      float_complex* signal);
    static void pfacc(char dir,int sz,int step,int nr,int batchstep,
                      float_complex* signal);
    static void pfacc(char dir,int sz,float_complex*);

    bool                setup();
    bool                normalize_;

    Transform1D*        createTransform() const;
    mClass(Algo) CC1D : public GenericTransformND::Transform1D,
                        public ParallelTask
    {
        public:
                        CC1D();
                        ~CC1D();
        bool            init();
        bool            run(bool parallel)
                        { return executeParallel( parallel ); }
        od_int64        nrIterations() const    { return nr_; }
        bool            doPrepare(int);
        bool            doWork(od_int64 start, od_int64 stop, int );
        void            setNormalization(bool yn)       { normalize_ = yn; }

        static int      getFastSize(int sz);
    protected:

        bool    dopfa_;
        char                    direction_;
        int                     higheststart_;
        bool                    normalize_;
        ObjectSet<FFTCC1D>      ffts_;
    };
};


mExpClass(Algo) FFTCC1D
{
public:
                        FFTCC1D();
                        FFTCC1D(const FFTCC1D&);

                        ~FFTCC1D()                      { cleanUp(); }
    bool                setSize(int);
    void                setSample(int smp)              { sample_ = smp; }
    void                setDir(bool forward)            { forward_ = forward; }
    void                setNormalization(bool yn)       { normalize_ = yn; }
    bool                run(float_complex* data);

    static int          getFastSize(int sz);

protected:

    void                cleanUp();
    bool                getSizeFactors();
    bool                doFactor2() const;
    bool                doFactor4() const;
    void                doFactor3() const;
    void                doFactor5() const;
    void                doOtherFactor(int factor,int psz);
    void                doRotation(int psz) const;
    bool                doFinish();
    bool                setupPermutation();

    bool                forward_;
    bool                normalize_;
    int                 size_;
    int                 sample_;
    int                 totalsmp_;
    int                 extsz_;
    int                 curf_;
    int                 rmfid_;
    int                 cycleid_;
    float               exp_;
    float               sin2_;

    float_complex*      data_;
    float*              rdata_;
    float*              idata_;
    float*              rtmp_;
    float*              itmp_;
    float*              cosv_;
    float*              sinv_;
    int*                permutation0_;
    int*                permutation1_;
    TypeSet<int>        permutfactors_;
    TypeSet<int>        factors_;
};

} // namespace Fourier