FourierTransformer Class Reference

#include <xmipp_fftw.h>

Collaboration diagram for FourierTransformer:

Public Member Functions
	FourierTransformer ()
	FourierTransformer (const FourierTransformer &fTransform)
	FourierTransformer (int _normSign)
FourierTransformer &	operator= (const FourierTransformer &other)
	~FourierTransformer ()
void	setThreadsNumber (int tNumber)
void	changeThreadsNumber (int tNumber)
void	destroyThreads (void)
template<typename T , typename T1 >
void	FourierTransform (T &v, T1 &V, bool getCopy=true)
void	FourierTransform ()
void	enforceHermitianSymmetry ()
void	inverseFourierTransform ()
template<typename T , typename T1 >
void	inverseFourierTransform (T &V, T1 &v)
template<typename T >
void	getFourierAlias (T &V)
template<typename T >
void	setFourierAlias (T &V)
template<typename T >
void	getFourierCopy (T &V)
template<typename T >
void	getCompleteFourier (T &V)
template<typename T , typename T1 >
void	completeFourierTransform (T &v, T1 &V)
template<typename T >
void	setFromCompleteFourier (T &V)
void	init ()
void	clear ()
void	cleanup (void)
void	recomputePlanR2C ()
void	Transform (int sign)
const MultidimArray< double > &	getReal () const
const MultidimArray< std::complex< double > > &	getComplex () const
void	setReal (MultidimArray< double > &img)
void	setReal (MultidimArray< std::complex< double > > &img)
void	setFourier (const MultidimArray< std::complex< double > > &imgFourier)
void	setNormalizationSign (int _normSign)

Public Attributes
MultidimArray< double > *	fReal
MultidimArray< std::complex< double > > *	fComplex
MultidimArray< std::complex< double > >	fFourier
fftw_plan	fPlanForward
fftw_plan	fPlanBackward
int	nthreads
bool	threadsSetOn
int	normSign
double *	dataPtr
std::complex< double > *	complexDataPtr

Detailed Description

Fourier Transformer class.

The memory for the Fourier transform is handled by this object. However, the memory for the real space image is handled externally and this object only has a pointer to it.

Here you have an example of use

FourierTransformer transformer;
MultidimArray< std::complex<double> > Vfft;
transformer.FourierTransform(V(),Vfft,false);
MultidimArray<double> Vmag;
Vmag.resize(Vfft);
FOR_ALL_ELEMENTS_IN_ARRAY3D(Vmag)
    Vmag(k,i,j)=20*log10(abs(Vfft(k,i,j)));

Definition at line 60 of file xmipp_fftw.h.

Constructor & Destructor Documentation

FourierTransformer() [1/3]

FourierTransformer::FourierTransformer

(

)

Default constructor

Definition at line 38 of file xmipp_fftw.cpp.

{
    init();
    nthreads=1;
    pthread_mutex_lock(&fftw_plan_mutex);
    nInstances++;
    pthread_mutex_unlock(&fftw_plan_mutex);
    threadsSetOn=false;
    normSign = FFTW_FORWARD;
}

FourierTransformer() [2/3]

FourierTransformer::FourierTransformer

(

const FourierTransformer &

fTransform

)

Copy constructor

Definition at line 60 of file xmipp_fftw.cpp.

{
    REPORT_ERROR(ERR_UNCLASSIFIED,"Fourier transformers should not be copied");
}

FourierTransformer() [3/3]

FourierTransformer::FourierTransformer

(

int

_normSign

)

Constructor setting the sign of normalization application

Definition at line 49 of file xmipp_fftw.cpp.

{
    init();
    pthread_mutex_lock(&fftw_plan_mutex);
    nInstances++;
    pthread_mutex_unlock(&fftw_plan_mutex);
    nthreads=1;
    threadsSetOn=false;
    normSign = _normSign;
}

~FourierTransformer()

FourierTransformer::~FourierTransformer

(

)

Destructor

Definition at line 93 of file xmipp_fftw.cpp.

