FourierTransform Class Reference

Description

Fourier transform of vectors (in 1D or 2D) using Fast Fourier Transform (fftw package).

Usage: std::vector<double> signal, result; FourierTransform ft; ft.fft(signal, result)

Given code rely on code from Jeremy Fix page, http://jeremy.fix.free.fr/spip.php?article15, see also "Efficient convolution using the Fast Fourier Transform, Application in C++" by Jeremy Fix, May 30, 2011

Definition at line 36 of file FourierTransform.h.

Collaboration diagram for FourierTransform:

Classes
class	Workspace
	Workspace for Fourier Transform. More...

Public Types
using	double1d_t = std::vector< double >
	definition of 1D vector of double More...
using	double2d_t = std::vector< double1d_t >
	definition of 2D vector of double More...

Public Member Functions
	FourierTransform ()
void	fft (const double1d_t &source, double1d_t &result)
	FT in 1D. More...
void	fft (const double2d_t &source, double2d_t &result)
	FT in 2D. More...
void	fftshift (double1d_t &result) const
	Shift low frequency to the center of 1D FT array. More...
void	fftshift (double2d_t &result) const
	Shift low frequency to the center of 2D FT array. More...
void	init (int h_src, int w_src)
	prepare arrays for 2D Fourier Transformation (FT) of the given vector More...

Private Member Functions
void	fftw_forward_FT (const double2d_t &src)
	compute FT of source using Fast Fourier transformation from fftw More...

Private Attributes
Workspace	ws
	input and output data for fftw3 More...

Member Typedef Documentation

double1d_t

using FourierTransform::double1d_t = std::vector<double>

definition of 1D vector of double

Definition at line 39 of file FourierTransform.h.

double2d_t

using FourierTransform::double2d_t = std::vector<double1d_t>

definition of 2D vector of double

Definition at line 42 of file FourierTransform.h.

Constructor & Destructor Documentation

FourierTransform()

FourierTransform::FourierTransform ( )

default

Member Function Documentation

fft() [1/2]

void FourierTransform::fft	(	const double1d_t &	source,
		double1d_t &	result
	)

FT in 1D.

Definition at line 114 of file FourierTransform.cpp.

{
    // we simply create 2d arrays with length of first dimension equal to 1, and call 2d FT
    double2d_t source2d;
    source2d.push_back(source);
 
    double2d_t result2d;
    fft(source2d, result2d);
 
    ASSERT(result2d.size() == 1);
    result = result2d[0];
}

References ASSERT.

fft() [2/2]

void FourierTransform::fft	(	const double2d_t &	source,
		double2d_t &	result
	)

FT in 2D.

Definition at line 49 of file FourierTransform.cpp.

{
    // rows (h) and columns (w) of the input 'source'
    int h_src = static_cast<int>(source.size());
    int w_src = static_cast<int>((!source.empty() ? source[0].size() : 0));
 
    // initialization
    init(h_src, w_src);
 
    // Compute the forward FT
    fftw_forward_FT(source);
 
    double* ptr = ws.out_fftw;
    result.clear();
 
    const size_t nh = ws.h_fftw;
 
    // Resize the array for holding the FT output to correct dimensions
    result.resize(nh, std::vector<double>(static_cast<size_t>(ws.w_fftw)));
 
    // Storing FT output
    for (size_t i = 0; i < nh; i++) {
        size_t k = nh - i;
        if (i == 0)
            k -= nh;
        for (size_t j = 0; j < static_cast<size_t>(ws.w_fftw / 2 + 1); j++) {
            result[i][j] = *ptr;
            size_t l = static_cast<size_t>(ws.w_fftw) - j;
            if (j != 0)
                result[k][l] = result[i][j];
            ptr += 2; // Only interested in the magnitudes of the complex Fourier coefficients
        }
    }
}

References fftw_forward_FT(), FourierTransform::Workspace::h_fftw, init(), FourierTransform::Workspace::out_fftw, FourierTransform::Workspace::w_fftw, and ws.

Here is the call graph for this function:

fftshift() [1/2]

void FourierTransform::fftshift

(

double1d_t &

result

)

const

Shift low frequency to the center of 1D FT array.

Definition at line 130 of file FourierTransform.cpp.

{
    // Centering FT around zero frequency
    size_t col_shift;
    if (result.size() % 2 == 0)
        col_shift = result.size() / 2;
    else
        col_shift = result.size() / 2 + 1;
 
    std::rotate(result.begin(), result.begin() + static_cast<int>(col_shift), result.end());
}

fftshift() [2/2]

void FourierTransform::fftshift

(

double2d_t &

result

)

const

Shift low frequency to the center of 2D FT array.

Definition at line 87 of file FourierTransform.cpp.

