mi32/fftfunc.h

Go to the documentation of this file.

#ifndef  INC_MI32_FFTFUNC_H
#define  INC_MI32_FFTFUNC_H

#ifndef  INC_MI32_DOUBLEAR_H
   #include <mi32/doublear.h>
#endif

#ifndef  INC_RVC_IMAGE_H
   #include <rvc/image.h>
#endif

#include <complex>


typedef std::complex<double> DCOMPLEX;

#ifndef GENERATING_DOXYGEN_OUTPUT
namespace RVC {
   class OBJITEM;
   class RASTER;
   }
namespace SML {
   class CONTEXT;
   }
#endif // GENERATING_DOXYGEN_OUTPUT


enum FTFORMAT {
   FTFORMAT_RI_RI = 0,    
   FTFORMAT_RI_MP = 1,    
   FTFORMAT_MP_RI = 2,    
   FTFORMAT_MP_MP = 3,    
   FTFORMAT_RI = FTFORMAT_RI_RI,
   FTFORMAT_MP = FTFORMAT_MP_MP
   };
      
class FFT2D {

   public:

      static ERRVALUE Forward (
         const RVC::RASTER& input,
         RVC::OBJITEM& objitem,
         const RVC::IMAGE::DATATYPE& datatype = RVC::IMAGE::DATATYPE_ComplexRI,
         const LRECT2D rect = LRECT2D(1,1,0,0)
         );

      static ERRVALUE Inverse (
         const RVC::RASTER& input,
         RVC::OBJITEM& objitem,
         const RVC::IMAGE::CELLTYPE& celltype = RVC::IMAGE::CELLTYPE_Float_32,
         const LRECT2D rect = LRECT2D(1,1,0,0)
         );

      static INT32 AdjustToPower2 (
         const INT32 num
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      static ERRVALUE CopyGeoreference (
         const RVC::RASTER& input,
         RVC::RASTER& output,
         const LRECT2D& rect
         );
      #endif // GENERATING_DOXYGEN_OUTPUT

   };

class FFT1D {

   public:

      static void SMLClassInstall (
         SML::CONTEXT *context
         );

      FFT1D (
         );

      ~FFT1D (
         );

      ERRVALUE Init (
         const INT32 numEntries                    
         );

      void Close (
         );

      void Forward (
         DOUBLE_ARRAY<DCOMPLEX>& inout
         );

      void Forward (
         const DOUBLE_ARRAY<DCOMPLEX>& in, 
         DOUBLE_ARRAY<DCOMPLEX>& out 
         );

      void Forward (
         const DOUBLE_ARRAY<DCOMPLEX>& in, 
         DOUBLE_ARRAY<double>& outx, 
         DOUBLE_ARRAY<double>& outy, 
         const FTFORMAT format = FTFORMAT_RI
         );

      void Forward (
         const DOUBLE_ARRAY<double>& inx,
         const DOUBLE_ARRAY<double>& iny,
         DOUBLE_ARRAY<DCOMPLEX>& out, 
         const FTFORMAT format = FTFORMAT_RI
         );

      void Forward (
         DOUBLE_ARRAY<double>& inoutx,
         DOUBLE_ARRAY<double>& inouty,
         const FTFORMAT format = FTFORMAT_RI_RI
         );

      void Forward (
         const DOUBLE_ARRAY<double>& inx, 
         const DOUBLE_ARRAY<double>& iny, 
         DOUBLE_ARRAY<double>& outx, 
         DOUBLE_ARRAY<double>& outy, 
         const FTFORMAT format = FTFORMAT_RI_RI
         );

      void Inverse (
         DOUBLE_ARRAY<DCOMPLEX>& inout 
         );

      void Inverse (
         const DOUBLE_ARRAY<DCOMPLEX>& in, 
         DOUBLE_ARRAY<DCOMPLEX>& out 
         );

      void Inverse (
         const DOUBLE_ARRAY<DCOMPLEX>& in, 
         DOUBLE_ARRAY<double>& outx, 
         DOUBLE_ARRAY<double>& outy, 
         const FTFORMAT format = FTFORMAT_RI
         );

