FFTMethods (ImgLib2 Javadocs 0-SNAPSHOT API)

java.lang.Object
- net.imglib2.algorithm.fft2.FFTMethods

```
public class FFTMethods
extends Object
```
Compute a FFT transform, either real-to-complex or complex-to-complex, or complex-to-real for individual dimensions. Unfortunately only supports a maximal size of INT in each dimension as the one-dimensional FFT is based on arrays.

Author:

Stephan Preibisch

Constructor Summary

Constructors
Constructor and Description

FFTMethods()

Constructors
Constructor and Description
`FFTMethods()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static <T extends ComplexType<T>> void`	`complexConjugate(RandomAccessibleInterval<T> complexData)`
`static <C extends ComplexType<C>> boolean`	`complexToComplex(RandomAccessibleInterval<C> data, int dim, boolean forward)` Computes a complex-to-complex forward or inverse FFT transform of an n-dimensional dataset in a certain dimension.
`static <C extends ComplexType<C>> boolean`	`complexToComplex(RandomAccessibleInterval<C> data, int dim, boolean forward, boolean scale)` Computes a complex-to-complex forward or inverse FFT transform of an n-dimensional dataset in a certain dimension.
`static <C extends ComplexType<C>> boolean`	`complexToComplex(RandomAccessibleInterval<C> data, int dim, boolean forward, boolean scale, ExecutorService service)` Computes a complex-to-complex forward or inverse FFT transform of an n-dimensional dataset in a certain dimension.
`static <C extends ComplexType<C>,R extends RealType<R>> boolean`	`complexToReal(RandomAccessibleInterval<C> input, RandomAccessibleInterval<R> output, int dim)` Computes a complex-to-real inverse FFT transform of an n-dimensional dataset in a certain dimension (typically dim = 0).
`static <C extends ComplexType<C>,R extends RealType<R>> boolean`	`complexToReal(RandomAccessibleInterval<C> input, RandomAccessibleInterval<R> output, int dim, boolean scale, ExecutorService service)` Computes a complex-to-real inverse FFT transform of an n-dimensional dataset in a certain dimension (typically dim = 0).
`static <C extends ComplexType<C>,R extends RealType<R>> boolean`	`complexToReal(RandomAccessibleInterval<C> input, RandomAccessibleInterval<R> output, int dim, boolean scale, int nThreads)` Computes a complex-to-real inverse FFT transform of an n-dimensional dataset in a certain dimension (typically dim = 0).
`static <C extends ComplexType<C>,R extends RealType<R>> boolean`	`complexToReal(RandomAccessibleInterval<C> input, RandomAccessibleInterval<R> output, Interval interval, int dim)` Computes a complex-to-real inverse FFT transform of an n-dimensional dataset in a certain dimension (typically dim = 0).
`static <C extends ComplexType<C>,R extends RealType<R>> boolean`	`complexToReal(RandomAccessibleInterval<C> input, RandomAccessibleInterval<R> output, Interval interval, int dim, boolean scale)` Computes a complex-to-real inverse FFT transform of an n-dimensional dataset in a certain dimension (typically dim = 0).
`static <C extends ComplexType<C>,R extends RealType<R>> boolean`	`complexToReal(RandomAccessibleInterval<C> input, RandomAccessibleInterval<R> output, Interval interval, int dim, boolean scale, ExecutorService service)` Computes a complex-to-real inverse FFT transform of an n-dimensional dataset in a certain dimension (typically dim = 0).
`static <C extends ComplexType<C>,R extends RealType<R>> boolean`	`complexToReal(RandomAccessibleInterval<C> input, RandomAccessibleInterval<R> output, Interval interval, int dim, boolean scale, int nThreads)` Computes a complex-to-real inverse FFT transform of an n-dimensional dataset in a certain dimension (typically dim = 0).
`static void`	`dimensionsComplexToComplexFast(Dimensions inputDimensions, long[] paddedDimensions)` Computes the supported dimensionality of an input dataset (of complex numbers) for a forward/inverse FFT of the entire dataset AS FAST AS POSSIBLE
`static void`	`dimensionsComplexToComplexSmall(Dimensions inputDimensions, long[] paddedDimensions)` Computes the supported dimensionality of an input dataset (of complex numbers) for a forward/inverse FFT of the entire dataset AS SMALL AS POSSIBLE
`static void`	`dimensionsComplexToRealFast(Dimensions inputDimensions, long[] paddedDimensions, long[] realSize)` Computes the supported dimensionality of an input dataset (of complex numbers) for an inverse FFT of the entire dataset AS FAST AS POSSIBLE
`static void`	`dimensionsComplexToRealSmall(Dimensions inputDimensions, long[] paddedDimensions, long[] realSize)` Computes the supported dimensionality of an input dataset (of complex numbers) for an inverse FFT of the entire dataset AS SMALL AS POSSIBLE
`static boolean`	`dimensionsEqual(Dimensions interval, Dimensions padded)` A helper method to test if padding is actually necessary
`static boolean`	`dimensionsEqual(Interval interval, long[] paddedDimensions)` A helper method to test if padding is actually necessary
`static void`	`dimensionsRealToComplexFast(Dimensions inputDimensions, long[] paddedDimensions, long[] fftDimensions)` Computes the supported dimensionality of an input dataset (of real numbers) for a forward FFT of the entire dataset AS FAST AS POSSIBLE
`static void`	`dimensionsRealToComplexSmall(Dimensions inputDimensions, long[] paddedDimensions, long[] fftDimensions)` Computes the supported dimensionality of an input dataset (of real numbers) for a forward FFT of the entire dataset AS SMALL AS POSSIBLE
`static Interval`	`paddingIntervalCentered(Interval input, Dimensions paddingDimensions)` Computes the padding interval required to perform an FFT when the padding dimensions are known.
`static <R extends RealType<R>,C extends ComplexType<C>> boolean`	`realToComplex(RandomAccessibleInterval<R> input, RandomAccessibleInterval<C> output, int dim)` Computes a real-to-complex forward FFT transform of an n-dimensional dataset in a certain dimension (typically dim = 0).
`static <R extends RealType<R>,C extends ComplexType<C>> boolean`	`realToComplex(RandomAccessibleInterval<R> input, RandomAccessibleInterval<C> output, int dim, boolean scale)` Computes a real-to-complex forward FFT transform of an n-dimensional dataset in a certain dimension (typically dim = 0).
`static <R extends RealType<R>,C extends ComplexType<C>> boolean`	`realToComplex(RandomAccessibleInterval<R> input, RandomAccessibleInterval<C> output, int dim, boolean scale, ExecutorService service)` Computes a real-to-complex forward FFT transform of an n-dimensional dataset in a certain dimension (typically dim = 0).
`static <R extends RealType<R>,C extends ComplexType<C>> boolean`	`realToComplex(RandomAccessibleInterval<R> input, RandomAccessibleInterval<C> output, int dim, boolean scale, int nThreads)` Computes a real-to-complex forward FFT transform of an n-dimensional dataset in a certain dimension (typically dim = 0).
`static <R extends RealType<R>,C extends ComplexType<C>> boolean`	`realToComplex(RandomAccessibleInterval<R> input, RandomAccessibleInterval<C> output, Interval interval, int dim)` Computes a real-to-complex forward FFT transform of an n-dimensional dataset in a certain dimension (typically dim = 0).
`static <R extends RealType<R>,C extends ComplexType<C>> boolean`	`realToComplex(RandomAccessibleInterval<R> input, RandomAccessibleInterval<C> output, Interval interval, int dim, boolean scale)` Computes a real-to-complex forward FFT transform of an n-dimensional dataset in a certain dimension (typically dim = 0).
`static <R extends RealType<R>,C extends ComplexType<C>> boolean`	`realToComplex(RandomAccessibleInterval<R> input, RandomAccessibleInterval<C> output, Interval interval, int dim, boolean scale, ExecutorService service)` Computes a real-to-complex forward FFT transform of an n-dimensional dataset in a certain dimension (typically dim = 0).
`static <R extends RealType<R>,C extends ComplexType<C>> boolean`	`realToComplex(RandomAccessibleInterval<R> input, RandomAccessibleInterval<C> output, Interval interval, int dim, boolean scale, int nThreads)` Computes a real-to-complex forward FFT transform of an n-dimensional dataset in a certain dimension (typically dim = 0).
`static Interval`	`unpaddingIntervalCentered(Interval fftDimensions, Dimensions originalDimensions)` Computes the un-padding interval required to extract the original sized image from an inverse FFT when padding was applying upon the FFT.
`protected static boolean`	`verifyComplexToComplexfftDimensions(int inputSize, int outputSize)`
`protected static boolean`	`verifyRealToComplexfftDimensions(int inputSize, int outputSize)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - FFTMethods
```
public FFTMethods()
```
- Method Detail
  - complexToReal
```
public static final <C extends ComplexType<C>,R extends RealType<R>> boolean complexToReal(RandomAccessibleInterval<C> input,
                                                                                           RandomAccessibleInterval<R> output,
                                                                                           int dim)
