Generic two-dimensional fast Fourier transform of complex data. More...
#include <FFT2D.h>
Inheritance diagram for pcl::GenericFFT2D< T >:
Public Types | |
| using | base = AbstractFFT2D< T > |
| using | complex = typename base::complex |
| using | complex_matrix = typename base::complex_matrix |
| using | complex_vector = typename base::complex_vector |
| using | matrix = typename base::matrix |
| using | scalar = typename base::scalar |
| using | transform = typename base::transform |
| using | vector = typename base::vector |
| Public Types inherited from pcl::AbstractFFT2D< T > | |
| using | complex = Complex< T > |
| using | complex_matrix = GenericMatrix< complex > |
| using | complex_vector = GenericVector< complex > |
| using | matrix = GenericMatrix< scalar > |
| using | scalar = T |
| using | transform = complex_matrix |
| using | vector = GenericVector< scalar > |
Public Member Functions | |
| GenericFFT2D (int rows, int cols) | |
| GenericFFT2D (int rows, int cols, StatusMonitor &status) | |
| ~GenericFFT2D () override | |
| GenericFFT2D & | operator() (complex *y, const complex *x, int dir=PCL_FFT_FORWARD) const |
| GenericFFT2D & | operator<< (const complex *x) |
| GenericFFT2D & | operator<< (const complex_matrix &x) |
| GenericFFT2D & | operator>> (complex *y) const |
| GenericFFT2D & | operator>> (complex_matrix &y) const |
| Public Member Functions inherited from pcl::AbstractFFT2D< T > | |
| AbstractFFT2D (int rows, int cols) | |
| AbstractFFT2D (int rows, int cols, StatusMonitor &monitor) | |
| ~AbstractFFT2D () override | |
| int | Cols () const |
| transform & | DFT () |
| transform | DFT () const |
| int | NumberOfElements () const |
| virtual void | Release () |
| int | Rows () const |
| Public Member Functions inherited from pcl::ParallelProcess | |
| ParallelProcess ()=default | |
| ParallelProcess (const ParallelProcess &)=default | |
| virtual | ~ParallelProcess () |
| void | DisableParallelProcessing (bool disable=true) noexcept |
| void | EnableParallelProcessing (bool enable=true, int maxProcessors=0) noexcept |
| bool | IsParallelProcessingEnabled () const noexcept |
| int | MaxProcessors () const noexcept |
| ParallelProcess & | operator= (const ParallelProcess &)=default |
| void | SetMaxProcessors (int maxProcessors) noexcept |
| void | Swap (ParallelProcess &process) noexcept |
Static Public Member Functions | |
| static int | OptimizedLength (int n) |
Detailed Description
template<typename T>
class pcl::GenericFFT2D< T >
The GenericFFT2D template class performs two-dimensional forward and inverse, out-of-place fast Fourier transforms of complex data.
For fast Fourier transforms of 2-D real-valued data, see the GenericRealFFT2D template class.
- See also
- AbstractFFT2D, GenericRealFFT2D
Member Typedef Documentation
◆ base
| using pcl::GenericFFT2D< T >::base = AbstractFFT2D<T> |
◆ complex
| using pcl::GenericFFT2D< T >::complex = typename base::complex |
◆ complex_matrix
| using pcl::GenericFFT2D< T >::complex_matrix = typename base::complex_matrix |
◆ complex_vector
| using pcl::GenericFFT2D< T >::complex_vector = typename base::complex_vector |
◆ matrix
| using pcl::GenericFFT2D< T >::matrix = typename base::matrix |
◆ scalar
| using pcl::GenericFFT2D< T >::scalar = typename base::scalar |
◆ transform
| using pcl::GenericFFT2D< T >::transform = typename base::transform |
◆ vector
| using pcl::GenericFFT2D< T >::vector = typename base::vector |
Constructor & Destructor Documentation
◆ GenericFFT2D() [1/2]
|
inline |
Constructs a GenericFFT2D object of the specified dimensions rows and cols.
The current PCL implementation supports FFTs of arbitrary length, but the underlying routines have been optimized for performance when the length of the input vector can be factorized as follows:
n = 2^n2 * 3^n3 * 4^n4 * 5^n5
where n2, n3, n4, and n5 are arbitrary positive integers. For best performance, you should call GenericFFT2D::OptimizedLength() to get the smallest optimal dimensions for your data, then place them on a matrix of the obtained dimensions, padded with zeros.
◆ GenericFFT2D() [2/2]
|
inline |
Constructs a GenericFFT2D object of the specified dimensions rows and cols, using the specified status monitoring object status.
On each transform performed with this object, the status m_monitor will be incremented by the sum of transform dimensions: rows + cols.
See the GenericFFT2D( int, int ) constructor for more information.
◆ ~GenericFFT2D()
|
inlineoverride |
Member Function Documentation
◆ operator()()
|
inline |
Performs the forward or inverse two-dimensional FFT of an input matrix of complex values, and stores the result in a caller-supplied output matrix.
- Parameters
-
[in] x Input matrix. Must be the starting address of a contiguous sequence of at least NumberOfElements() complex numbers, stored in row order: all elements of the first row followed by all elements of the second row, and so on. [out] y Output matrix, where the result of the transform will be stored. Must be the starting address of a contiguous sequence of at least NumberOfElements() complex numbers. The result will be stored in row order: all elements of the first row followed by all elements of the second row, and so on. dir Indicates the direction of the Fourier transform:
PCL_FFT_FORWARD The FFT is calculated. PCL_FFT_BACKWARD The inverse FFT is calculated.
This parameter is optional; the default value is PCL_FFT_FORWARD.
This member function does not change the current Fourier transform in this object, if it exists.
Returns a reference to this object.
◆ operator<<() [1/2]
|
inline |
Fast Fourier transform. Performs the two-dimensional FFT of the specified matrix of complex values.
The argument x must be the starting address of a contiguous block of at least NumberOfElements() elements, stored in row order: all elements of the first matrix row followed by all elements of the second row, and so on.
Returns a reference to this object.
◆ operator<<() [2/2]
|
inline |
Fast Fourier transform. Performs the two-dimensional FFT of a matrix of complex values.
The specified matrix x must have Rows() and Cols() dimensions. Otherwise an Error exception will be thrown.
Returns a reference to this object.
Definition at line 443 of file FFT2D.h.
References pcl::GenericMatrix< T >::Rows().
◆ operator>>() [1/2]
|
inline |
Inverse fast Fourier transform. Performs the two-dimensional inverse FFT and stores the result in the specified matrix of complex values.
The argument y must be the starting address of a contiguous block of at least NumberOfElements() elements. The result matrix will be stored in row order: all elements of the first matrix row followed by all elements of the second row, and so on.
If no FFT has been performed on this object (by a previous call to operator <<()), this member function throws an Error exception.
Returns a reference to this object.
◆ operator>>() [2/2]
|
inline |
Inverse fast Fourier transform. Performs the two-dimensional inverse FFT and stores the result in a matrix of complex values.
The specified matrix y must have Rows() and Cols() dimensions. Otherwise an Error exception will be thrown.
If no FFT has been performed on this object (by a previous call to operator <<()), this member function throws an Error exception.
Returns a reference to this object.
Definition at line 464 of file FFT2D.h.
References pcl::GenericMatrix< T >::Rows().
◆ OptimizedLength()
|
inlinestatic |
Returns the optimized complex FFT length larger than or equal to a given length n. The returned length will be optimal to perform a FFT of complex data with the current PCL implementation. The optimized length can be used as the rows or cols argument to the constructor of any two-dimensional FFT class for complex data transforms.
Definition at line 518 of file FFT2D.h.
References pcl::GenericFFT< T >::OptimizedLength().
The documentation for this class was generated from the following file:
