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

Timestamp:

May 13, 2004, 1:16:19 PM (22 years ago)

Author:

eugene

Message:

psFloatArray, psDoubleArray, psIntArray, etc merged into
psVector. psVector is analogous to psImage. reference to the old
forms have been converted to psVector. the file psStdArrays.h has
been removed and replaced with psVector.h (containing the vector
functions) and psTypes.h (containing the basic data types)

File:

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

trunk/archive/pslib/include/psFFT.h

@@ -14 +14 @@
  */
 
-/** Forward FFT an image.  Returns a complex float image. */
+/**** Image FFT & Complex functions ****/
+
+/** FFT an image.  in: psF32 or psC32, out: psC32 */
 psImage *
-psImageFFT(const psImage *image         ///< Image to transform
-    );
-
-/** Forward FFT an array of floating-point numbers. */
-psFloatArray *
-psFloatArrayFFT(const psFloatArray *arr ///< Array to transform
-    );
-
-/** Inverse FFT an image. */
-psImage *
-psImageInverseFFT(const psImage *fftImage ///< FFT-ed image to inverse-transform
-    );
-
-/** Inverse FFT an array of complex floating-point numbers */
-psComplexArray *
-psComplexArrayInverseFFT(const psComplexArray *fftArray ///< FFT-ed array to inverse-transform
-    );
+psImageFFT(const psImage *image,        ///< image to transform (if forward, may be real)
+           int dir)                     ///< FFT direction (1: forward, -1: reverse)
+;
 
 /** Calculate power spectrum of an image */
 psImage *
-psImagePowerSpectrum(const psImage *image ///< Image to obtain power spectrum of
-    );
-
-/** Calculate power spectrum of an array of floating-point numbers */
-psFloatArray *
-psFloatArrayPowerSpectrum(const psFloatArray *arr ///< Array to obtain power spectrum of
-    );
-
-/* The below functions are provided to allow cross-correlations etc. */
+psImagePowerSpectrum(const psImage *image) ///< Image to obtain power spectrum of
+;
 
 /** 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
-            );
+            const psImage *in)          ///< Image to get the real part of
+;
 
-/** 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
-    );
+/** Get the imaginary part of an image */
+psImage *
+psImageImaginary(psImage *out,          ///< Image for output (or NULL)
+                 const psImage *in)     ///< Image to get the imaginary part of
+;
+
+/** Construct a complex image from real & imaginary parts */
+psImage *
+psImageComplex(psImage *out,            ///< Image for output (or NULL)
+               const psImage *real)     ///< real part of image
+               const psImage *imag)     ///< imaginary part of image
+;
 
 /** 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
-    );
+                 const psImage *in)     ///< Image to get the complex conjugate of
+;
 
-/** 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
-    );
+/**** Vector FFT & Complex functions ****/
+
+/** FFT a vector. in: psF32 or psC32, out: psC32 */
+psVector *
+psVectorFFT(const psVector *vector)     ///< Vector to transform
+;
+
+/** Calculate power spectrum of a vector of floating-point numbers */
+psVector *
+psVectorPowerSpectrum(const psVector *vector) ///< Vector to obtain power spectrum of
+;
+
+/** Get the real part of a vector */
+psVector *
+psVectorReal(psVector *out,             ///< Vector for output (or NULL)
+             const psVector *in)        ///< Vector to get the real part of
+;
+
+/** Get the imaginary part of a vector */
+psVector *
+psVectorImaginary(psVector *out,        ///< Vector for output (or NULL)
+             const psVector *in)        ///< Vector to get the imaginary part of
+;
+
+/** Construct a complex vector from real & imaginary parts */
+psVector *
+psVectorComplex(psVector *out,          ///< Vector for output (or NULL)
+               const psVector *real)    ///< real part of vector
+               const psVector *imag)    ///< imaginary part of vector
+;
+
+/** Get the complex conjugate of an vector of complex floating-point numbers */
+psVector *
+psVectorConjugate(psVector *out,        ///< Vector for output (or NULL)
+                  const psVector *in)   ///< Vector to get the complex conjugate of
+;
 
 /* \} */ // End of MathGroup Functions