```
    Computes a complex-to-real inverse FFT transform of an n-dimensional dataset in a certain dimension (typically dim = 0). By default as many threads as processors are available are used. By default the real values are scaled (divided by the amount of pixels in the input dataset), this way after performing a forward and reverse FFT, the values will be exactly the same
    
    Parameters:
    
    input - - the complex-valued input dataset
    
    output - - the real-valued output dataset
    
    dim - - the dimension to compute the inverse FFT in
    
    Returns:
    
    - true if successful, false if the dimensions of input and output are not compatible, i.e. not supported by the edu_mines_jtk 1d fft
  - complexToReal
```
public static final <C extends ComplexType<C>,R extends RealType<R>> boolean complexToReal(RandomAccessibleInterval<C> input,
                                                                                           RandomAccessibleInterval<R> output,
                                                                                           Interval interval,
                                                                                           int dim)
```
    Computes a complex-to-real inverse FFT transform of an n-dimensional dataset in a certain dimension (typically dim = 0). By default as many threads as processors are available are used. By default the real values are scaled (divided by the amount of pixels in the input dataset), this way after performing a forward and reverse FFT, the values will be exactly the same
    
    Parameters:
    
    input - - the complex-valued input dataset
    
    output - - the real-valued output dataset
    
    interval - - if just a subset of the real-values output is required it can be defined here (otherwise it can just be equal to output)
    
    dim - - the dimension to compute the inverse FFT in
    
    Returns:
    
    - true if successful, false if the dimensions of input and output are not compatible, i.e. not supported by the edu_mines_jtk 1d fft
  - complexToReal
```
public static final <C extends ComplexType<C>,R extends RealType<R>> boolean complexToReal(RandomAccessibleInterval<C> input,
                                                                                           RandomAccessibleInterval<R> output,
                                                                                           Interval interval,
                                                                                           int dim,
                                                                                           boolean scale)
