FourierTransform

class odl.trafos.fourier.fourier.FourierTransform(*args, **kwargs)[source]

Bases: FourierTransformBase

Discretized Fourier transform between discrete L^p spaces.

This operator is the discretized variant of the continuous Fourier Transform between Lebesgue L^p spaces. It applies a three-step procedure consisting of a pre-processing step of the data, an FFT evaluation and a post-processing step. Pre- and post-processing account for the shift and scaling of the real-space and Fourier-space grids.

The sign convention (‘-’ vs. ‘+’) can be changed with the sign parameter.

See Also

DiscreteFourierTransform FourierTransformInverse odl.trafos.util.ft_utils.dft_preprocess_data odl.trafos.backends.pyfftw_bindings.pyfftw_call odl.trafos.util.ft_utils.dft_postprocess_data

__init__(domain, range=None, impl=None, **kwargs)[source]

Initialize a new instance.

Parameters

domainDiscretizedSpace

Domain of the Fourier transform. If the DiscretizedSpace.exponent of domain and range are equal to 2.0, this operator has an adjoint which is equal to its inverse.

rangeDiscretizedSpace, optional

Range of the Fourier transform. If not given, the range is determined from domain and the other parameters. The exponent is chosen to be the conjugate p / (p - 1), which reads as ‘inf’ for p=1 and 1 for p=’inf’.

impl{‘numpy’, ‘pyfftw’}, optional

Backend for the FFT implementation. The ‘pyfftw’ backend is faster but requires the pyfftw package. None selects the fastest available backend.

axesint or sequence of ints, optional

Dimensions along which to take the transform. Default: all axes

sign{‘-’, ‘+’}, optional

Sign of the complex exponent. Default: ‘-’

halfcomplexbool, optional

If True, calculate only the negative frequency part along the last axis for real input. If False, calculate the full complex FFT. For complex domain, it has no effect. Default: True

shiftbool or sequence of bools, optional

If True, the reciprocal grid is shifted by half a stride in the negative direction. With a boolean sequence, this option is applied separately to each axis. If a sequence is provided, it must have the same length as axes if supplied. Note that this must be set to True in the halved axis in half-complex transforms. Default: True

Other Parameters

tmp_rDiscretizedSpaceElement or numpy.ndarray, optional

Temporary for calculations in the real space (domain of this transform). It is shared with the inverse.

Variants using this: R2C, R2HC, C2R (inverse)

tmp_fDiscretizedSpaceElement or numpy.ndarray, optional

Temporary for calculations in the frequency (reciprocal) space. It is shared with the inverse.

Variants using this: R2C, C2R (inverse), HC2R (inverse)

Notes

  • The transform variants are:

    • C2C: complex-to-complex. The default variant, one-to-one and unitary.

    • R2C: real-to-complex. This variants adjoint and inverse may suffer from information loss since the result is cast to real.

    • R2HC: real-to-halfcomplex. This variant stores only a half-space of frequencies and is guaranteed to be one-to-one (invertible).

  • The Operator.range of this operator always has the ComplexNumbers as LinearSpace.field, i.e. if the field of domain is the RealNumbers, this operator’s adjoint is defined by identifying real and imaginary parts with the components of a real product space element. See the mathematical background documentation for details.