FFTUtils.h

Go to the documentation of this file.

/********************************************************************
**                Image Component Library (ICL)                    **
**                                                                 **
** Copyright (C) 2006-2013 CITEC, University of Bielefeld          **
**                         Neuroinformatics Group                  **
** Website: www.iclcv.org and                                      **
**          http://opensource.cit-ec.de/projects/icl               **
**                                                                 **
** File   : ICLMath/src/ICLMath/FFTUtils.h                         **
** Module : ICLMath                                                **
** Authors: Christian Groszewski, Christof Elbrechter              **
**                                                                 **
**                                                                 **
** GNU LESSER GENERAL PUBLIC LICENSE                               **
** This file may be used under the terms of the GNU Lesser General **
** Public License version 3.0 as published by the                  **
**                                                                 **
** Free Software Foundation and appearing in the file LICENSE.LGPL **
** included in the packaging of this file.  Please review the      **
** following information to ensure the license requirements will   **
** be met: http://www.gnu.org/licenses/lgpl-3.0.txt                **
**                                                                 **
** The development of this software was supported by the           **
** Excellence Cluster EXC 277 Cognitive Interaction Technology.    **
** The Excellence Cluster EXC 277 is a grant of the Deutsche       **
** Forschungsgemeinschaft (DFG) in the context of the German       **
** Excellence Initiative.                                          **
**                                                                 **
********************************************************************/

#pragma once

#include <ICLUtils/CompatMacros.h>
#include <ICLUtils/BasicTypes.h>
#include <ICLMath/DynMatrix.h>
#include <ICLMath/FFTException.h>
#include <string.h>
#include <complex>

using namespace icl::utils;

namespace icl{
  namespace math{

  namespace fft{

  static const double FFT_2_PI = 2.0*3.1415926535897932384626433832795288419716939937510;

  static const double FFT_PI = 3.1415926535897932384626433832795288419716939937510;

  static const double FFT_PI_HALF = 1.5707963267948966192313216916397644209858469968755;


  template<typename T1,typename T2> ICLMath_IMP
  std::complex<T2>* fft(unsigned int n, const T1* data);


  template<typename T1, typename T2> ICLMath_IMP
  DynMatrix<std::complex<T2> >&  fft2D_cpp(const DynMatrix<T1> &src,
                DynMatrix<std::complex<T2> > &dst,DynMatrix<std::complex<T2> > &buf);


  template<typename T1, typename T2> ICLMath_IMP
  DynMatrix<std::complex<T2> >& fft2D(const DynMatrix<T1> &src, DynMatrix<std::complex<T2> > &dst,
                DynMatrix<std::complex<T2> > &buf);


  template<typename T1, typename T2> ICLMath_IMP
  std::complex<T2>* dft(unsigned int n, T1 *matrix);


  template<typename T1, typename T2> ICLMath_IMP
  DynMatrix<std::complex<T2> >&  dft2D(DynMatrix<T1> &src,
                DynMatrix<std::complex<T2> >& dst,DynMatrix<std::complex<T2> >&buf);


  template<typename T1, typename T2> ICLMath_IMP
  std::complex<T2>* ifft_cpp(unsigned int n, const T1* matrix);


  template<typename T1, typename T2> ICLMath_IMP
  DynMatrix<std::complex<T2> >&  ifft2D_cpp(const DynMatrix<T1>& src,
                DynMatrix<std::complex<T2> > &dst,DynMatrix<std::complex<T2> > &buf);


  template<typename T1, typename T2> ICLMath_IMP
  DynMatrix<std::complex<T2> >&   ifft2D(const DynMatrix<T1> &src, DynMatrix<std::complex<T2> > &dst,
                DynMatrix<std::complex<T2> > &buf);


  template<typename T1, typename T2> ICLMath_IMP
  std::complex<T2>* idft(unsigned int n, T1 *matrix);


  template<typename T1, typename T2> ICLMath_IMP
  DynMatrix<std::complex<T2> > &idft2D(DynMatrix<T1> &src, DynMatrix<std::complex<T2> > &dst,
                DynMatrix<std::complex<T2> > &buf);


  template<typename T> ICLMath_IMP
  DynMatrix<T>& fftshift(DynMatrix<T> &src, DynMatrix<T> &dst) ;


  template<typename T> ICLMath_IMP
  DynMatrix<T>& ifftshift(DynMatrix<T> &src, DynMatrix<T> &dst) ;


  template<typename T> ICLMath_IMP
  DynMatrix<T>& powerspectrum(const DynMatrix<std::complex<T> > &src, DynMatrix<T> &dst);


  template<typename T> ICLMath_IMP
  DynMatrix<T>& logpowerspectrum(const DynMatrix<std::complex<T> > &src, DynMatrix<T> &dst);


  template<typename T> ICLMath_IMP
  DynMatrix<T> &makeborder(const DynMatrix<T> &src, DynMatrix<T> &dst, T borderFill);


  template<typename T> ICLMath_IMP
  DynMatrix<T> &mirrorOnCenter(const DynMatrix<T> &src, DynMatrix<T> &dst);


  template<typename T> ICLMath_IMP
  DynMatrix<T> &continueMatrixToPowerOf2(const DynMatrix<T> &src, DynMatrix<T> &dst);


  ICLMath_API int nextPowerOf2(int n);

  ICLMath_API int priorPowerOf2(int n);


  template<typename T> ICLMath_IMP
  void split_complex(const DynMatrix<std::complex<T> > &src, DynMatrix<T> &real, DynMatrix<T> &img);


  template<typename T1, typename T2> ICLMath_IMP
  DynMatrix<T2> &imagpart(const DynMatrix<std::complex<T1> > &src, DynMatrix<T2> &dst);


  template<typename T1, typename T2> ICLMath_IMP
  DynMatrix<T2> &realpart(const DynMatrix<std::complex<T1> > &src, DynMatrix<T2> &dst);


  template<typename T1, typename T2> ICLMath_IMP
  DynMatrix<T2>& magnitude(const DynMatrix<std::complex<T1> > &src, DynMatrix<T2> &dst);


  template<typename T1, typename T2> ICLMath_IMP
  DynMatrix<T2>& phase(const DynMatrix<std::complex<T1> > &src, DynMatrix<T2> &dst);


  template<typename T> ICLMath_IMP
  void split_magnitude_phase(const DynMatrix<std::complex<T> > &src, DynMatrix<T> &mag, DynMatrix<T> &phase);


  template<typename T1, typename T2> ICLMath_IMP
  DynMatrix<std::complex<T2> > &joinComplex(const DynMatrix<T1> &real, const DynMatrix<T1> &im, DynMatrix<std::complex<T2> > &dst);

  } // namespace math
}
}