```
    Computes a complex-to-real inverse FFT transform of an n-dimensional dataset in a certain dimension (typically dim = 0). By default as many threads as processors are available are used.
    
    Parameters:
    
    input - - the complex-valued input dataset
    
    output - - the real-valued output dataset
    
    interval - - if just a subset of the real-values output is required it can be defined here (otherwise it can just be equal to output)
    
    dim - - the dimension to compute the inverse FFT in
    
    scale - - define if each pixel is divided by the sum of all pixels in the image
    
    Returns:
    
    - true if successful, false if the dimensions of input and output are not compatible, i.e. not supported by the edu_mines_jtk 1d fft
  - complexToReal
```
public static final <C extends ComplexType<C>,R extends RealType<R>> boolean complexToReal(RandomAccessibleInterval<C> input,
                                                                                           RandomAccessibleInterval<R> output,
                                                                                           int dim,
                                                                                           boolean scale,
                                                                                           int nThreads)
```
    Computes a complex-to-real inverse FFT transform of an n-dimensional dataset in a certain dimension (typically dim = 0).
    
    Parameters:
    
    input - - the complex-valued input dataset
    
    output - - the real-valued output dataset
    
    dim - - the dimension to compute the inverse FFT in
    
    scale - - define if each pixel is divided by the sum of all pixels in the image
    
    nThreads - - number of threads to utilize
    
    Returns:
    
    - true if successful, false if the dimensions of input and output are not compatible, i.e. not supported by the edu_mines_jtk 1d fft
  - complexToReal
```
public static final <C extends ComplexType<C>,R extends RealType<R>> boolean complexToReal(RandomAccessibleInterval<C> input,
                                                                                           RandomAccessibleInterval<R> output,
                                                                                           Interval interval,
                                                                                           int dim,
                                                                                           boolean scale,
                                                                                           int nThreads)
