FourierTransform Class Reference

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

Collaboration diagram for FourierTransform:

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

Public Types
typedef std::vector< double >	double1d_t
	definition of 1D vector of double More...
typedef std::vector< double1d_t >	double2d_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)
	Shift low frequency to the center of 1D FT array. More...
void	fftshift (double2d_t &result)
	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 &source)
	compute FT of source using Fast Fourier transformation from fftw More...

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

Detailed 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 39 of file FourierTransform.h.

Member Typedef Documentation

double1d_t

typedef std::vector<double> FourierTransform::double1d_t

definition of 1D vector of double

Definition at line 42 of file FourierTransform.h.

double2d_t

typedef std::vector<double1d_t> FourierTransform::double2d_t

definition of 2D vector of double

Definition at line 45 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 123 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);
 
    if (result2d.size() != 1)
        throw std::runtime_error("FourierTransform::fft -> Panic in 1d");
 
    result = result2d[0];
}

fft() [2/2]

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

FT in 2D.

Definition at line 58 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.size() ? source[0].size() : 0));
 
    // initialisation
    init(h_src, w_src);
 
    // Compute the forward FT
    fftw_forward_FT(source);
 
    double* ptr = ws.out_fftw;
    result.clear();
 
    // Resize the array for holding the FT output to correct dimensions
    result.resize(static_cast<size_t>(ws.h_fftw),
                  std::vector<double>(static_cast<size_t>(ws.w_fftw)));
 
    // Storing FT output
    for (size_t i = 0; i < static_cast<size_t>(ws.h_fftw); i++) {
        size_t k = static_cast<size_t>(ws.h_fftw) - i;
        if (i == 0)
            k -= static_cast<size_t>(ws.h_fftw);
        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

)

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

Definition at line 141 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

)

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

Definition at line 95 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 &  source )

private

compute FT of source using Fast Fourier transformation from fftw

Definition at line 191 of file FourierTransform.cpp.

{
    if (ws.h_fftw <= 0 || ws.w_fftw <= 0)
        throw std::runtime_error(
            "FourierTransform::fftw_forward_FT() -> Panic! Initialisation is missed.");
 
    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);
 
    double re_out, im_out;
    for (ptr = ws.out_fftw, ptr_end = ws.out_fftw + 2 * ws.h_fftw * (ws.w_fftw / 2 + 1);
         ptr != ptr_end; ++ptr) {
        re_out = *ptr;
        im_out = *(++ptr);
 
        // magnitude
        *(ptr - 1) = sqrt(re_out * re_out + im_out * im_out);
        // phase
        *ptr = atan2(im_out, re_out);
    }
}

References 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 156 of file FourierTransform.cpp.

{
    if (!h_src || !w_src) {
        std::ostringstream os;
        os << "FourierTransform::init() -> Panic! Wrong dimensions " << h_src << " " << w_src
           << std::endl;
        throw std::runtime_error(os.str());
    }
 
    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);
 
    if (ws.p_forw_src == nullptr)
        throw std::runtime_error(
            "FourierTransform::init() -> Error! Can't initialise p_forw_src plan.");
}

References 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 94 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/www/ba/Base/Math/FourierTransform.h
• /home/www/ba/Base/Math/FourierTransform.cpp