Index: trunk/archive/pslib/include/psFFT.h
===================================================================
--- trunk/archive/pslib/include/psFFT.h	(revision 613)
+++ trunk/archive/pslib/include/psFFT.h	(revision 671)
@@ -14,59 +14,78 @@
  */
 
-/** 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