Changeset 1452

Timestamp:

Aug 10, 2004, 8:54:38 AM (22 years ago)

Author:

desonia

Message:

added doxygen comments.

Location:

trunk/psLib

Files:

• psLib.kdevses (modified) (1 diff)
• src/dataManip/psFFT.c (modified) (3 diffs)
• src/dataManip/psFFT.h (modified) (2 diffs)
• src/dataManip/psVectorFFT.c (modified) (3 diffs)
• src/dataManip/psVectorFFT.h (modified) (2 diffs)
• src/fft/psVectorFFT.c (modified) (3 diffs)
• src/fft/psVectorFFT.h (modified) (2 diffs)

trunk/psLib/psLib.kdevses

@@ -2 +2 @@
 <!DOCTYPE KDevPrjSession>
 <KDevPrjSession>
- <DocsAndViews NumberOfDocuments="0" />
+ <DocsAndViews NumberOfDocuments="1" >
+  <Doc0 NumberOfViews="1" URL="file:/home/desonia/psLib/src/dataManip/psFFT.h" >
+   <View0 line="54" Type="???" >
+    <AdditionalSettings Top="1" Width="1107" Attach="1" Height="529" Left="1" MinMaxMode="0" />
+   </View0>
+  </Doc0>
+ </DocsAndViews>
  <pluginList>
   <kdevbookmarks>

trunk/psLib/src/dataManip/psFFT.c

@@ -6 +6 @@
 *  @author Robert DeSonia, MHPCC
 *
-*  @version $Revision: 1.20 $ $Name: not supported by cvs2svn $
-*  @date $Date: 2004-08-09 23:34:57 $
+*  @version $Revision: 1.21 $ $Name: not supported by cvs2svn $
+*  @date $Date: 2004-08-10 18:54:38 $
 *
 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
@@ -211 +211 @@
 }
 
-psImage* psImageComplex(psImage* out, psImage* real, const psImage* imag)
+psImage* psImageComplex(psImage* out, const psImage* real, const psImage* imag)
 {
     psElemType type;
@@ -586 +586 @@
 }
 