{
    // Centering FT around zero frequency
    size_t row_shift;
    if (result.size() % 2 == 0)
        row_shift = result.size() / 2;
    else
        row_shift = result.size() / 2 + 1;
 
    size_t col_shift;
    if (result[0].size() % 2 == 0)
        col_shift = result[0].size() / 2;
    else
        col_shift = result[0].size() / 2 + 1;
 
    // First, shifting the rows
    std::rotate(result.begin(), result.begin() + static_cast<int>(row_shift), result.end());
 
    // Second, shifting the cols
    for (size_t i = 0; i < static_cast<size_t>(ws.h_fftw); i++)
        std::rotate(result[i].begin(), result[i].begin() + static_cast<int>(col_shift),
                    result[i].end());
}

References FourierTransform::Workspace::h_fftw, and ws.

fftw_forward_FT()

void FourierTransform::fftw_forward_FT ( const double2d_t &  src )

private

compute FT of source using Fast Fourier transformation from fftw

Definition at line 174 of file FourierTransform.cpp.

{
    ASSERT(ws.h_fftw > 0);
    ASSERT(ws.w_fftw > 0);
 
    double *ptr, *ptr_end;
 
    // Initializing the content of ws.in_src to zero for all elements
    for (ptr = ws.in_src, ptr_end = ws.in_src + ws.h_fftw * ws.w_fftw; ptr != ptr_end; ++ptr)
        *ptr = 0.0;
 
    // Building the input signal for fftw algorithm
    for (size_t row = 0; row < static_cast<size_t>(ws.h_src); ++row)
        for (size_t col = 0; col < static_cast<size_t>(ws.w_src); ++col)
            ws.in_src[(static_cast<int>(row) % ws.h_fftw) * ws.w_fftw
                      + (static_cast<int>(col) % ws.w_fftw)] += src[row][col];
 
    // Computing the FFT with fftw plan
    fftw_execute(ws.p_forw_src);
 
    for (ptr = ws.out_fftw, ptr_end = ws.out_fftw + 2 * ws.h_fftw * (ws.w_fftw / 2 + 1);
         ptr != ptr_end; ++ptr) {
        double re_out = *ptr;
        double im_out = *(++ptr);
 
        // magnitude
        *(ptr - 1) = sqrt(re_out * re_out + im_out * im_out);
        // phase
        *ptr = atan2(im_out, re_out);
    }
}

References ASSERT, FourierTransform::Workspace::h_fftw, FourierTransform::Workspace::h_src, FourierTransform::Workspace::in_src, FourierTransform::Workspace::out_fftw, FourierTransform::Workspace::p_forw_src, FourierTransform::Workspace::w_fftw, FourierTransform::Workspace::w_src, and ws.

Referenced by fft().

init()

void FourierTransform::init	(	int	h_src,
		int	w_src
	)

prepare arrays for 2D Fourier Transformation (FT) of the given vector

Definition at line 145 of file FourierTransform.cpp.

{
    ASSERT(h_src);
    ASSERT(w_src);
 
    ws.clear();
    ws.h_src = h_src;
    ws.w_src = w_src;
 
    ws.h_fftw = h_src;
    ws.w_fftw = w_src;
 
    ws.in_src = new double[static_cast<size_t>(ws.h_fftw * ws.w_fftw)];
    ws.out_fftw = static_cast<double*>(
        fftw_malloc(sizeof(fftw_complex) * static_cast<size_t>(ws.h_fftw * (ws.w_fftw / 2 + 1))));
 
    // Initialization of the plans
    ws.p_forw_src = fftw_plan_dft_r2c_2d(ws.h_fftw, ws.w_fftw, ws.in_src,
                                         (fftw_complex*)ws.out_fftw, FFTW_ESTIMATE);
    // ws.p_forw_src = fftw_plan_dft_r2c_2d(ws.h_fftw, ws.w_fftw, ws.in_src,
    //                                     static_cast<double*>(ws.out_src), FFTW_ESTIMATE);
 
    ASSERT(ws.p_forw_src);
}

References ASSERT, FourierTransform::Workspace::clear(), FourierTransform::Workspace::h_fftw, FourierTransform::Workspace::h_src, FourierTransform::Workspace::in_src, FourierTransform::Workspace::out_fftw, FourierTransform::Workspace::p_forw_src, FourierTransform::Workspace::w_fftw, FourierTransform::Workspace::w_src, and ws.

Referenced by fft().

Here is the call graph for this function:

Member Data Documentation

ws

Workspace FourierTransform::ws

private

input and output data for fftw3

Definition at line 91 of file FourierTransform.h.

Referenced by fft(), fftshift(), fftw_forward_FT(), and init().

---

The documentation for this class was generated from the following files:

• /home/build/builds/o5h8MZZm/0/mlz/bornagain/Base/Math/FourierTransform.h
• /home/build/builds/o5h8MZZm/0/mlz/bornagain/Base/Math/FourierTransform.cpp