{
    clear();

    pthread_mutex_lock(&fftw_plan_mutex);
    nInstances--;

    // Check if a plan was already created.
    if (planCreated)
    {
        // Check if this is last instance of a FFT.
        if (nInstances == 0)
        {
            destroyThreads();
            planCreated = false;
            // Don't call cleanup.
            // There might be other transformers, and this call would
            // invalidate it's plans
//          cleanup();
        }
    }
    pthread_mutex_unlock(&fftw_plan_mutex);
}

Member Function Documentation

changeThreadsNumber()

void FourierTransformer::changeThreadsNumber ( int  tNumber )

inline

Change Number of threads.

The nthreads argument indicates the number of threads you want FFTW to use (or actually, the maximum number). All plans subsequently created with any planner routine will use that many threads. You can call fftw_plan_with_nthreads, create some plans, call fftw_plan_with_nthreads again with a different argument, and create some more plans for a new number of threads. Plans already created before a call to fftw_plan_with_nthreads are unaffected. If you pass an nthreads argument of 1 (the default), threads are disabled for subsequent plans.

Definition at line 142 of file xmipp_fftw.h.

    {
        nthreads = tNumber;
        fftw_plan_with_nthreads(nthreads);
    }

cleanup()

void FourierTransformer::cleanup ( void  )

inline

FFTW's planner saves some other persistent data, such as the accumulated wisdom and a list of algorithms available in the current configuration. If you want to deallocate all of that and reset FFTW to the pristine state it was in when you started your program, you can call:

Definition at line 370 of file xmipp_fftw.h.

    {
        fftw_cleanup();
    }

clear()

void FourierTransformer::clear

(

)

Clear object

Definition at line 79 of file xmipp_fftw.cpp.

{
    fFourier.clear();
    // Anything to do with plans has to be protected for threads!
    pthread_mutex_lock(&fftw_plan_mutex);
    if (fPlanForward !=NULL)
        fftw_destroy_plan(fPlanForward);
    if (fPlanBackward!=NULL)
        fftw_destroy_plan(fPlanBackward);
    pthread_mutex_unlock(&fftw_plan_mutex);

    init();
}

completeFourierTransform()

template<typename T , typename T1 >

void FourierTransformer::completeFourierTransform ( T &  v, T1 &  V  )

inline

Compute the Fourier transform of a MultidimArray, 2D and 3D and returns a complete copy.

Definition at line 315 of file xmipp_fftw.h.

    {
        setReal(v);
        Transform(FFTW_FORWARD);
        getCompleteFourier(V);
    }

destroyThreads()

void FourierTransformer::destroyThreads ( void  )

inline

Destroy Threads. Do not execute any previously created plans after calling this function

Definition at line 150 of file xmipp_fftw.h.

    {
        nthreads = 1;
        if(threadsSetOn)
            fftw_cleanup_threads();

        threadsSetOn=false;
    }

enforceHermitianSymmetry()

void FourierTransformer::enforceHermitianSymmetry

(

)

Inforce Hermitian symmetry. If the Fourier transform risks of losing Hermitian symmetry, use this function to renforce it.

Definition at line 335 of file xmipp_fftw.cpp.

