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
 RCS:           $Id$
________________________________________________________________________
 
*/
 
#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