-psVector* psVectorComplex(psVector* out, psVector* real, const psVector* imag)
+psVector* psVectorComplex(psVector* out, const psVector* real, const psVector* imag)
 {
     psElemType type;

trunk/psLib/src/dataManip/psFFT.h

@@ -8 +8 @@
  *  @author Robert DeSonia, MHPCC
  *
- *  @version $Revision: 1.12 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2004-08-09 23:40:55 $
+ *  @version $Revision: 1.13 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2004-08-10 18:54:38 $
  *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
@@ -23 +23 @@
 /// @{
 
-/** Details on FFT implementation (private). */
-
+/** Specify direction of FFT */
 typedef enum {
-    // / psImageFFT/psVectorFFT should perform a forward FFT.
+    /// psImageFFT/psVectorFFT should perform a forward FFT.
     PS_FFT_FORWARD = (-1),
 
-    ///< psImageFFT/psVectorFFT should perform a reverse FFT.
+    /// psImageFFT/psVectorFFT should perform a reverse FFT.
     PS_FFT_REVERSE = (+1)
 } psFftDirection;
 
-psImage* psImageFFT(psImage* out, const psImage* in, psFftDirection direction);
-psImage* psImageReal(psImage* out, const psImage* in);
-psImage* psImageImaginary(psImage* out, const psImage* in);
-psImage* psImageComplex(psImage* out, psImage* real, const psImage* imag);
-psImage* psImageConjugate(psImage* out, const psImage* in);
-psImage* psImagePowerSpectrum(psImage* out, const psImage* in);
+/** Forward and reverse FFT calculations.
+ *
+ *  This takes as input the image of interest (in) and the direction 
+ *  (direction), which is specified by an enumerated type psFftDirection.
+ *  The input image may be of type psF32 or psC32, the result is always 
+ *  psC32. If the input vector is psF32, the direction must be forward. 
+ *  
+ *  @return psImage* the FFT transformation result
+ */
+psImage* psImageFFT(
+    psImage* out,                      ///< a psImage to recycle.  If NULL, a new psImage is made.
+    const psImage* in,                 ///< the psImage to apply transform to
+    psFftDirection direction           ///< the direction of the transform
+);
 
-psVector* psVectorFFT(psVector* out, const psVector* in, psFftDirection direction);
-psVector* psVectorReal(psVector* out, const psVector* in);
-psVector* psVectorImaginary(psVector* out, const psVector* in);
-psVector* psVectorComplex(psVector* out, psVector* real, const psVector* imag);
-psVector* psVectorConjugate(psVector* out, const psVector* in);
-psVector* psVectorPowerSpectrum(psVector* out, const psVector* in);
+/** extract the real portion of a complex image
+ * 
+ *  @return psImage*   real portion of the input image.
+ */
+psImage* psImageReal(
+    psImage* out,                      ///< a psImage to recycle.  If NULL, a new psImage is made.
+    const psImage* in                  ///< the psImage to extract real portion from
+);
+
+/** extract the imaginary portion of a complex image
+ * 
+ *  @return psImage*   imaginary portion of the input image.
+ */
+psImage* psImageImaginary(
+    psImage* out,                      ///< a psImage to recycle.  If NULL, a new psImage is made.
+    const psImage* in                  ///< the psImage to extract imaginary portion from
+);
+
+/** creates a complex image from separate real and imaginary plane images
+ * 
+ *  @return psImage*   resulting complex image
+ */
+psImage* psImageComplex(
+    psImage* out,                      ///< a psImage to recycle.  If NULL, a new psImage is made.
+    const psImage* real,               ///< the real plane image
+    const psImage* imag                ///< the imaginary plane image
+);
+
+/** computes the complex conjugate of an image
+ * 
+ *  @return psImage*   the complex conjugate of the 'in' image
+ */
+psImage* psImageConjugate(
+    psImage* out,                      ///< a psImage to recycle.  If NULL, a new psImage is made.
+    const psImage* in                  ///< the psImage to compute conjugate of
+);
+
+/** computes the power spectrum of an image
+ * 
+ *  @return psImage*   the power spectrum of the 'in' image
+ */
+psImage* psImagePowerSpectrum(
+    psImage* out,                       ///< a psImage to recycle.  If NULL, a new psImage is made.
+    const psImage* in                   ///< the psImage to power spectrum of
+);
+
+/** Forward and reverse FFT calculations.
+ *
+ *  This takes as input the vector of interest (in) and the direction 
+ *  (direction), which is specified by an enumerated type psFftDirection.
+ *  The input vector may be of type psF32 or psC32, the result is always 
+ *  psC32. If the input vector is psF32, the direction must be forward. 
+ *  
+ *  @return psVector* the FFT transformation result
+ */
+psVector* psVectorFFT(
+    psVector* out,                     ///< a psVector to recycle.  If NULL, a new psVector is made.
+    const psVector* in,                ///< the vector to apply transform to
+    psFftDirection direction           ///< the direction of the transform
+);
+
+/** extract the real portion of a complex vector
+ * 
+ *  @return psVector*   real portion of the input vector.
+ */
+psVector* psVectorReal(
+    psVector* out,                     ///< a psVector to recycle.  If NULL, a new psVector is made.
+    const psVector* in                ///< the psVector to extract real portion from
+);
+
+/** extract the imaginary portion of a complex vector
+ * 
+ *  @return psVector*   imaginary portion of the input vector.
+ */
+psVector* psVectorImaginary(
+    psVector* out,                     ///< a psVector to recycle.  If NULL, a new psVector is made.
+    const psVector* in                 ///< the psVector to extract imaginary portion from
+);
+
+/** creates a complex vector from separate real and imaginary vectors
+ * 
+ *  @return psVector*   resulting complex vector
+ */
+psVector* psVectorComplex(
+    psVector* out,                     ///< a psVector to recycle.  If NULL, a new psVector is made.
+    const psVector* real,              ///< the real vector
+    const psVector* imag               ///< the imaginary vector
+);
+
+/** computes the complex conjugate of a vector
+ * 
+ *  @return psVector*   the complex conjugate of the 'in' vector
+ */
+psVector* psVectorConjugate(
+    psVector* out,                     ///< a psVector to recycle.  If NULL, a new psVector is made.
+    const psVector* in                 ///< the psVector to compute conjugate of
+);
+
+/** computes the power spectrum of a vector
+ * 
+ *  @return psVector*   the power spectrum of the 'in' vector
+ */
+psVector* psVectorPowerSpectrum(
+    psVector* out,                     ///< a psVector to recycle.  If NULL, a new psVector is made.
+    const psVector* in                 ///< the psVector to power spectrum of
+);
 
 /// @}

trunk/psLib/src/dataManip/psVectorFFT.c

@@ -6 +6 @@
 *  @author Robert DeSonia, MHPCC
 *
-*  @version $Revision: 1.20 $ $Name: not supported by cvs2svn $
-*  @date $Date: 2004-08-09 23:34:57 $
+*  @version $Revision: 1.21 $ $Name: not supported by cvs2svn $
+*  @date $Date: 2004-08-10 18:54:38 $
 *
 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
@@ -211 +211 @@
 }
 