{
    int ndim=3;
    int Zdim=ZSIZE(*fReal);
    int Ydim=YSIZE(*fReal);
    if (Zdim==1)
    {
        ndim=2;
        if (Ydim==1)
            ndim=1;
    }
    int yHalf=Ydim/2;
    if (Ydim%2==0)
        yHalf--;
    int zHalf=Zdim/2;
    if (Zdim%2==0)
        zHalf--;
    switch (ndim)
    {
    case 2:
        for (int i=1; i<=yHalf; i++)
        {
            int isym=intWRAP(-i,0,Ydim-1);
            std::complex<double> mean=0.5*(
                                          DIRECT_A2D_ELEM(fFourier,i,0)+
                                          conj(DIRECT_A2D_ELEM(fFourier,isym,0)));
            DIRECT_A2D_ELEM(fFourier,i,0)=mean;
            DIRECT_A2D_ELEM(fFourier,isym,0)=conj(mean);
        }
        break;
    case 3:
        for (int k=0; k<Zdim; k++)
        {
            int ksym=intWRAP(-k,0,Zdim-1);
            for (int i=1; i<=yHalf; i++)
            {
                int isym=intWRAP(-i,0,Ydim-1);
                std::complex<double> mean=0.5*(
                                              DIRECT_A3D_ELEM(fFourier,k,i,0)+
                                              conj(DIRECT_A3D_ELEM(fFourier,ksym,isym,0)));
                DIRECT_A3D_ELEM(fFourier,k,i,0)=mean;
                DIRECT_A3D_ELEM(fFourier,ksym,isym,0)=conj(mean);
            }
        }
        for (int k=1; k<=zHalf; k++)
        {
            int ksym=intWRAP(-k,0,Zdim-1);
            std::complex<double> mean=0.5*(
                                          DIRECT_A3D_ELEM(fFourier,k,0,0)+
                                          conj(DIRECT_A3D_ELEM(fFourier,ksym,0,0)));
            DIRECT_A3D_ELEM(fFourier,k,0,0)=mean;
            DIRECT_A3D_ELEM(fFourier,ksym,0,0)=conj(mean);
        }
        break;
    }
}

FourierTransform() [1/2]

template<typename T , typename T1 >

void FourierTransformer::FourierTransform ( T &  v, T1 &  V, bool  getCopy = true  )

inline

Compute the Fourier transform of a MultidimArray, 2D and 3D. If getCopy is false, an alias to the transformed data is returned. This is a faster option since a copy of all the data is avoided, but you need to be careful that an inverse Fourier transform may change the data.

Definition at line 166 of file xmipp_fftw.h.

    {
        setReal(v);
        Transform(FFTW_FORWARD);
        if (getCopy)
            getFourierCopy(V);
        else
            getFourierAlias(V);
    }

FourierTransform() [2/2]

void FourierTransformer::FourierTransform

(

)

Compute the Fourier transform. The data is taken from the matrix with which the object was created.

Definition at line 324 of file xmipp_fftw.cpp.

{
    Transform(FFTW_FORWARD);
}

getCompleteFourier()

template<typename T >

void FourierTransformer::getCompleteFourier ( T &  V )

inline

Return a complete Fourier transform (two halves).

Definition at line 234 of file xmipp_fftw.h.

    {
        V.resizeNoCopy(*fReal);
        int ndim=3;
        if (ZSIZE(*fReal)==1)
        {
            ndim=2;
            if (YSIZE(*fReal)==1)
                ndim=1;
        }
        double *ptrSource=NULL;
        double *ptrDest=NULL;
        switch (ndim)
        {
        case 1:
            FOR_ALL_DIRECT_ELEMENTS_IN_ARRAY1D(V)
            {
                ptrDest=(double*)&DIRECT_A1D_ELEM(V,i);
                if (i<XSIZE(fFourier))
                {
                    ptrSource=(double*)&DIRECT_A1D_ELEM(fFourier,i);
                    *ptrDest=*ptrSource;
                    *(ptrDest+1)=*(ptrSource+1);
                }
                else
                {
                    ptrSource=(double*)&DIRECT_A1D_ELEM(fFourier,XSIZE(*fReal)-i);
                    *ptrDest=*ptrSource;
                    *(ptrDest+1)=-(*(ptrSource+1));
                }
            }
            break;
        case 2:
            FOR_ALL_DIRECT_ELEMENTS_IN_ARRAY2D(V)
            {
                ptrDest=(double*)&DIRECT_A2D_ELEM(V,i,j);
                if (j<XSIZE(fFourier))
                {
                    ptrSource=(double*)&DIRECT_A2D_ELEM(fFourier,i,j);
                    *ptrDest=*ptrSource;
                    *(ptrDest+1)=*(ptrSource+1);
                }
                else
                {
                    ptrSource=(double*)&DIRECT_A2D_ELEM(fFourier,
                                                        (YSIZE(*fReal)-i)%YSIZE(*fReal),
                                                        XSIZE(*fReal)-j);
                    *ptrDest=*ptrSource;
                    *(ptrDest+1)=-(*(ptrSource+1));
                }
            }
            break;
        case 3:
            FOR_ALL_DIRECT_ELEMENTS_IN_ARRAY3D(V)
            {
                ptrDest=(double*)&DIRECT_A3D_ELEM(V,k,i,j);
                if (j<XSIZE(fFourier))
                {
                    ptrSource=(double*)&DIRECT_A3D_ELEM(fFourier,k,i,j);
                    *ptrDest=*ptrSource;
                    *(ptrDest+1)=*(ptrSource+1);
                }
                else
                {
                    ptrSource=(double*)&DIRECT_A3D_ELEM(fFourier,
                                                        (ZSIZE(*fReal)-k)%ZSIZE(*fReal),
                                                        (YSIZE(*fReal)-i)%YSIZE(*fReal),
                                                        XSIZE(*fReal)-j);
                    *ptrDest=*ptrSource;
                    *(ptrDest+1)=-(*(ptrSource+1));
                }
            }
            break;
        }
    }