      void Inverse (
         const DOUBLE_ARRAY<double>& inx,
         const DOUBLE_ARRAY<double>& iny,
         DOUBLE_ARRAY<DCOMPLEX>& out, 
         const FTFORMAT format = FTFORMAT_RI
         );

      void Inverse (
         DOUBLE_ARRAY<double>& inoutx,
         DOUBLE_ARRAY<double>& inouty,
         const FTFORMAT format = FTFORMAT_RI_RI
         );

      void Inverse (
         const DOUBLE_ARRAY<double>& inx, 
         const DOUBLE_ARRAY<double>& iny, 
         DOUBLE_ARRAY<double>& outx, 
         DOUBLE_ARRAY<double>& outy, 
         const FTFORMAT format = FTFORMAT_RI_RI
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      const DCOMPLEX m_Null;

      INT32 m_NumEntries;
      DOUBLE_ARRAY<DCOMPLEX> m_Work;
      DOUBLE_ARRAY<DCOMPLEX> m_Temp;
      DOUBLE_ARRAY<DCOMPLEX> m_MinusRoot;
      DOUBLE_ARRAY<DCOMPLEX> m_PlusRoot;

      bool IsValid (
         const INT32 numEntries
         ) const;

      static void Copy (
         const DOUBLE_ARRAY<DCOMPLEX>& in, 
         DOUBLE_ARRAY<DCOMPLEX>& out, 
         INT32 numItems
         );

      static void Copy (
         const DOUBLE_ARRAY<DCOMPLEX>& in, 
         DOUBLE_ARRAY<double>& outx, 
         DOUBLE_ARRAY<double>& outy, 
         INT32 numItems,
         bool ri
         );

      static void Copy (
         const DOUBLE_ARRAY<double>& inx, 
         const DOUBLE_ARRAY<double>& iny, 
         DOUBLE_ARRAY<DCOMPLEX>& out, 
         INT32 numItems,
         bool ri
         );

      void PadWorkNull (
         INT32 startindex
         );

      void Transform (
         DOUBLE_ARRAY<DCOMPLEX>& root, 
         INT32 N,
         INT32 K,
         bool forward
         );

      FFT1D (const FFT1D&);
      FFT1D& operator= (const FFT1D&);
      #endif
   };


class FT1D {

   public:

      static void SMLClassInstall (
         SML::CONTEXT *context
         );

      FT1D (
         );

      ~FT1D (
         );

      ERRVALUE Init (
         const UINT32 numInputEntries,                   
         const UINT32 numOutputEntries                   
         );

      void Close (
         );

      void Forward (
         DOUBLE_ARRAY<DCOMPLEX>& inout,
         const UINT32 numInputEntries = 0,
         const UINT32 numOutputEntries = 0  
         );

      void Forward (
         const DOUBLE_ARRAY<DCOMPLEX>& in, 
         DOUBLE_ARRAY<DCOMPLEX>& out, 
         const UINT32 numInputEntries = 0,
         const UINT32 numOutputEntries = 0  
         );

      void Forward (
         const DOUBLE_ARRAY<DCOMPLEX>& in, 
         DOUBLE_ARRAY<double>& outx, 
         DOUBLE_ARRAY<double>& outy, 
         const FTFORMAT format = FTFORMAT_RI,
         const UINT32 numInputEntries = 0,
         const UINT32 numOutputEntries = 0  
         );

      void Forward (
         const DOUBLE_ARRAY<double>& inx,
         const DOUBLE_ARRAY<double>& iny,
         DOUBLE_ARRAY<DCOMPLEX>& out, 
         const FTFORMAT format = FTFORMAT_RI,
         const UINT32 numInputEntries = 0,
         const UINT32 numOutputEntries = 0  
         );

      void Forward (
         DOUBLE_ARRAY<double>& inoutx,
         DOUBLE_ARRAY<double>& inouty,
         const FTFORMAT format = FTFORMAT_RI_RI,
         const UINT32 numInputEntries = 0,
         const UINT32 numOutputEntries = 0  
         );

      void Forward (
         const DOUBLE_ARRAY<double>& inx, 
         const DOUBLE_ARRAY<double>& iny, 
         DOUBLE_ARRAY<double>& outx, 
         DOUBLE_ARRAY<double>& outy, 
         const FTFORMAT format = FTFORMAT_RI_RI,
         const UINT32 numInputEntries = 0,
         const UINT32 numOutputEntries = 0  
         );