-psImage* psImageComplex(psImage* out, psImage* real, const psImage* imag)
+psImage* psImageComplex(psImage* out, const psImage* real, const psImage* imag)
 {
     psElemType type;
@@ -586 +586 @@
 }
 
-psVector* psVectorComplex(psVector* out, psVector* real, const psVector* imag)
+psVector* psVectorComplex(psVector* out, const psVector* real, const psVector* imag)
 {
     psElemType type;

trunk/psLib/src/dataManip/psVectorFFT.h

@@ -8 +8 @@
  *  @author Robert DeSonia, MHPCC
  *
- *  @version $Revision: 1.12 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2004-08-09 23:40:55 $
+ *  @version $Revision: 1.13 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2004-08-10 18:54:38 $
  *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
@@ -23 +23 @@
 /// @{
 
-/** Details on FFT implementation (private). */
-
+/** Specify direction of FFT */
 typedef enum {
-    // / psImageFFT/psVectorFFT should perform a forward FFT.
+    /// psImageFFT/psVectorFFT should perform a forward FFT.
     PS_FFT_FORWARD = (-1),
 
-    ///< psImageFFT/psVectorFFT should perform a reverse FFT.
+    /// psImageFFT/psVectorFFT should perform a reverse FFT.
     PS_FFT_REVERSE = (+1)
 } psFftDirection;
 
-psImage* psImageFFT(psImage* out, const psImage* in, psFftDirection direction);
-psImage* psImageReal(psImage* out, const psImage* in);
-psImage* psImageImaginary(psImage* out, const psImage* in);
-psImage* psImageComplex(psImage* out, psImage* real, const psImage* imag);
-psImage* psImageConjugate(psImage* out, const psImage* in);
-psImage* psImagePowerSpectrum(psImage* out, const psImage* in);
+/** Forward and reverse FFT calculations.
+ *
+ *  This takes as input the image of interest (in) and the direction 
+ *  (direction), which is specified by an enumerated type psFftDirection.
+ *  The input image may be of type psF32 or psC32, the result is always 
+ *  psC32. If the input vector is psF32, the direction must be forward. 
+ *  
+ *  @return psImage* the FFT transformation result
+ */
+psImage* psImageFFT(
+    psImage* out,                      ///< a psImage to recycle.  If NULL, a new psImage is made.
+    const psImage* in,                 ///< the psImage to apply transform to
+    psFftDirection direction           ///< the direction of the transform
+);
 
-psVector* psVectorFFT(psVector* out, const psVector* in, psFftDirection direction);
-psVector* psVectorReal(psVector* out, const psVector* in);
-psVector* psVectorImaginary(psVector* out, const psVector* in);
-psVector* psVectorComplex(psVector* out, psVector* real, const psVector* imag);
-psVector* psVectorConjugate(psVector* out, const psVector* in);
-psVector* psVectorPowerSpectrum(psVector* out, const psVector* in);
+/** extract the real portion of a complex image
+ * 
+ *  @return psImage*   real portion of the input image.
+ */
+psImage* psImageReal(
+    psImage* out,                      ///< a psImage to recycle.  If NULL, a new psImage is made.
+    const psImage* in                  ///< the psImage to extract real portion from
+);
+
+/** extract the imaginary portion of a complex image
+ * 
+ *  @return psImage*   imaginary portion of the input image.
+ */
+psImage* psImageImaginary(
+    psImage* out,                      ///< a psImage to recycle.  If NULL, a new psImage is made.
+    const psImage* in                  ///< the psImage to extract imaginary portion from
+);
+
+/** creates a complex image from separate real and imaginary plane images
+ * 
+ *  @return psImage*   resulting complex image
+ */
+psImage* psImageComplex(
+    psImage* out,                      ///< a psImage to recycle.  If NULL, a new psImage is made.
+    const psImage* real,               ///< the real plane image
+    const psImage* imag                ///< the imaginary plane image
+);
+
+/** computes the complex conjugate of an image
+ * 
+ *  @return psImage*   the complex conjugate of the 'in' image
+ */
+psImage* psImageConjugate(
+    psImage* out,                      ///< a psImage to recycle.  If NULL, a new psImage is made.
+    const psImage* in                  ///< the psImage to compute conjugate of
+);
+
+/** computes the power spectrum of an image
+ * 
+ *  @return psImage*   the power spectrum of the 'in' image
+ */
+psImage* psImagePowerSpectrum(
+    psImage* out,                       ///< a psImage to recycle.  If NULL, a new psImage is made.
+    const psImage* in                   ///< the psImage to power spectrum of
+);
+
+/** Forward and reverse FFT calculations.
+ *
+ *  This takes as input the vector of interest (in) and the direction 
+ *  (direction), which is specified by an enumerated type psFftDirection.
+ *  The input vector may be of type psF32 or psC32, the result is always 
+ *  psC32. If the input vector is psF32, the direction must be forward. 
+ *  
+ *  @return psVector* the FFT transformation result
+ */
+psVector* psVectorFFT(
+    psVector* out,                     ///< a psVector to recycle.  If NULL, a new psVector is made.
+    const psVector* in,                ///< the vector to apply transform to
+    psFftDirection direction           ///< the direction of the transform
+);
+
+/** extract the real portion of a complex vector
+ * 
+ *  @return psVector*   real portion of the input vector.
+ */
+psVector* psVectorReal(
+    psVector* out,                     ///< a psVector to recycle.  If NULL, a new psVector is made.
+    const psVector* in                ///< the psVector to extract real portion from
+);
+
+/** extract the imaginary portion of a complex vector
+ * 
+ *  @return psVector*   imaginary portion of the input vector.
+ */
+psVector* psVectorImaginary(
+    psVector* out,                     ///< a psVector to recycle.  If NULL, a new psVector is made.
+    const psVector* in                 ///< the psVector to extract imaginary portion from
+);
+
+/** creates a complex vector from separate real and imaginary vectors
+ * 
+ *  @return psVector*   resulting complex vector
+ */
+psVector* psVectorComplex(
+    psVector* out,                     ///< a psVector to recycle.  If NULL, a new psVector is made.
+    const psVector* real,              ///< the real vector
+    const psVector* imag               ///< the imaginary vector
+);
+
+/** computes the complex conjugate of a vector
+ * 
+ *  @return psVector*   the complex conjugate of the 'in' vector
+ */
+psVector* psVectorConjugate(
+    psVector* out,                     ///< a psVector to recycle.  If NULL, a new psVector is made.
+    const psVector* in                 ///< the psVector to compute conjugate of
+);
+
+/** computes the power spectrum of a vector
+ * 
+ *  @return psVector*   the power spectrum of the 'in' vector
+ */
+psVector* psVectorPowerSpectrum(
+    psVector* out,                     ///< a psVector to recycle.  If NULL, a new psVector is made.
+    const psVector* in                 ///< the psVector to power spectrum of
+);
 
 /// @}

trunk/psLib/src/fft/psVectorFFT.c

@@ -6 +6 @@
 *  @author Robert DeSonia, MHPCC
 *
-*  @version $Revision: 1.20 $ $Name: not supported by cvs2svn $
-*  @date $Date: 2004-08-09 23:34:57 $
+*  @version $Revision: 1.21 $ $Name: not supported by cvs2svn $
+*  @date $Date: 2004-08-10 18:54:38 $
 *
 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
@@ -211 +211 @@
 }
 