getComplex()

const MultidimArray< std::complex< double > > & FourierTransformer::getComplex

(

)

const

Definition at line 123 of file xmipp_fftw.cpp.

{
    return (*fComplex);
}

getFourierAlias()

template<typename T >

void FourierTransformer::getFourierAlias ( T &  V )

inline

Get Fourier coefficients.

Definition at line 207 of file xmipp_fftw.h.

    {
        V.alias(fFourier);
        return;
    }

getFourierCopy()

template<typename T >

void FourierTransformer::getFourierCopy ( T &  V )

inline

Get Fourier coefficients.

Definition at line 223 of file xmipp_fftw.h.

    {
        V.resizeNoCopy(fFourier);
        memcpy(MULTIDIM_ARRAY(V),MULTIDIM_ARRAY(fFourier),
               MULTIDIM_SIZE(fFourier)*2*sizeof(double));
    }

getReal()

const MultidimArray< double > & FourierTransformer::getReal

(

)

const

Get the Multidimarray that is being used as input.

Definition at line 118 of file xmipp_fftw.cpp.

{
    return (*fReal);
}

init()

void FourierTransformer::init

(

void

)

Definition at line 69 of file xmipp_fftw.cpp.

{
    fReal=NULL;
    fComplex=NULL;
    fPlanForward     = NULL;
    fPlanBackward    = NULL;
    dataPtr          = NULL;
    complexDataPtr   = NULL;
}

inverseFourierTransform() [1/2]

void FourierTransformer::inverseFourierTransform

(

)

Compute the inverse Fourier transform. The result is stored in the same real data that was passed for the forward transform. The Fourier coefficients are taken from the internal Fourier coefficients

Definition at line 329 of file xmipp_fftw.cpp.

{
    Transform(FFTW_BACKWARD);
}

inverseFourierTransform() [2/2]

template<typename T , typename T1 >

void FourierTransformer::inverseFourierTransform ( T &  V, T1 &  v  )

inline

Compute the inverse Fourier transform. New data is provided for the Fourier coefficients and the output can be any matrix1D, 2D or 3D. It is important that the output matrix is already resized to the right size before entering in this function.

Definition at line 198 of file xmipp_fftw.h.

    {
        setReal(v);
        setFourier(V);
        Transform(FFTW_BACKWARD);
    }

operator=()

FourierTransformer & FourierTransformer::operator=

(

const FourierTransformer &

other

)

Assignment operator

Definition at line 65 of file xmipp_fftw.cpp.

{
    REPORT_ERROR(ERR_UNCLASSIFIED,"Fourier transformers should not be copied");
}

recomputePlanR2C()

void FourierTransformer::recomputePlanR2C

(

)

Recompute transformation plan. Call this method after setting real/fourier alias and before calling Transform() to correctly update this object.

Definition at line 147 of file xmipp_fftw.cpp.