      void Inverse (
         DOUBLE_ARRAY<DCOMPLEX>& inout, 
         const UINT32 numInputEntries = 0,
         const UINT32 numOutputEntries = 0  
         );

      void Inverse (
         const DOUBLE_ARRAY<DCOMPLEX>& in, 
         DOUBLE_ARRAY<DCOMPLEX>& out,
         const UINT32 numInputEntries = 0,
         const UINT32 numOutputEntries = 0  
         );

      void Inverse (
         const DOUBLE_ARRAY<DCOMPLEX>& in, 
         DOUBLE_ARRAY<double>& outx, 
         DOUBLE_ARRAY<double>& outy, 
         const FTFORMAT format = FTFORMAT_RI,
         const UINT32 numInputEntries = 0,
         const UINT32 numOutputEntries = 0  
         );

      void Inverse (
         const DOUBLE_ARRAY<double>& inx,
         const DOUBLE_ARRAY<double>& iny,
         DOUBLE_ARRAY<DCOMPLEX>& out, 
         const FTFORMAT format = FTFORMAT_RI,
         const UINT32 numInputEntries = 0,
         const UINT32 numOutputEntries = 0  
         );

      void Inverse (
         DOUBLE_ARRAY<double>& inoutx,
         DOUBLE_ARRAY<double>& inouty,
         const FTFORMAT format = FTFORMAT_RI_RI,
         const UINT32 numInputEntries = 0,
         const UINT32 numOutputEntries = 0  
         );

      void Inverse (
         const DOUBLE_ARRAY<double>& inx, 
         const DOUBLE_ARRAY<double>& iny, 
         DOUBLE_ARRAY<double>& outx, 
         DOUBLE_ARRAY<double>& outy, 
         const FTFORMAT format = FTFORMAT_RI_RI,
         const UINT32 numInputEntries = 0,
         const UINT32 numOutputEntries = 0  
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      INT32 m_NumInputEntries;
      INT32 m_NumOutputEntries;
      DOUBLE_ARRAY<DCOMPLEX> m_In;
      DOUBLE_ARRAY<DCOMPLEX> m_Out;

      UINT32 CalculateNum (
         const UINT32 numNew,
         const UINT32 numGiven,
         const UINT32 numInput
         ) const;

      bool IsValid (
         const UINT32 numInputEntries,
         const UINT32 numOutputEntries
         ) const;

      static void Copy (
         const DOUBLE_ARRAY<DCOMPLEX>& in, 
         DOUBLE_ARRAY<DCOMPLEX>& out, 
         INT32 numItems
         );

      static void Copy (
         const DOUBLE_ARRAY<DCOMPLEX>& in, 
         DOUBLE_ARRAY<double>& outx, 
         DOUBLE_ARRAY<double>& outy, 
         INT32 numItems,
         bool ri
         );

      static void Copy (
         const DOUBLE_ARRAY<double>& inx, 
         const DOUBLE_ARRAY<double>& iny, 
         DOUBLE_ARRAY<DCOMPLEX>& out, 
         INT32 numItems,
         bool ri
         );

      void Transform (
         const DOUBLE_ARRAY<DCOMPLEX>& in, 
         const UINT32 numInputs,
         DOUBLE_ARRAY<DCOMPLEX>& out,
         const UINT32 numOutputs,  
         bool forward
         );

      FT1D (const FT1D&);
      FT1D& operator= (const FT1D&);

      #endif
   };


class TIMESERIES {
   public:

      enum FLAG {
         FLAG_None = 0x0000,
         FLAG_UseFastFourierTransformation = 0x0001,
         FLAG_SmoothSeries = 0x0002,
         FLAG_RemoveTrend = 0x0004
         };
      
      enum INTERPOLATION {
         INTERPOLATION_Linear,
         INTERPOLATION_CubicSpline
         };
      
      static void SMLClassInstall (
         SML::CONTEXT *context
         );

      TIMESERIES (
         ) :
         m_Flags(FLAG_None)
         { }

      ~TIMESERIES (
         ) {
         }

      FLAG GetFlags (
         ) {
         return m_Flags;
         };

      void SetFlags (
         const FLAG flags
         ) {
         m_Flags = flags;
         };

