img1,img2 =	forwardDiscreteFourierTransform2dImg (inImg)
img1,img2 =	forwardDiscreteFourierTransform2dImg (inImg,inOptDFTConfig)

Detailed Description

Forward Discrete Fourier Transform for an input 2d image.

This algorithm allows to compute the Forward Discrete Fourier Transformation of an input 2d image $ InImg $ .

In two dimensions, the Forward Discrete Fourier Transformation (FDFT) of input image $ InImg $ with $ S_y $ rows and $ S_x $ columns is defined as the following complex image:

$fdft(x, y) = \sum_{k=0}^{S_y}{\sum_{l=0}^{S_x}{InImg(l, k)\exp^{-2\pi i \left (\frac{xl}{S_x}+\frac{yk}{S_y} \right )}}}$

On output this complex image is represented by a couple of images $ OutDFTImg1 = Re(fdft) $ and $ OutDFTImg2 = Im(fdft) $ (user should note that this is not the default output representation, see below).

The following image is an illustration of Forward Discrete Fourier Transformation results in case of previous configuration :

A common 'user friendly' representation of FDFT results consists in:

applying a cartesian to polar conversion of FDFT complex representation (see Cartesian to polar transformation),
swaping image quadrants to center lowest frequencies.

Output images $ OutDFTImg1 $ and $ OutDFTImg2 $ are then modified in function.

Input parameter $ InDFTConfig $ allows to setup:

targeted output coordinates :
- eDFTCoordinates::eDFTC_Polar for polar representation [default],
- eDFTCoordinates::eDFTC_Cartesian for cartesian representation.
output quadrants policy :
- eDFTQuadrantsPolicy::eDFTQP_Centered for centerer lowest frequencies [default],
- eDFTQuadrantsPolicy::eDFTQP_Native for centerer highest frequencies
a scale policy: during processing, Forward Discrete Fourier Transformation can be scaled by a constant value :
$fdft(x, y) = \lambda\sum_{k=0}^{S_y}{\sum_{l=0}^{S_x}{InImg(l, k)\exp^{-2\pi i \left (\frac{xl}{S_x}+\frac{yk}{S_y} \right )}}}$
- eDFTScalePolicy::eDFTSP_Default for default behavior with $\lambda=1$ ,
- eDFTScalePolicy::eDFTSP_Unitary for unitary FDFT with $\lambda=\frac{1}{\sqrt{S_x}}$ along x axis and $\lambda=\frac{1}{\sqrt{S_y}}$ along y axis,
  See also
  https://en.wikipedia.org/wiki/Discrete_Fourier_transform#The_unitary_DFT
- eDFTScalePolicy::eDFTSP_Custom for a user custom scale factor defined for each axis.

The following image is an illustration of Forward Discrete Fourier Transformation results in case of polar coordinates, centered quadrants policy and default scale (which is the default configuration):

See also: https://en.wikipedia.org/wiki/Discrete_Fourier_transform

Example of Python code :

Example imports

import PyIPSDK

import PyIPSDK.IPSDKIPLIntensityTransform as itrans

Code Example

    # opening of input image
    inImg = PyIPSDK.loadTiffImageFile(inputImgPath)
    
    # Forward Discrete Fourier Transform of input image
    outImg1, outImg2 = itrans.forwardDiscreteFourierTransform2dImg(inImg)

Example of C++ code :

Example informations

Header file

#include <IPSDKIPL/IPSDKIPLIntensityTransform/Processor/ForwardDiscreteFourierTransform2dImg/ForwardDiscreteFourierTransform2dImg.h>

Code Example

    // opening of input image
    ImagePtr pInImg = loadTiffImageFile(inputImgPath);
    // Forward Discrete Fourier Transform of input image
    ForwardDFTImg forwardDFTImg = forwardDiscreteFourierTransform2dImg(pInImg);