{
    int ndim=3;
    if (ZSIZE(*fReal)==1)
    {
        ndim=2;
        if (YSIZE(*fReal)==1)
            ndim=1;
    }
    int N[3];
    switch (ndim)
    {
    case 1:
        N[0]=XSIZE(*fReal);
        break;
    case 2:
        N[0]=YSIZE(*fReal);
        N[1]=XSIZE(*fReal);
        break;
    case 3:
        N[0]=ZSIZE(*fReal);
        N[1]=YSIZE(*fReal);
        N[2]=XSIZE(*fReal);
        break;
    }

    pthread_mutex_lock(&fftw_plan_mutex);
    if (fPlanForward!=NULL)
        fftw_destroy_plan(fPlanForward);
    fPlanForward=NULL;
    fPlanForward = fftw_plan_dft_r2c(ndim, N, MULTIDIM_ARRAY(*fReal),
                                     (fftw_complex*) MULTIDIM_ARRAY(fFourier), FFTW_ESTIMATE);
    if (fPlanBackward!=NULL)
        fftw_destroy_plan(fPlanBackward);
    fPlanBackward=NULL;
    fPlanBackward = fftw_plan_dft_c2r(ndim, N,
                                      (fftw_complex*) MULTIDIM_ARRAY(fFourier), MULTIDIM_ARRAY(*fReal),
                                      FFTW_ESTIMATE);
    if (fPlanForward == NULL || fPlanBackward == NULL)
        REPORT_ERROR(ERR_PLANS_NOCREATE, "FFTW plans cannot be created");
    dataPtr=MULTIDIM_ARRAY(*fReal);
    planCreated = true;
    pthread_mutex_unlock(&fftw_plan_mutex);
}

setFourier()

void FourierTransformer::setFourier

(

const MultidimArray< std::complex< double > > &

imgFourier

)

Set a Multidimarray for the Fourier transform. The values of the input array are copied in the internal array. It is assumed that the container for the real image as well as the one for the Fourier array are already resized. No plan is updated.

Definition at line 249 of file xmipp_fftw.cpp.

{
    memcpy(MULTIDIM_ARRAY(fFourier),MULTIDIM_ARRAY(inputFourier),
           MULTIDIM_SIZE(inputFourier)*2*sizeof(double));
}

setFourierAlias()

template<typename T >

void FourierTransformer::setFourierAlias ( T &  V )

inline

Use input as a reference to Fourier data.

Definition at line 215 of file xmipp_fftw.h.

    {
        fFourier.alias(V);
        return;
    }

setFromCompleteFourier()

template<typename T >

void FourierTransformer::setFromCompleteFourier ( T &  V )

inline

Set one half of the FT in fFourier from the input complete Fourier transform (two halves). The fReal and fFourier already should have the right sizes

Definition at line 326 of file xmipp_fftw.h.

    {
        int ndim=3;
        if (ZSIZE(*fReal)==1)
        {
            ndim=2;
            if (YSIZE(*fReal)==1)
                ndim=1;
        }
        switch (ndim)
        {
        case 1:
            FOR_ALL_DIRECT_ELEMENTS_IN_ARRAY1D(fFourier)
            DIRECT_A1D_ELEM(fFourier,i)=DIRECT_A1D_ELEM(V,i);
            break;
        case 2:
            FOR_ALL_DIRECT_ELEMENTS_IN_ARRAY2D(fFourier)
            DIRECT_A2D_ELEM(fFourier,i,j) = DIRECT_A2D_ELEM(V,i,j);
            break;
        case 3:
            FOR_ALL_DIRECT_ELEMENTS_IN_ARRAY3D(fFourier)
            DIRECT_A3D_ELEM(fFourier,k,i,j) = DIRECT_A3D_ELEM(V,k,i,j);
            break;
        }
    }

setNormalizationSign()

void FourierTransformer::setNormalizationSign ( int  _normSign )

inline

Definition at line 416 of file xmipp_fftw.h.

    {
        normSign = _normSign;
    }

setReal() [1/2]

void FourierTransformer::setReal

(

MultidimArray< double > &

img

)

Set a Multidimarray for input. The data of img will be the one of fReal. In forward transforms it is not modified, but in backward transforms, the result will be stored in img. This means that the size of img cannot change between calls.