      void SetInterpolation (
         const INTERPOLATION interpolation
         ) {
         m_Interpolation = interpolation;
         return;
         };


      void Transform (
         const DOUBLE_ARRAY<double>& input, 
         DOUBLE_ARRAY<double>& outx, 
         DOUBLE_ARRAY<double>& outy, 
         const FTFORMAT format = FTFORMAT_RI,
         const UINT32 numInputEntries = 0,
         const UINT32 numOutputEntries = 0  
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      class LINEAR_INTERPOLATOR;
      class CUBICSPLINE_INTERPOLATOR;

      class INTERPOLATOR {
         public:

            enum TYPE {
               TYPE_Linear = 0,
               TYPE_CubicSpline = 1
               };

            static INTERPOLATOR& GetInterpolator (
               const TYPE type
               ) {
               if (type == TYPE_CubicSpline) return s_CubicSplineInterpolator;
               return s_LinearInterpolator;
               }

            virtual ~INTERPOLATOR (
               ) {
               }

            ERRVALUE Interpolate (
               DOUBLE_ARRAY<double>& inout,
               const INT32 numNewItems
               ) {
               DOUBLE_ARRAY<double> temp;
               int err = Interpolate(inout,temp,numNewItems);
               if (err < 0) return err;
               inout = temp;
               return 0;
               };
            
            virtual ERRVALUE Interpolate (
               const DOUBLE_ARRAY<double>& in,
               DOUBLE_ARRAY<double>& out,
               const INT32 numNewItems
               ) = 0;
            
         protected:

            INTERPOLATOR (                     
               ) {
               };

         private:

            static LINEAR_INTERPOLATOR s_LinearInterpolator;
            static CUBICSPLINE_INTERPOLATOR s_CubicSplineInterpolator;

            INTERPOLATOR (                      
               const INTERPOLATOR &rhs
               );

            INTERPOLATOR& operator= (           
               const INTERPOLATOR& rhs
               );

         };
      friend class INTERPOLATOR;

      class LINEAR_INTERPOLATOR : public INTERPOLATOR {
         public:
            LINEAR_INTERPOLATOR (                       
               ) {
               };

            ERRVALUE Interpolate (
               const DOUBLE_ARRAY<double>& in,
               DOUBLE_ARRAY<double>& out,
               const INT32 numNewItems
               );
         };

      class CUBICSPLINE_INTERPOLATOR : public INTERPOLATOR {
         public:
            CUBICSPLINE_INTERPOLATOR (                     
               ) {
               }

            ERRVALUE Interpolate (
               const DOUBLE_ARRAY<double>& in,
               DOUBLE_ARRAY<double>& out,
               const INT32 numNewItems
               );
            
         private:

            DOUBLE_ARRAY<double> m_D;
            DOUBLE_ARRAY<double> m_W;
            DOUBLE_ARRAY<double> m_P;

         };

      class SMOOTHFILTER {
         public:
            ERRVALUE Filter (
               DOUBLE_ARRAY<double>& inout
               );
         };

      class TRENDREMOVAL {
         public:
            ERRVALUE RemoveTrend (
               DOUBLE_ARRAY<double>& inout
               );
         };

      FLAG m_Flags;
      INTERPOLATION m_Interpolation;

      FFT1D m_FFT;
      FT1D m_FT;
      
      DOUBLE_ARRAY<DCOMPLEX> m_Input; 
      DOUBLE_ARRAY<double> m_Work; 
      DOUBLE_ARRAY<double> m_Temp; 

      SMOOTHFILTER m_SmoothFilter;
      TRENDREMOVAL m_TrendRemoval;

      TIMESERIES (const TIMESERIES&);                 
      TIMESERIES& operator= (const TIMESERIES&);      

      void Convert (
         const DOUBLE_ARRAY<double>& in, 
         DOUBLE_ARRAY<DCOMPLEX>& out 
         );

      UINT32 GetUpperBound (
         const UINT32 value
         ) const;

      #endif   // GENERATING_DOXYGEN_OUTPUT
   };

#ifndef GENERATING_DOXYGEN_OUTPUT
DEFINE_ENUM_OP_BITWISE(TIMESERIES::FLAG)
#endif

#endif

---