Index: /trunk/psLib/psLib.kdevses =================================================================== --- /trunk/psLib/psLib.kdevses (revision 1451) +++ /trunk/psLib/psLib.kdevses (revision 1452) @@ -2,5 +2,11 @@ - + + + + + + + Index: /trunk/psLib/src/dataManip/psFFT.c =================================================================== --- /trunk/psLib/src/dataManip/psFFT.c (revision 1451) +++ /trunk/psLib/src/dataManip/psFFT.c (revision 1452) @@ -6,6 +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,5 +211,5 @@ } -psImage* psImageComplex(psImage* out, psImage* real, const psImage* imag) +psImage* psImageComplex(psImage* out, const psImage* real, const psImage* imag) { psElemType type; @@ -586,5 +586,5 @@ } -psVector* psVectorComplex(psVector* out, psVector* real, const psVector* imag) +psVector* psVectorComplex(psVector* out, const psVector* real, const psVector* imag) { psElemType type; Index: /trunk/psLib/src/dataManip/psFFT.h =================================================================== --- /trunk/psLib/src/dataManip/psFFT.h (revision 1451) +++ /trunk/psLib/src/dataManip/psFFT.h (revision 1452) @@ -8,6 +8,6 @@ * @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,27 +23,134 @@ /// @{ -/** 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 +); /// @} Index: /trunk/psLib/src/dataManip/psVectorFFT.c =================================================================== --- /trunk/psLib/src/dataManip/psVectorFFT.c (revision 1451) +++ /trunk/psLib/src/dataManip/psVectorFFT.c (revision 1452) @@ -6,6 +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,5 +211,5 @@ } -psImage* psImageComplex(psImage* out, psImage* real, const psImage* imag) +psImage* psImageComplex(psImage* out, const psImage* real, const psImage* imag) { psElemType type; @@ -586,5 +586,5 @@ } -psVector* psVectorComplex(psVector* out, psVector* real, const psVector* imag) +psVector* psVectorComplex(psVector* out, const psVector* real, const psVector* imag) { psElemType type; Index: /trunk/psLib/src/dataManip/psVectorFFT.h =================================================================== --- /trunk/psLib/src/dataManip/psVectorFFT.h (revision 1451) +++ /trunk/psLib/src/dataManip/psVectorFFT.h (revision 1452) @@ -8,6 +8,6 @@ * @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,27 +23,134 @@ /// @{ -/** 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 +); /// @} Index: /trunk/psLib/src/fft/psVectorFFT.c =================================================================== --- /trunk/psLib/src/fft/psVectorFFT.c (revision 1451) +++ /trunk/psLib/src/fft/psVectorFFT.c (revision 1452) @@ -6,6 +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,5 +211,5 @@ } -psImage* psImageComplex(psImage* out, psImage* real, const psImage* imag) +psImage* psImageComplex(psImage* out, const psImage* real, const psImage* imag) { psElemType type; @@ -586,5 +586,5 @@ } -psVector* psVectorComplex(psVector* out, psVector* real, const psVector* imag) +psVector* psVectorComplex(psVector* out, const psVector* real, const psVector* imag) { psElemType type; Index: /trunk/psLib/src/fft/psVectorFFT.h =================================================================== --- /trunk/psLib/src/fft/psVectorFFT.h (revision 1451) +++ /trunk/psLib/src/fft/psVectorFFT.h (revision 1452) @@ -8,6 +8,6 @@ * @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,27 +23,134 @@ /// @{ -/** 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 +); /// @}