Definition at line 129 of file xmipp_fftw.cpp.

{
    bool updatePlan=false;
    if (fReal==NULL)
        updatePlan=true;
    else if (dataPtr!=MULTIDIM_ARRAY(input))
        updatePlan=true;
    else
        updatePlan=!(fReal->sameShape(input));
    fFourier.resizeNoCopy(ZSIZE(input),YSIZE(input),XSIZE(input)/2+1);
    fReal=&input;

    if (updatePlan)
    {
        recomputePlanR2C();
    }
}

setReal() [2/2]

void FourierTransformer::setReal

(

MultidimArray< std::complex< double > > &

img

)

Set a Multidimarray for input. The data of img will be the one of fComplex. In forward transforms it is not modified, but in backward transforms, the result will be stored in img. This means that the size of img cannot change between calls.

Definition at line 192 of file xmipp_fftw.cpp.

{
    bool recomputePlan=false;
    if (fComplex==NULL)
        recomputePlan=true;
    else if (complexDataPtr!=MULTIDIM_ARRAY(input))
        recomputePlan=true;
    else
        recomputePlan=!(fComplex->sameShape(input));
    fFourier.resizeNoCopy(input);
    fComplex=&input;

    if (recomputePlan)
    {
        int ndim=3;
        if (ZSIZE(input)==1)
        {
            ndim=2;
            if (YSIZE(input)==1)
                ndim=1;
        }
        int *N = new int[ndim];
        switch (ndim)
        {
        case 1:
            N[0]=XSIZE(input);
            break;
        case 2:
            N[0]=YSIZE(input);
            N[1]=XSIZE(input);
            break;
        case 3:
            N[0]=ZSIZE(input);
            N[1]=YSIZE(input);
            N[2]=XSIZE(input);
            break;
        }

        pthread_mutex_lock(&fftw_plan_mutex);
        if (fPlanForward!=NULL)
            fftw_destroy_plan(fPlanForward);
        fPlanForward=NULL;
        fPlanForward = fftw_plan_dft(ndim, N, (fftw_complex*) MULTIDIM_ARRAY(*fComplex),
                                     (fftw_complex*) MULTIDIM_ARRAY(fFourier), FFTW_FORWARD, FFTW_ESTIMATE);
        if (fPlanBackward!=NULL)
            fftw_destroy_plan(fPlanBackward);
        fPlanBackward=NULL;
        fPlanBackward = fftw_plan_dft(ndim, N, (fftw_complex*) MULTIDIM_ARRAY(fFourier),
                                      (fftw_complex*) MULTIDIM_ARRAY(*fComplex), FFTW_BACKWARD, FFTW_ESTIMATE);
        if (fPlanForward == NULL || fPlanBackward == NULL)
            REPORT_ERROR(ERR_PLANS_NOCREATE, "FFTW plans cannot be created");
        delete [] N;
        complexDataPtr=MULTIDIM_ARRAY(*fComplex);
        pthread_mutex_unlock(&fftw_plan_mutex);
    }
}

setThreadsNumber()

void FourierTransformer::setThreadsNumber ( int  tNumber )

inline

Set Number of threads This function, which should be called once, performs any one-time initialization required to use threads on your system.

The nthreads argument indicates the number of threads you want FFTW to use (or actually, the maximum number). All plans subsequently created with any planner routine will use that many threads. You can call fftw_plan_with_nthreads, create some plans, call fftw_plan_with_nthreads again with a different argument, and create some more plans for a new number of threads. Plans already created before a call to fftw_plan_with_nthreads are unaffected. If you pass an nthreads argument of 1 (the default), threads are disabled for subsequent plans.

Definition at line 119 of file xmipp_fftw.h.

    {
        if (tNumber!=1)
        {
            threadsSetOn=true;
            nthreads = tNumber;
            if(fftw_init_threads()==0)
                REPORT_ERROR(ERR_THREADS_NOTINIT, (std::string)"FFTW cannot init threads (setThreadsNumber)");
            fftw_plan_with_nthreads(nthreads);
        }
    }