-psImage* psImageComplex(psImage* out, psImage* real, const psImage* imag)
+psImage* psImageComplex(psImage* out, const psImage* real, const psImage* imag)
 {
     psElemType type;
@@ -586 +586 @@
 }
 
-psVector* psVectorComplex(psVector* out, psVector* real, const psVector* imag)
+psVector* psVectorComplex(psVector* out, const psVector* real, const psVector* imag)
 {
     psElemType type;

trunk/psLib/src/fft/psVectorFFT.h

@@ -8 +8 @@
  *  @author Robert DeSonia, MHPCC
  *
- *  @version $Revision: 1.12 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2004-08-09 23:40:55 $
+ *  @version $Revision: 1.13 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2004-08-10 18:54:38 $
  *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
@@ -23 +23 @@
 /// @{
 
-/** Details on FFT implementation (private). */
-
+/** Specify direction of FFT */
 typedef enum {
-    // / psImageFFT/psVectorFFT should perform a forward FFT.
+    /// psImageFFT/psVectorFFT should perform a forward FFT.
     PS_FFT_FORWARD = (-1),
 
-    ///< psImageFFT/psVectorFFT should perform a reverse FFT.
+    /// psImageFFT/psVectorFFT should perform a reverse FFT.
     PS_FFT_REVERSE = (+1)
 } psFftDirection;
 
-psImage* psImageFFT(psImage* out, const psImage* in, psFftDirection direction);
-psImage* psImageReal(psImage* out, const psImage* in);
-psImage* psImageImaginary(psImage* out, const psImage* in);
-psImage* psImageComplex(psImage* out, psImage* real, const psImage* imag);
-psImage* psImageConjugate(psImage* out, const psImage* in);
-psImage* psImagePowerSpectrum(psImage* out, const psImage* in);
+/** Forward and reverse FFT calculations.
+ *
+ *  This takes as input the image of interest (in) and the direction 
+ *  (direction), which is specified by an enumerated type psFftDirection.
+ *  The input image may be of type psF32 or psC32, the result is always 
+ *  psC32. If the input vector is psF32, the direction must be forward. 
+ *  
+ *  @return psImage* the FFT transformation result
+ */
+psImage* psImageFFT(
+    psImage* out,                      ///< a psImage to recycle.  If NULL, a new psImage is made.
+    const psImage* in,                 ///< the psImage to apply transform to
+    psFftDirection direction           ///< the direction of the transform
+);
 
-psVector* psVectorFFT(psVector* out, const psVector* in, psFftDirection direction);
-psVector* psVectorReal(psVector* out, const psVector* in);
-psVector* psVectorImaginary(psVector* out, const psVector* in);
-psVector* psVectorComplex(psVector* out, psVector* real, const psVector* imag);
-psVector* psVectorConjugate(psVector* out, const psVector* in);
-psVector* psVectorPowerSpectrum(psVector* out, const psVector* in);
+/** extract the real portion of a complex image
+ * 
+ *  @return psImage*   real portion of the input image.
+ */
+psImage* psImageReal(
+    psImage* out,                      ///< a psImage to recycle.  If NULL, a new psImage is made.
+    const psImage* in                  ///< the psImage to extract real portion from
+);
+
+/** extract the imaginary portion of a complex image
+ * 
+ *  @return psImage*   imaginary portion of the input image.
+ */
+psImage* psImageImaginary(
+    psImage* out,                      ///< a psImage to recycle.  If NULL, a new psImage is made.
+    const psImage* in                  ///< the psImage to extract imaginary portion from
+);
+
+/** creates a complex image from separate real and imaginary plane images
+ * 
+ *  @return psImage*   resulting complex image
+ */
+psImage* psImageComplex(
+    psImage* out,                      ///< a psImage to recycle.  If NULL, a new psImage is made.
+    const psImage* real,               ///< the real plane image
+    const psImage* imag                ///< the imaginary plane image
+);
+
+/** computes the complex conjugate of an image
+ * 
+ *  @return psImage*   the complex conjugate of the 'in' image
+ */
+psImage* psImageConjugate(
+    psImage* out,                      ///< a psImage to recycle.  If NULL, a new psImage is made.
+    const psImage* in                  ///< the psImage to compute conjugate of
+);
+
+/** computes the power spectrum of an image
+ * 
+ *  @return psImage*   the power spectrum of the 'in' image
+ */
+psImage* psImagePowerSpectrum(
+    psImage* out,                       ///< a psImage to recycle.  If NULL, a new psImage is made.
+    const psImage* in                   ///< the psImage to power spectrum of
+);
+
+/** Forward and reverse FFT calculations.
+ *
+ *  This takes as input the vector of interest (in) and the direction 
+ *  (direction), which is specified by an enumerated type psFftDirection.
+ *  The input vector may be of type psF32 or psC32, the result is always 
+ *  psC32. If the input vector is psF32, the direction must be forward. 
+ *  
+ *  @return psVector* the FFT transformation result
+ */
+psVector* psVectorFFT(
+    psVector* out,                     ///< a psVector to recycle.  If NULL, a new psVector is made.
+    const psVector* in,                ///< the vector to apply transform to
+    psFftDirection direction           ///< the direction of the transform
+);
+
+/** extract the real portion of a complex vector
+ * 
+ *  @return psVector*   real portion of the input vector.
+ */
+psVector* psVectorReal(
+    psVector* out,                     ///< a psVector to recycle.  If NULL, a new psVector is made.
+    const psVector* in                ///< the psVector to extract real portion from
+);
+
+/** extract the imaginary portion of a complex vector
+ * 
+ *  @return psVector*   imaginary portion of the input vector.
+ */
+psVector* psVectorImaginary(
+    psVector* out,                     ///< a psVector to recycle.  If NULL, a new psVector is made.
+    const psVector* in                 ///< the psVector to extract imaginary portion from
+);
+
+/** creates a complex vector from separate real and imaginary vectors
+ * 
+ *  @return psVector*   resulting complex vector
+ */
+psVector* psVectorComplex(
+    psVector* out,                     ///< a psVector to recycle.  If NULL, a new psVector is made.
+    const psVector* real,              ///< the real vector
+    const psVector* imag               ///< the imaginary vector
+);
+
+/** computes the complex conjugate of a vector
+ * 
+ *  @return psVector*   the complex conjugate of the 'in' vector
+ */
+psVector* psVectorConjugate(
+    psVector* out,                     ///< a psVector to recycle.  If NULL, a new psVector is made.
+    const psVector* in                 ///< the psVector to compute conjugate of
+);
+
+/** computes the power spectrum of a vector
+ * 
+ *  @return psVector*   the power spectrum of the 'in' vector
+ */
+psVector* psVectorPowerSpectrum(
+    psVector* out,                     ///< a psVector to recycle.  If NULL, a new psVector is made.
+    const psVector* in                 ///< the psVector to power spectrum of
+);
 
 /// @}