```
    Computes a complex-to-real inverse FFT transform of an n-dimensional dataset in a certain dimension (typically dim = 0). By default as many threads as processors are available are used.
    
    Parameters:
    
    input - - the complex-valued input dataset
    
    output - - the real-valued output dataset
    
    interval - - if just a subset of the real-values output is required it can be defined here (otherwise it can just be equal to output)
    
    dim - - the dimension to compute the inverse FFT in
    
    scale - - define if each pixel is divided by the sum of all pixels in the image
    
    nThreads - - number of threads to utilize
    
    Returns:
    
    - true if successful, false if the dimensions of input and output are not compatible, i.e. not supported by the edu_mines_jtk 1d fft
  - complexToReal
```
public static final <C extends ComplexType<C>,R extends RealType<R>> boolean complexToReal(RandomAccessibleInterval<C> input,
                                                                                           RandomAccessibleInterval<R> output,
                                                                                           int dim,
                                                                                           boolean scale,
                                                                                           ExecutorService service)
```
    Computes a complex-to-real inverse FFT transform of an n-dimensional dataset in a certain dimension (typically dim = 0). By default as many threads as processors are available are used.
    
    Parameters:
    
    input - - the complex-valued input dataset
    
    output - - the real-valued output dataset
    
    dim - - the dimension to compute the inverse FFT in
    
    scale - - define if each pixel is divided by the sum of all pixels in the image
    
    service - - service providing threads for multi-threading (if numDims > 1)
    
    Returns:
    
    - true if successful, false if the dimensions of input and output are not compatible, i.e. not supported by the edu_mines_jtk 1d fft
  - complexToReal
```
public static final <C extends ComplexType<C>,R extends RealType<R>> boolean complexToReal(RandomAccessibleInterval<C> input,
                                                                                           RandomAccessibleInterval<R> output,
                                                                                           Interval interval,
                                                                                           int dim,
                                                                                           boolean scale,
                                                                                           ExecutorService service)
```
    Computes a complex-to-real inverse FFT transform of an n-dimensional dataset in a certain dimension (typically dim = 0).
    
    Parameters:
    
    input - - the complex-valued input dataset
    
    output - - the real-valued output dataset
    
    interval - - if just a subset of the real-values output is required it can be defined here (otherwise it can just be equal to output)
    
    dim - - the dimension to compute the inverse FFT in
    
    scale - - define if each pixel is divided by the sum of all pixels in the image
    
    service - - service providing threads for multi-threading (if numDims > 1)
    
    Returns:
    
    - true if successful, false if the dimensions of input and output are not compatible, i.e. not supported by the edu_mines_jtk 1d fft
  - realToComplex
```
public static final <R extends RealType<R>,C extends ComplexType<C>> boolean realToComplex(RandomAccessibleInterval<R> input,
                                                                                           RandomAccessibleInterval<C> output,
                                                                                           int dim)
