Changeset 314 for trunk/archive/pslib/include/psFFT.h

Timestamp:

Mar 29, 2004, 7:40:01 PM (22 years ago)

Author:

Paul Price

Message:

Major hack of the FFT APIs, incorporating Nick's comments: Defined a
FFT type, on which all the FFT operations act. This insulates us from
the details of the implementation (e.g., FFTW requires a "plan";
different FFT libraries store the transformed data differently).
Added the functionality Nick suggested (filtering, cross-correlation).

File:

• trunk/archive/pslib/include/psFFT.h (modified) (2 diffs)

trunk/archive/pslib/include/psFFT.h

@@ -1 +1 @@
 #if !defined(PS_FFT_H)
 #define PS_FFT_H
+
+#include <fftw3.h>
 
 /** \file psFFT.h
@@ -12 +14 @@
  */
 
-/** Return Fourier Transform of an array */
-psComplexArray *
-psRealFFT(psComplexArray *restrict out, //!< Output array to be returned; may be NULL
-          const psFloatArray *restrict myArray //!< Input array
+/** Details on FFT implementation (private).  Example shown is for FFTW */
+typedef struct {
+    fftw_plan plan;                     //!< FFTW plan on how to do the FFT
+    char *filename;                     //!< File name for FFTW plan
+} p_psFFTDetails;
+
+/** Fast Fourier Transform */
+typedef struct {
+    p_psFFTDetails *details;            //!< Details on FFT implementation (private)
+    int nx, ny;                         //!< Size in x and y
+    float **real;                       //!< Data in real space
+    void *fourier;                      //!< Data in fourier space; implementation dependent
+} psFFT;
+
+/** Constructor */
+psFFT *
+psFFTAlloc(psImage *image               //!< Image to transform
+           );
+
+/** Constructor for 1D case */
+psFFT *
+psFFTAlloc1D(const psFloatArray *arr    //!< Array to transform
+             );
+
+/** Destructor. Returns the data in the real space as an image. */
+psImage *
+psFFTFree(psImage *out,                 //!< Image to write the data to, or NULL
+          psFFT *restrict fft           //!< FFT to destroy
           );
 
-/** Return [inverse?] Fourier Transform of a complex array.  May NOT be done in-place (restrict-ed) */
-psComplexArray *
-psComplexFFT(psComplexArray *restrict out, //!< Output array to be returned; may be NULL
-             const psComplexArray *restrict myArray, //!< Input array
-             int sign                   //!< +1 or -1 to indicate direction of FT
-             );
+/** Forward FFT: from real to fourier space */
+psFFT *
+psFFTForwardTransform(psFFT *fft        //!< FFT to apply (input and output)
+                      );
 
-/** Return Power spectrum of a array */
-psFloatArray *
-psPowerSpec(psFloatArray *restrict out, //!< Output array to be returned
-            const psFloatArray *restrict myArray //!< Input array
+/** Reverse FFT: from fourier to real space */
+psFFT *
+psFFTReverseTransform(psFFT *fft        //!< FFT to apply (input and output)
+                      );
+
+/** Apply filter function in fourier space */
+psFFT *
+psFFTFilter(psFFT *fft,                 //!< FFT to use (input and output)
+            float (*filterFunc)(int kx, int ky) //!< External filter function
             );
+
+/** Apply complex filter function */
+psFFT *
+psFFTFilterComplex(psFFT *fft,          //!< FFT to use (input and output)
+                   float (*realFilterFunc)(int kx, int ky), //!< External filter function, real part
+                   float (*imagFilterFunc)(int kx, int ky) //!< External filter function, imaginary part
+                   );
+
+/** Calculate cross-correlation function */
+psFFT *
+psFFTCrossCorrelate(psFFT *out          //!< Output FFT (or NULL)
+                    const psFFT *fft1, const psFFT *fft2 //!< FFTs to use in cross-correlation
+                    );
+
+/** Calculate power spectrum */
+psFFT *
+psFFTPowerSpec(psFFT *fft               //!< FFT to use (input and output)
+               );
+
+/** Multiply two Fourier transforms, as for convolution */
+psFFT *
+psFFTMultiplyFT(psFFT *out,             //!< Output FFT (or NULL)
+                const psFFT *fft1, const psFFT *fft2 //!< FFTs to multiply
+                );
+
+/* Convert the real data in the FFT struct to an image again */
+psImage *
+psFFTGetImage(psImage *out,             //!< Image to write to (or NULL)
+              const psFFT *fft          //!< FFT to get image from
+              );
+
+/** Convert the Fourier transform data in the FFT struct to an image of complex numbers */
+psImage *
+psFFTGetFT(psImage *out,                //!< Image to write to (or NULL)
+           const psFFT *fft             //!< FFT to get Fourier transform from
+           );
 
 /* \} */ // End of MathGroup Functions
 
 #endif
+
+