FourierTransform Class Reference

Collaboration diagram for FourierTransform:

Classes
class	Workspace

Public Types
typedef std::vector< double >	double1d_t
typedef std::vector< double1d_t >	double2d_t

Public Member Functions
	FourierTransform ()
void	fft (const double1d_t &source, double1d_t &result)
void	fftshift (double1d_t &result)
void	fft (const double2d_t &source, double2d_t &result)
void	fftshift (double2d_t &result)
void	init (int h_src, int w_src)

Private Member Functions
void	fftw_forward_FT (const double2d_t &source)

Private Attributes
Workspace	ws

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 34 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 38 of file FourierTransform.h.

double2d_t

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

definition of 2D vector of double

Definition at line 41 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 124 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 Exceptions::RuntimeErrorException("FourierTransform::fft -> Panic in 1d");
 
    result = result2d[0];
}

Referenced by IntensityDataFunctions::FT2DArray().

fftshift() [1/2]

void FourierTransform::fftshift

(

double1d_t &

result

)

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

Definition at line 142 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());
}

Referenced by IntensityDataFunctions::FT2DArray().

fft() [2/2]

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

FT in 2D.

Definition at line 59 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() [2/2]

void FourierTransform::fftshift

(

double2d_t &

result

)

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

Definition at line 96 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.

init()

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

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

Definition at line 157 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 Exceptions::RuntimeErrorException(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 Exceptions::RuntimeErrorException(
            "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:

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

{
    if (ws.h_fftw <= 0 || ws.w_fftw <= 0)
        throw Exceptions::RuntimeErrorException(
            "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().

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/www/ba/Device/Instrument/FourierTransform.h
• /home/www/ba/Device/Instrument/FourierTransform.cpp