```
    Computes a real-to-complex forward FFT transform of an n-dimensional dataset in a certain dimension (typically dim = 0). By default as many threads as processors are available are used. By default the complex values are not scaled (not divided by the amount of pixels in the input dataset)
    
    Parameters:
    
    input - - the real-valued input dataset
    
    output - - the complex-valued output dataset
    
    dim - - the dimension to compute the FFT in
    
    Returns:
    
    - true if successful, false if the dimensions of input and output are not compatible, i.e. not supported by the edu_mines_jtk 1d fft
  - realToComplex
```
public static final <R extends RealType<R>,C extends ComplexType<C>> boolean realToComplex(RandomAccessibleInterval<R> input,
                                                                                           RandomAccessibleInterval<C> output,
                                                                                           Interval interval,
                                                                                           int dim)
```
    Computes a real-to-complex forward FFT transform of an n-dimensional dataset in a certain dimension (typically dim = 0). By default as many threads as processors are available are used. By default the complex values are not scaled (not divided by the amount of pixels in the input dataset)
    
    Parameters:
    
    input - - the real-valued input dataset
    
    output - - the complex-valued output dataset
    
    interval - - if just a subset of the complex-valued output is required it can be defined here (otherwise it can just be equal to output)
    
    dim - - the dimension to compute the FFT in
    
    Returns:
    
    - true if successful, false if the dimensions of input and output are not compatible, i.e. not supported by the edu_mines_jtk 1d fft
  - realToComplex
```
public static final <R extends RealType<R>,C extends ComplexType<C>> boolean realToComplex(RandomAccessibleInterval<R> input,
                                                                                           RandomAccessibleInterval<C> output,
                                                                                           int dim,
                                                                                           boolean scale)
```
    Computes a real-to-complex forward FFT transform of an n-dimensional dataset in a certain dimension (typically dim = 0). By default as many threads as processors are available are used.
    
    Parameters:
    
    input - - the real-valued input dataset
    
    output - - the complex-valued output dataset
    
    dim - - the dimension to compute the FFT in
    
    scale - - define if each pixel is divided by the sum of all pixels in the image
    
    Returns:
    
    - true if successful, false if the dimensions of input and output are not compatible, i.e. not supported by the edu_mines_jtk 1d fft
  - realToComplex
```
public static final <R extends RealType<R>,C extends ComplexType<C>> boolean realToComplex(RandomAccessibleInterval<R> input,
                                                                                           RandomAccessibleInterval<C> output,
                                                                                           Interval interval,
                                                                                           int dim,
                                                                                           boolean scale)
```
    Computes a real-to-complex forward FFT transform of an n-dimensional dataset in a certain dimension (typically dim = 0). By default as many threads as processors are available are used.
    
    Parameters:
    
    input - - the real-valued input dataset
    
    output - - the complex-valued output dataset
    
    interval - - if just a subset of the complex-valued output is required it can be defined here (otherwise it can just be equal to output)
    
    dim - - the dimension to compute the FFT in
    
    scale - - define if each pixel is divided by the sum of all pixels in the image
    
    Returns:
    
    - true if successful, false if the dimensions of input and output are not compatible, i.e. not supported by the edu_mines_jtk 1d fft
  - realToComplex
```
public static final <R extends RealType<R>,C extends ComplexType<C>> boolean realToComplex(RandomAccessibleInterval<R> input,
                                                                                           RandomAccessibleInterval<C> output,
                                                                                           int dim,
                                                                                           boolean scale,
                                                                                           int nThreads)
```
    Computes a real-to-complex forward FFT transform of an n-dimensional dataset in a certain dimension (typically dim = 0). By default as many threads as processors are available are used.
    
    Parameters:
    
    input - - the real-valued input dataset
    
    output - - the complex-valued output dataset
    
    dim - - the dimension to compute the FFT in
    
    scale - - define if each pixel is divided by the sum of all pixels in the image
    
    nThreads - - number of threads to utilize
    
    Returns:
    
    - true if successful, false if the dimensions of input and output are not compatible, i.e. not supported by the edu_mines_jtk 1d fft
  - realToComplex
```
public static final <R extends RealType<R>,C extends ComplexType<C>> boolean realToComplex(RandomAccessibleInterval<R> input,
                                                                                           RandomAccessibleInterval<C> output,
                                                                                           Interval interval,
                                                                                           int dim,
                                                                                           boolean scale,
                                                                                           int nThreads)
