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

Timestamp:

May 7, 2004, 2:00:44 PM (22 years ago)

Author:

Paul Price

Message:

Major reworking of Fourier Transforms --- poor design previously.
Want to work with images, not some generic FFT type.

File:

• trunk/archive/pslib/include/psFFT.h (modified) (1 diff)

trunk/archive/pslib/include/psFFT.h

@@ -14 +14 @@
  */
 
-/** 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;
+/** Forward FFT an image.  Returns a complex float image. */
+psImage *
+psImageFFT(const psImage *image         ///< Image to transform
+    );
 
-/** 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: a 2D array using the [nx*y + x] stuff
-    void *fourier;                      ///< Data in fourier space; implementation dependent
-} psFFT;
+/** Forward FFT an array of floating-point numbers. */
+psFloatArray *
+psFloatArrayFFT(const psFloatArray *arr ///< Array to transform
+    );
 
-/** Constructor */
-psFFT *
-psFFTAlloc(psImage *image               ///< Image to transform
-           );
+/** Inverse FFT an image. */
+psImage *
+psImageInverseFFT(const psImage *fftImage ///< FFT-ed image to inverse-transform
+    );
 
-/** Constructor for 1D case */
-psFFT *
-psFFTAlloc1D(const psFloatArray *arr    ///< Array to transform
-             );
+/** Inverse FFT an array of complex floating-point numbers */
+psComplexArray *
+psComplexArrayInverseFFT(const psComplexArray *fftArray ///< FFT-ed array to inverse-transform
+    );
 
-/** Destructor. Returns the data in the real space as an image. */
+/** Calculate power spectrum of an image */
 psImage *
-psFFTFree(psImage *out,                 ///< Image to write the data to, or NULL
-          psFFT *restrict fft           ///< FFT to destroy
-          );
+psImagePowerSpectrum(const psImage *image ///< Image to obtain power spectrum of
+    );
 
-/** Forward FFT: from real to fourier space */
-psFFT *
-psFFTForward(psFFT *fft                 ///< FFT to apply (input and output)
-             );
+/** Calculate power spectrum of an array of floating-point numbers */
+psFloatArray *
+psFloatArrayPowerSpectrum(const psFloatArray *arr ///< Array to obtain power spectrum of
+    );
 
-/** Reverse FFT: from fourier to real space */
-psFFT *
-psFFTReverse(psFFT *fft                 ///< FFT to apply (input and output)
-             );
+/* The below functions are provided to allow cross-correlations etc. */
 
-/** 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
+/** Get the real part of an image */
+psImage *
+psImageReal(psImage *out,               ///< Image for output (or NULL)
+            const psImage *in           ///< Image to get the real part of
             );
 
-/** 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
-                   );
+/** Get the real part of an array of complex floating-point numbers */
+psFloatArray *
+psComplexArrayReal(psFloatArray *out,   ///< Array for output (or NULL)
+                   const psComplexArray *in ///< Array to get the real part of
+    );
 
-/** Calculate FFT of the cross-correlation.  Multiplication of the first FFT with the complex conjugate of
- *  the second.
- */
-psFFT *
-psFFTCrossCorrelate(psFFT *out,         ///< Output FFT (or NULL)
-                    const psFFT *fft1, const psFFT *fft2 ///< FFTs to use in cross-correlation
-                    );
+/** Get the complex conjugate of an image */
+psImage *
+psImageConjugate(psImage *out,          ///< Image for output (or NULL)
+                 const psImage *in      ///< Image to get the complex conjugate of
+    );
 
-/** Calculate FFT of the convolution.  Straight multiplication of the FFTs */
-psFFT *
-psFFTConvolve(psFFT *out,               ///< Output FFT (or NULL)
-              const psFFT *fft1, const psFFT *fft2 ///< FFTs to multiply
-              );
-
-/** Calculate power spectrum */
-psFloatArray *
-psFFTPowerSpec(psFFT *fft               ///< FFT to use (input and output)
-               );
-
-/* 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
-           );
+/** Get the complex conjugate of an array of complex floating-point numbers */
+psComplexArray *
+psComplexArrayConjugate(psComplexArray *out, ///< Array for output (or NULL)
+                        const psComplexArray *in ///< Array to get the complex conjugate of
+    );
 
 /* \} */ // End of MathGroup Functions