Index: trunk/archive/pslib/include/psFFT.h
===================================================================
--- trunk/archive/pslib/include/psFFT.h	(revision 317)
+++ trunk/archive/pslib/include/psFFT.h	(revision 344)
@@ -16,53 +16,53 @@
 /** 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
+    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: a 2D array using the [nx*y + x] stuff
-    void *fourier;			//!< Data in fourier space; implementation dependent
+    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;
 
 /** Constructor */
 psFFT *
-psFFTAlloc(psImage *image		//!< Image to transform
+psFFTAlloc(psImage *image		///< Image to transform
 	   );
 
 /** Constructor for 1D case */
 psFFT *
-psFFTAlloc1D(const psFloatArray *arr	//!< Array to transform
+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
+psFFTFree(psImage *out,			///< Image to write the data to, or NULL
+	  psFFT *restrict fft		///< FFT to destroy
 	  );
 
 /** Forward FFT: from real to fourier space */
 psFFT *
-psFFTForward(psFFT *fft			//!< FFT to apply (input and output)
+psFFTForward(psFFT *fft			///< FFT to apply (input and output)
 	     );
 
 /** Reverse FFT: from fourier to real space */
 psFFT *
-psFFTReverse(psFFT *fft			//!< FFT to apply (input and output)
+psFFTReverse(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
+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
+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
 		   );
 
@@ -71,29 +71,29 @@
  */
 psFFT *
-psFFTCrossCorrelate(psFFT *out		//!< Output FFT (or NULL)
-		    const psFFT *fft1, const psFFT *fft2 //!< FFTs to use in cross-correlation
+psFFTCrossCorrelate(psFFT *out		///< Output FFT (or NULL)
+		    const psFFT *fft1, const psFFT *fft2 ///< FFTs to use in cross-correlation
 		    );
 
 /** 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
+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)
+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
+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
+psFFTGetFT(psImage *out,		///< Image to write to (or NULL)
+	   const psFFT *fft		///< FFT to get Fourier transform from
 	   );