```
    Computes a real-to-complex forward FFT transform of an n-dimensional dataset in a certain dimension (typically dim = 0). By default as many threads as processors are available are used.
    
    Parameters:
    
    input - - the real-valued input dataset
    
    output - - the complex-valued output dataset
    
    interval - - if just a subset of the complex-valued output is required it can be defined here (otherwise it can just be equal to output)
    
    dim - - the dimension to compute the FFT in
    
    scale - - define if each pixel is divided by the sum of all pixels in the image
    
    nThreads - - number of threads to utilize
    
    Returns:
    
    - true if successful, false if the dimensions of input and output are not compatible, i.e. not supported by the edu_mines_jtk 1d fft
  - realToComplex
```
public static final <R extends RealType<R>,C extends ComplexType<C>> boolean realToComplex(RandomAccessibleInterval<R> input,
                                                                                           RandomAccessibleInterval<C> output,
                                                                                           int dim,
                                                                                           boolean scale,
                                                                                           ExecutorService service)
```
    Computes a real-to-complex forward FFT transform of an n-dimensional dataset in a certain dimension (typically dim = 0).
    
    Parameters:
    
    input - - the real-valued input dataset
    
    output - - the complex-valued output dataset
    
    dim - - the dimension to compute the FFT in
    
    scale - - define if each pixel is divided by the sum of all pixels in the image
    
    service - - service providing threads for multi-threading
    
    Returns:
    
    - true if successful, false if the dimensions of input and output are not compatible, i.e. not supported by the edu_mines_jtk 1d fft
  - realToComplex
```
public static final <R extends RealType<R>,C extends ComplexType<C>> boolean realToComplex(RandomAccessibleInterval<R> input,
                                                                                           RandomAccessibleInterval<C> output,
                                                                                           Interval interval,
                                                                                           int dim,
                                                                                           boolean scale,
                                                                                           ExecutorService service)
```
    Computes a real-to-complex forward FFT transform of an n-dimensional dataset in a certain dimension (typically dim = 0).
    
    Parameters:
    
    input - - the real-valued input dataset
    
    output - - the complex-valued output dataset
    
    interval - - if just a subset of the complex-valued output is required it can be defined here (otherwise it can just be equal to output)
    
    dim - - the dimension to compute the FFT in
    
    scale - - define if each pixel is divided by the sum of all pixels in the image
    
    service - - service providing threads for multi-threading (if numDims > 1)
    
    Returns:
    
    - true if successful, false if the dimensions of input and output are not compatible, i.e. not supported by the edu_mines_jtk 1d fft
  - complexToComplex
```
public static final <C extends ComplexType<C>> boolean complexToComplex(RandomAccessibleInterval<C> data,
                                                                        int dim,
                                                                        boolean forward)
```
    Computes a complex-to-complex forward or inverse FFT transform of an n-dimensional dataset in a certain dimension. By default as many threads as processors are available are used. By default the real values are scaled if it is an inverse transform (divided by the amount of pixels in the input dataset), this way after performing a forward and reverse FFT, the values will be exactly the same. By default the real values are not scaled if it is a forward transform (not divided by the amount of pixels in the input dataset)
    
    Parameters:
    
    data - - the complex-valued dataset (FFT performed in-place)
    
    dim - - the dimension to compute the inverse FFT in
    
    forward - - true means forward FFT transform, false means inverse FFT transform
    
    Returns:
    
    - true if successful, false if the dimensionality of the dataset is not supported by the edu_mines_jtk 1d fft
  - complexToComplex
```
public static final <C extends ComplexType<C>> boolean complexToComplex(RandomAccessibleInterval<C> data,
                                                                        int dim,
                                                                        boolean forward,
                                                                        boolean scale)
