Class GeneralPurposeFFT_F64_1D

java.lang.Object
boofcv.alg.transform.fft.GeneralPurposeFFT_F64_1D

public class GeneralPurposeFFT_F64_1D
extends Object
Computes 1D Discrete Fourier Transform (DFT) of complex and real, double precision data. The size of the data can be an arbitrary number. The code originally comes from General Purpose FFT Package written by Takuya Ooura (http://www.kurims.kyoto-u.ac.jp/~ooura/fft.html). See below for the full history.

This code has a bit of a history. Originally from General Purpose FFT. Which was then ported into JFFTPack written by Baoshe Zhang (http://jfftpack.sourceforge.net/), and then into JTransforms by Piotr Wendykier. The major modification from JTransforms is that the SMP code has been stripped out. It might be added back in once an SMP strategy has been finalized in BoofCV.

Code License: The original license of General Purpose FFT Package is shown below. This file will fall under the same license:
 Copyright Takuya OOURA, 1996-2001

 You may use, copy, modify and distribute this code for any purpose (include commercial use) and without fee.
 Please refer to this package when you modify this code.
 
  • Constructor Summary

    Constructors
    Constructor Description
    GeneralPurposeFFT_F64_1D​(int n)
    Creates new instance of DoubleFFT_1D.
  • Method Summary

    Modifier and Type Method Description
    void complexForward​(double[] a)
    Computes 1D forward DFT of complex data leaving the result in a.
    void complexForward​(double[] a, int offa)
    Computes 1D forward DFT of complex data leaving the result in a.
    void complexInverse​(double[] a, boolean scale)
    Computes 1D inverse DFT of complex data leaving the result in a.
    void complexInverse​(double[] a, int offa, boolean scale)
    Computes 1D inverse DFT of complex data leaving the result in a.
    void realForward​(double[] a)
    Computes 1D forward DFT of real data leaving the result in a .
    void realForward​(double[] a, int offa)
    Computes 1D forward DFT of real data leaving the result in a .
    void realForwardFull​(double[] a)
    Computes 1D forward DFT of real data leaving the result in a .
    void realForwardFull​(double[] a, int offa)
    Computes 1D forward DFT of real data leaving the result in a .
    void realInverse​(double[] a, boolean scale)
    Computes 1D inverse DFT of real data leaving the result in a .
    void realInverse​(double[] a, int offa, boolean scale)
    Computes 1D inverse DFT of real data leaving the result in a .
    protected void realInverse2​(double[] a, int offa, boolean scale)  
    void realInverseFull​(double[] a, boolean scale)
    Computes 1D inverse DFT of real data leaving the result in a .
    void realInverseFull​(double[] a, int offa, boolean scale)
    Computes 1D inverse DFT of real data leaving the result in a .

    Methods inherited from class java.lang.Object

    clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
  • Constructor Details

    • GeneralPurposeFFT_F64_1D

      public GeneralPurposeFFT_F64_1D​(int n)
      Creates new instance of DoubleFFT_1D.
      Parameters:
      n - size of data
  • Method Details

    • complexForward

      public void complexForward​(double[] a)
      Computes 1D forward DFT of complex data leaving the result in a. Complex number is stored as two double values in sequence: the real and imaginary part, i.e. the size of the input array must be greater or equal 2*n. The physical layout of the input data has to be as follows:
       a[2*k] = Re[k], 
       a[2*k+1] = Im[k], 0<=k<n
       
      Parameters:
      a - data to transform
    • complexForward

      public void complexForward​(double[] a, int offa)
      Computes 1D forward DFT of complex data leaving the result in a. Complex number is stored as two double values in sequence: the real and imaginary part, i.e. the size of the input array must be greater or equal 2*n. The physical layout of the input data has to be as follows:
       a[offa+2*k] = Re[k], 
       a[offa+2*k+1] = Im[k], 0<=k<n
       
      Parameters:
      a - data to transform
      offa - index of the first element in array a
    • complexInverse

      public void complexInverse​(double[] a, boolean scale)
      Computes 1D inverse DFT of complex data leaving the result in a. Complex number is stored as two double values in sequence: the real and imaginary part, i.e. the size of the input array must be greater or equal 2*n. The physical layout of the input data has to be as follows:
       a[2*k] = Re[k], 
       a[2*k+1] = Im[k], 0<=k<n
       
      Parameters:
      a - data to transform
      scale - if true then scaling is performed
    • complexInverse

      public void complexInverse​(double[] a, int offa, boolean scale)
      Computes 1D inverse DFT of complex data leaving the result in a. Complex number is stored as two double values in sequence: the real and imaginary part, i.e. the size of the input array must be greater or equal 2*n. The physical layout of the input data has to be as follows:
       a[offa+2*k] = Re[k], 
       a[offa+2*k+1] = Im[k], 0<=k<n
       
      Parameters:
      a - data to transform
      offa - index of the first element in array a
      scale - if true then scaling is performed
    • realForward

      public void realForward​(double[] a)
      Computes 1D forward DFT of real data leaving the result in a . The physical layout of the output data is as follows:
      if n is even then
       a[2*k] = Re[k], 0<=k<n/2
       a[2*k+1] = Im[k], 0<k<n/2
       a[1] = Re[n/2]
       
      if n is odd then
       a[2*k] = Re[k], 0<=k<(n+1)/2
       a[2*k+1] = Im[k], 0<k<(n-1)/2
       a[1] = Im[(n-1)/2]
       
      This method computes only half of the elements of the real transform. The other half satisfies the symmetry condition. If you want the full real forward transform, use realForwardFull. To get back the original data, use realInverse on the output of this method.
      Parameters:
      a - data to transform
    • realForward

      public void realForward​(double[] a, int offa)
      Computes 1D forward DFT of real data leaving the result in a . The physical layout of the output data is as follows:
      if n is even then
       a[offa+2*k] = Re[k], 0<=k<n/2
       a[offa+2*k+1] = Im[k], 0<k<n/2
       a[offa+1] = Re[n/2]
       
      if n is odd then
       a[offa+2*k] = Re[k], 0<=k<(n+1)/2
       a[offa+2*k+1] = Im[k], 0<k<(n-1)/2
       a[offa+1] = Im[(n-1)/2]
       
      This method computes only half of the elements of the real transform. The other half satisfies the symmetry condition. If you want the full real forward transform, use realForwardFull. To get back the original data, use realInverse on the output of this method.
      Parameters:
      a - data to transform
      offa - index of the first element in array a
    • realForwardFull

      public void realForwardFull​(double[] a)
      Computes 1D forward DFT of real data leaving the result in a . This method computes the full real forward transform, i.e. you will get the same result as from complexForward called with all imaginary parts equal 0. Because the result is stored in a, the size of the input array must greater or equal 2*n, with only the first n elements filled with real data. To get back the original data, use complexInverse on the output of this method.
      Parameters:
      a - data to transform
    • realForwardFull

      public void realForwardFull​(double[] a, int offa)
      Computes 1D forward DFT of real data leaving the result in a . This method computes the full real forward transform, i.e. you will get the same result as from complexForward called with all imaginary part equal 0. Because the result is stored in a, the size of the input array must greater or equal 2*n, with only the first n elements filled with real data. To get back the original data, use complexInverse on the output of this method.
      Parameters:
      a - data to transform
      offa - index of the first element in array a
    • realInverse

      public void realInverse​(double[] a, boolean scale)
      Computes 1D inverse DFT of real data leaving the result in a . The physical layout of the input data has to be as follows:
      if n is even then
       a[2*k] = Re[k], 0<=k<n/2
       a[2*k+1] = Im[k], 0<k<n/2
       a[1] = Re[n/2]
       
      if n is odd then
       a[2*k] = Re[k], 0<=k<(n+1)/2
       a[2*k+1] = Im[k], 0<k<(n-1)/2
       a[1] = Im[(n-1)/2]
       
      This method computes only half of the elements of the real transform. The other half satisfies the symmetry condition. If you want the full real inverse transform, use realInverseFull.
      Parameters:
      a - data to transform
      scale - if true then scaling is performed
    • realInverse

      public void realInverse​(double[] a, int offa, boolean scale)
      Computes 1D inverse DFT of real data leaving the result in a . The physical layout of the input data has to be as follows:
      if n is even then
       a[offa+2*k] = Re[k], 0<=k<n/2
       a[offa+2*k+1] = Im[k], 0<k<n/2
       a[offa+1] = Re[n/2]
       
      if n is odd then
       a[offa+2*k] = Re[k], 0<=k<(n+1)/2
       a[offa+2*k+1] = Im[k], 0<k<(n-1)/2
       a[offa+1] = Im[(n-1)/2]
       
      This method computes only half of the elements of the real transform. The other half satisfies the symmetry condition. If you want the full real inverse transform, use realInverseFull.
      Parameters:
      a - data to transform
      offa - index of the first element in array a
      scale - if true then scaling is performed
    • realInverseFull

      public void realInverseFull​(double[] a, boolean scale)
      Computes 1D inverse DFT of real data leaving the result in a . This method computes the full real inverse transform, i.e. you will get the same result as from complexInverse called with all imaginary part equal 0. Because the result is stored in a, the size of the input array must greater or equal 2*n, with only the first n elements filled with real data.
      Parameters:
      a - data to transform
      scale - if true then scaling is performed
    • realInverseFull

      public void realInverseFull​(double[] a, int offa, boolean scale)
      Computes 1D inverse DFT of real data leaving the result in a . This method computes the full real inverse transform, i.e. you will get the same result as from complexInverse called with all imaginary part equal 0. Because the result is stored in a, the size of the input array must greater or equal 2*n, with only the first n elements filled with real data.
      Parameters:
      a - data to transform
      offa - index of the first element in array a
      scale - if true then scaling is performed
    • realInverse2

      protected void realInverse2​(double[] a, int offa, boolean scale)