Transform()

void FourierTransformer::Transform

(

int

sign

)

Computes the transform, specified in Init() function If normalization=true the forward transform is normalized (no normalization is made in the inverse transform) If normalize=false no normalization is performed and therefore the image is scaled by the number of pixels.

Definition at line 256 of file xmipp_fftw.cpp.

{
    if (sign == FFTW_FORWARD)
    {
        fftw_execute(fPlanForward);

        if (sign == normSign)
        {
            unsigned long int size=0;
            if(fReal!=NULL)
                size = MULTIDIM_SIZE(*fReal);
            else if (fComplex!= NULL)
                size = MULTIDIM_SIZE(*fComplex);
            else
                REPORT_ERROR(ERR_UNCLASSIFIED,"No complex nor real data defined");

            double isize=1.0/size;
            double *ptr=(double*)MULTIDIM_ARRAY(fFourier);
            size_t nmax=(fFourier.nzyxdim/4)*4;
            for (size_t n=0; n<nmax; n+=4)
            {
                *ptr++ *= isize;
                *ptr++ *= isize;
                *ptr++ *= isize;
                *ptr++ *= isize;
                *ptr++ *= isize;
                *ptr++ *= isize;
                *ptr++ *= isize;
                *ptr++ *= isize;
            }
            for (size_t n=nmax; n<fFourier.nzyxdim; ++n)
            {
                *ptr++ *= isize;
                *ptr++ *= isize;
            }
        }
    }
    else if (sign == FFTW_BACKWARD)
    {
        fftw_execute(fPlanBackward);

        if (sign == normSign)
        {
            unsigned long int size=0;
            if(fReal!=NULL)
            {
                size = MULTIDIM_SIZE(*fReal);
                double isize=1.0/size;
                FOR_ALL_DIRECT_ELEMENTS_IN_MULTIDIMARRAY(*fReal)
                DIRECT_MULTIDIM_ELEM(*fReal,n) *= isize;
            }
            else if (fComplex!= NULL)
            {
                size = MULTIDIM_SIZE(*fComplex);
                double isize=1.0/size;
                double *ptr=(double*)MULTIDIM_ARRAY(*fComplex);
                FOR_ALL_DIRECT_ELEMENTS_IN_MULTIDIMARRAY(*fComplex)
                {
                    *ptr++ *= isize;
                    *ptr++ *= isize;
                }
            }
            else
                REPORT_ERROR(ERR_UNCLASSIFIED,"No complex nor real data defined");
        }
    }
}

Member Data Documentation

complexDataPtr

std::complex<double>* FourierTransformer::complexDataPtr

Definition at line 358 of file xmipp_fftw.h.

dataPtr

double* FourierTransformer::dataPtr

Definition at line 355 of file xmipp_fftw.h.

fComplex

MultidimArray<std::complex<double> >* FourierTransformer::fComplex

Complex array, in fact a pointer to the user array is stored.

Definition at line 67 of file xmipp_fftw.h.

fFourier

MultidimArray< std::complex<double> > FourierTransformer::fFourier

Fourier array

Definition at line 70 of file xmipp_fftw.h.

fPlanBackward

fftw_plan FourierTransformer::fPlanBackward

Definition at line 76 of file xmipp_fftw.h.

fPlanForward

fftw_plan FourierTransformer::fPlanForward

Definition at line 73 of file xmipp_fftw.h.

fReal

MultidimArray<double>* FourierTransformer::fReal

Real array, in fact a pointer to the user array is stored.

Definition at line 64 of file xmipp_fftw.h.

normSign

int FourierTransformer::normSign

Definition at line 85 of file xmipp_fftw.h.

nthreads

int FourierTransformer::nthreads

Definition at line 79 of file xmipp_fftw.h.

threadsSetOn

bool FourierTransformer::threadsSetOn

Definition at line 82 of file xmipp_fftw.h.

---

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

• xmippCore/core/xmipp_fftw.h
• xmippCore/core/xmipp_fftw.cpp