```
    Computes a complex-to-complex forward or inverse FFT transform of an n-dimensional dataset in a certain dimension. By default as many threads as processors are available are used.
    
    Parameters:
    
    data - - the complex-valued dataset (FFT performed in-place)
    
    dim - - the dimension to compute the inverse FFT in
    
    forward - - true means forward FFT transform, false means inverse FFT transform
    
    scale - - define if each pixel is divided by the sum of all pixels in the image
    
    Returns:
    
    - true if successful, false if the dimensionality of the dataset is not supported by the edu_mines_jtk 1d fft
  - complexToComplex
```
public static final <C extends ComplexType<C>> boolean complexToComplex(RandomAccessibleInterval<C> data,
                                                                        int dim,
                                                                        boolean forward,
                                                                        boolean scale,
                                                                        ExecutorService service)
```
    Computes a complex-to-complex forward or inverse FFT transform of an n-dimensional dataset in a certain dimension.
    
    Parameters:
    
    data - - the complex-valued dataset (FFT performed in-place)
    
    dim - - the dimension to compute the inverse FFT in
    
    forward - - true means forward FFT transform, false means inverse FFT transform
    
    scale - - define if each pixel is divided by the sum of all pixels in the image
    
    service - - service providing threads for multi-threading (if numDims > 1)
    
    Returns:
    
    - true if successful, false if the dimensionality of the dataset is not supported by the edu_mines_jtk 1d fft
  - paddingIntervalCentered
```
public static final Interval paddingIntervalCentered(Interval input,
                                                     Dimensions paddingDimensions)
```
    Computes the padding interval required to perform an FFT when the padding dimensions are known. It will define the padding area around the input. If the extension is not even, it will add the one pixel more on the right side.
    
    Parameters:
    
    input - - the input interval
    
    paddingDimensions - - the dimensions of the padding
    
    Returns:
    
    - a new Interval with the correct dimensions.
  - unpaddingIntervalCentered
```
public static final Interval unpaddingIntervalCentered(Interval fftDimensions,
                                                       Dimensions originalDimensions)
```
    Computes the un-padding interval required to extract the original sized image from an inverse FFT when padding was applying upon the FFT. It assumes that the original padding was computed using the method paddingIntervalCentered( final Interval input, final int[] paddingDimensions ). Therefore, it will define the padding area around the input. If the extension is not even on all sides, it will assume the one pixel to be on the right side.
    
    Parameters:
    
    fftDimensions - - the input interval
    
    originalDimensions - - the dimensions of the padding
    
    Returns:
    
    - a new Interval with the correct dimensions.
  - dimensionsComplexToRealSmall
```
public static final void dimensionsComplexToRealSmall(Dimensions inputDimensions,
                                                      long[] paddedDimensions,
                                                      long[] realSize)
```
    Computes the supported dimensionality of an input dataset (of complex numbers) for an inverse FFT of the entire dataset AS SMALL AS POSSIBLE
    
    Parameters:
    
    inputDimensions - - the dimensions of the complex-valued input
    
    paddedDimensions - - the required dimensions of the complex-valued input (computed)
    
    realSize - - the dimensions of the real-valued output after the inverse fast fourier transform (computed), i.e. which dimensions are required for the output
  - dimensionsComplexToRealFast
```
public static final void dimensionsComplexToRealFast(Dimensions inputDimensions,
                                                     long[] paddedDimensions,
                                                     long[] realSize)
```
    Computes the supported dimensionality of an input dataset (of complex numbers) for an inverse FFT of the entire dataset AS FAST AS POSSIBLE
    
    Parameters:
    
    inputDimensions - - the dimensions of the complex-valued input
    
    paddedDimensions - - the required dimensions of the complex-valued input (computed)
    
    realSize - - the dimensions of the real-valued output after the inverse fast fourier transform (computed), i.e. which dimensions are required for the output
  - dimensionsEqual
```
public static final boolean dimensionsEqual(Interval interval,
                                            long[] paddedDimensions)
