Image Component Library (ICL)
|
#include <FFTOp.h>
Public Types | |
enum | SizeAdaptionMode { NO_SCALE, PAD_ZERO, PAD_COPY, PAD_MIRROR, SCALE_UP, SCALE_DOWN } |
Modes how the sourceimage is to adapt before fftcomputation. More... | |
enum | ResultMode { TWO_CHANNEL_COMPLEX, IMAG_ONLY, REAL_ONLY, POWER_SPECTRUM, LOG_POWER_SPECTRUM, MAGNITUDE_ONLY, PHASE_ONLY, TWO_CHANNEL_MAGNITUDE_PHASE } |
Modes how the destinationimage will be created. More... | |
Public Member Functions | |
FFTOp (ResultMode rm=LOG_POWER_SPECTRUM, SizeAdaptionMode sam=NO_SCALE, bool fftshift=true, bool forceDFT=false) | |
Creates a new FFTOp-object. | |
~FFTOp () | |
void | setResultMode (ResultMode rm) |
Sets the resultmode. | |
int | getResultMode () |
Returns the resultmode as int. | |
void | setSizeAdaptionMode (SizeAdaptionMode sam) |
Sets the sizeadaptionmode. | |
int | getSizeAdaptionMode () |
Returns the sizeadaptionmode. | |
bool | getForceDFT () |
Returns true if the diskrete fourier transfarmation shall be used, else false. | |
void | setForceDFT (bool pForceDFT) |
Set wether to force the diskrete fourier transformation or to use the fast fourier transformation. | |
void | setFFTShift (bool pFFTShift) |
Set wether to fftshift the destinationimage or not. | |
bool | getFFTShift () |
Returns the current value for fftshift. | |
virtual void | apply (const core::ImgBase *src, core::ImgBase **dst) |
Call this method to start fftcomputation. | |
Private Member Functions | |
template<class SrcT , class DstT > | |
void | apply_internal (const core::Img< SrcT > &src, core::Img< DstT > &dst, math::DynMatrix< std::complex< DstT > > &buf, math::DynMatrix< std::complex< DstT > > &dstBuf) |
template<class T > | |
const core::Img< T > * | adapt_source (const core::Img< T > *src) |
template<typename T > | |
void | apply_inplace_fftshift (math::DynMatrix< T > &m) |
Private Attributes | |
Data * | m_data |
Class for internal params and buffers. |
This class implements the unary operator for the fast and discrete 2D fourier transformation. As known the fft can only be applied if the datasize is a power of 2. This implementation uses the fft as far as it can be applied and switches to the dft, so you can use it if datasize is not a power of 2 too. If MKL or IPP is available, FFTOp tries to use it if possible.
#include <ICLQuick/Common.h> #include <ICLFilter/FFTOp.h> using namespace icl; GUI gui; void init(){...} int main(int n, char **args){ pa_init(n,args,"-input|-i(filename)",init); Img32f src = load(*pa("-i")); FFTOp fftop(FFTOp::LOG_POWER_SPECTRUM,FFTOp::NO_SCALE); const ImgBase *dst = fftop.apply(&src); // note: icl-xv must be within your PATH show(norm(cvt(dst))); } |
Save the above sourcecode to a file, compile and link it. Execute it: ./appname -input pic.jpg
These modes configure the way the destinationimage (the result of the fft) shall be returned. Different results like logpowerspectrum, real part or phase and magnitude can be obtained. (see icl::FFTOp::ResultMode)
These modes configure the sourceimage before processing the fft. The sourceimage can be scaled up, so that the datasize is a power of 2 (this is needed if you want to use the IPP acceleration or the faster part of the fallback). You can also scale the image down, leave it as it is or create a border and fill it with several methods. (see icl::filter::FFTOp::SizeAdaptionMode)
If you own the Intel IPP or MKL library, the computation of the fft can be accelarated by using it. The IPP functions assume a datasize of power of 2 (see icl::filter::FFTOp::SizeAdaptionMode). If IPP is available on you system and the datasize is a power of 2, it will be used automatacally. If MKL is available on your system, it will be used if IPP is not available or the datasize is not a power of 2. If IPP and MKL are not available, the fallback will be used. The MKL and fallback functions support also datasizes which are not power of 2. Supported source and destinationtypes:
dst/src | icl8u | icl16s | icl32s | icl32f | icl64f |
icl32f | IPP/MKL | IPP/MKL | IPP/MKL | IPP/MKL | MKL |
icl64f | MKL | MKL | MKL | MKL | MKL |
The following benchmark has been done on Intel Dual Core 2.4GHz CPU on a PC with 2GiB RAM. Since IPP and MKL provide their fft results in a packed format, the time for unpacking is included in this benchmarks. Also IPP and MKL do not support every possible sourcetype, so time for typeconversation is also included if necessary. All times are provided in ms per channel.:
lib/size (format) | QVGA(320x240) | HVGA(480x320) | VGA(640x480) | SVGA(800x600) | XGA(1024x768) | DSVGA(1200x800) | 512x512 | 1024x1024 |
IPP | - | - | - | - | - | - | 4 | 21 |
MKL | 1 | 2 | 7 | 12 | 36 | 26 | 6 | 58 |
FB | 214 | 440 | 896 | 5509 | 1395 | 11064 | 438 | 1915 |
Modes how the destinationimage will be created.
Several resultmodes for destinationimage.
Modes how the sourceimage is to adapt before fftcomputation.
Several sizeadaptionmodes for sourceimageadaption
icl::filter::FFTOp::FFTOp | ( | ResultMode | rm = LOG_POWER_SPECTRUM , |
SizeAdaptionMode | sam = NO_SCALE , |
||
bool | fftshift = true , |
||
bool | forceDFT = false |
||
) |
Creates a new FFTOp-object.
Constructor. Params can be changed later.
rm | the resultmode |
sam | the sizeadaptionmode before applying FFTOp |
fftshift | wether to apply fftshift to destinationimage after fftcomputation or not* |
forceDFT | wether to apply dft or fft |
Destructor
const core::Img<T>* icl::filter::FFTOp::adapt_source | ( | const core::Img< T > * | src | ) | [private] |
Called by apply. Adapts sourceimage to specified values(scaling, padding on so on).Possible sourceparam is: Img<icl8u>, Img<icl16s>, Img<icl32s>, Img<icl32f>, Img<icl64f>
virtual void icl::filter::FFTOp::apply | ( | const core::ImgBase * | src, |
core::ImgBase ** | dst | ||
) | [virtual] |
Call this method to start fftcomputation.
Applies FFTOp on src and dst.
*src | pointer to sourceimage |
**dst | pointer to pointer to destinationimage |
Implements icl::filter::UnaryOp.
void icl::filter::FFTOp::apply_inplace_fftshift | ( | math::DynMatrix< T > & | m | ) | [private] |
Applies inplace fftshift on destinationimage after fftcomputation. Possible sourceparam is: Img<icl32f> and Img<icl64f>
void icl::filter::FFTOp::apply_internal | ( | const core::Img< SrcT > & | src, |
core::Img< DstT > & | dst, | ||
math::DynMatrix< std::complex< DstT > > & | buf, | ||
math::DynMatrix< std::complex< DstT > > & | dstBuf | ||
) | [private] |
Called by apply. Applies fft/dft and resultmode. Possible sourceparam is: Img<icl8u>, Img<icl16s>, Img<icl32s>, Img<icl32f>, Img<icl64f>. Possible destinationparam is: Img<icl32f> and Img<icl64f>.
bool icl::filter::FFTOp::getFFTShift | ( | ) |
Returns the current value for fftshift.
bool icl::filter::FFTOp::getForceDFT | ( | ) |
Returns true if the diskrete fourier transfarmation shall be used, else false.
Returns the resultmode as int.
Returns the sizeadaptionmode.
void icl::filter::FFTOp::setFFTShift | ( | bool | pFFTShift | ) |
Set wether to fftshift the destinationimage or not.
pFFTShift | true if the destinationimage should be shifted, else false |
void icl::filter::FFTOp::setForceDFT | ( | bool | pForceDFT | ) |
Set wether to force the diskrete fourier transformation or to use the fast fourier transformation.
pForceDFT |
void icl::filter::FFTOp::setResultMode | ( | ResultMode | rm | ) |
Sets the resultmode.
rm | the resultmode to be set |
Sets the sizeadaptionmode.
sam | the sizeadaptionmode to be set |
Data* icl::filter::FFTOp::m_data [private] |
Class for internal params and buffers.