```
    A helper method to test if padding is actually necessary
    
    Parameters:
    
    interval - - the dimensions of a dataset
    
    paddedDimensions - - the dimensions of a dataset
    
    Returns:
    
    true if the dimensions are equal, otherwise false
  - dimensionsEqual
```
public static final boolean dimensionsEqual(Dimensions interval,
                                            Dimensions padded)
```
    A helper method to test if padding is actually necessary
    
    Parameters:
    
    interval - - the dimensions of a dataset
    
    padded - - the dimensions of a dataset
    
    Returns:
    
    true if the dimensions are equal, otherwise false
  - dimensionsRealToComplexFast
```
public static final void dimensionsRealToComplexFast(Dimensions inputDimensions,
                                                     long[] paddedDimensions,
                                                     long[] fftDimensions)
```
    Computes the supported dimensionality of an input dataset (of real numbers) for a forward FFT of the entire dataset AS FAST AS POSSIBLE
    
    Parameters:
    
    inputDimensions - - the dimensions of the real-valued input
    
    paddedDimensions - - the required dimensions of the real-valued input (computed)
    
    fftDimensions - - the dimensions of the complex-valued fft after the fast fourier transform (computed), i.e. which dimensions are required for the output
  - dimensionsRealToComplexSmall
```
public static final void dimensionsRealToComplexSmall(Dimensions inputDimensions,
                                                      long[] paddedDimensions,
                                                      long[] fftDimensions)
```
    Computes the supported dimensionality of an input dataset (of real numbers) for a forward FFT of the entire dataset AS SMALL AS POSSIBLE
    
    Parameters:
    
    inputDimensions - - the dimensions of the real-valued input
    
    paddedDimensions - - the required dimensions of the real-valued input (computed)
    
    fftDimensions - - the dimensions of the complex-valued fft after the fast fourier transform (computed), i.e. which dimensions are required for the output
  - dimensionsComplexToComplexFast
```
public static final void dimensionsComplexToComplexFast(Dimensions inputDimensions,
                                                        long[] paddedDimensions)
```
    Computes the supported dimensionality of an input dataset (of complex numbers) for a forward/inverse FFT of the entire dataset AS FAST AS POSSIBLE
    
    Parameters:
    
    inputDimensions - - the dimensions of the input
    
    paddedDimensions - - the required dimensions of the input/output (computed)
  - dimensionsComplexToComplexSmall
```
public static final void dimensionsComplexToComplexSmall(Dimensions inputDimensions,
                                                         long[] paddedDimensions)
```
    Computes the supported dimensionality of an input dataset (of complex numbers) for a forward/inverse FFT of the entire dataset AS SMALL AS POSSIBLE
    
    Parameters:
    
    inputDimensions - - the dimensions of the input
    
    paddedDimensions - - the required dimensions of the input/output (computed)
  - verifyRealToComplexfftDimensions
```
protected static final boolean verifyRealToComplexfftDimensions(int inputSize,
                                                                int outputSize)
```
  - verifyComplexToComplexfftDimensions
```
protected static final boolean verifyComplexToComplexfftDimensions(int inputSize,
                                                                   int outputSize)
```
  - complexConjugate
```
public static final <T extends ComplexType<T>> void complexConjugate(RandomAccessibleInterval<T> complexData)
```

Class FFTMethods

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

FFTMethods

Method Detail

complexToReal

complexToReal

complexToReal

complexToReal

complexToReal

complexToReal

complexToReal

realToComplex

realToComplex

realToComplex

realToComplex

realToComplex

realToComplex

realToComplex

realToComplex

complexToComplex

complexToComplex

complexToComplex

paddingIntervalCentered

unpaddingIntervalCentered

dimensionsComplexToRealSmall

dimensionsComplexToRealFast

dimensionsEqual

dimensionsEqual

dimensionsRealToComplexFast

dimensionsRealToComplexSmall

dimensionsComplexToComplexFast

dimensionsComplexToComplexSmall

verifyRealToComplexfftDimensions

verifyComplexToComplexfftDimensions

complexConjugate