ImageDev

- Getting Started
- ImageDev Python
- ImageDev C#
- ImageDev C++
- Licensing Information
- Redistributable Files
- Processing
- Image Manipulation
- - Synthetic Images
  - - RandomImage2d
    - RandomImage3d
    - RandomGaussianImage2d
    - RandomGaussianImage3d
    - RadialFunctionImage2d
    - RadialFunctionImage3d
    - OrientedLinesImage2d
    - OrientedLinesImage3d
    - RandomSphereImage3d
    - BoxGridImage2d
    - BoxGridImage3d
    - WedgeMaskImage3d
    - PointSpreadFunctionImage3d
  - Image Editing
  - - ConvertImage
    - ResetImage
    - CopyImage
    - PasteImage2d
    - PasteImage3d
    - CropImage2d
    - CropImage3d
    - SampleImage2d
    - SampleImage3d
    - InterlaceFrames2d
    - DeinterlaceFrames2d
  - Stack Operations
  - - SequenceConcatenation
    - SequenceToMultispectral
    - SequenceToVolume
    - VolumeToSequence
    - MultispectralToSequence
    - GetSliceFromVolume3d
    - SetSliceToVolume3d
    - GetObliqueSliceFromVolume3d
    - ImageStackProjection3d
    - VolumeProjection3d
- Geometry And Matching
- - Geometric Transforms
  - - Shearing3d
    - TranslateImage2d
    - TranslateImage3d
    - Flip2d
    - Flip3d
    - FlipImage2d
    - FlipImage3d
    - TransposeImage2d
    - TransposeImage3d
    - SwapQuadrants
    - Rotate2d
    - Rotate3d
    - RotationGenerator3d
    - Resize2d
    - Resize3d
    - RescaleByFactor
    - RescaleImageByFactor
    - ResampleAffine2d
    - ResampleAffine3d
    - ResampleElastic2d
    - SurfaceUnfolding3d
  - Pattern Recognition
  - - BinaryCorrelation2d
    - CrossCorrelation2d
    - CorrelationByDifference2d
    - CorrelationBySignChange2d
  - Registration
  - - ImagePrealignment3d
    - AffineRegistration
    - ElasticRegistration2d
- Arithmetic And Logic
- - Arithmetical Operations
  - - AbsoluteValue
    - AbsoluteMaximumWithImage
    - ArithmeticOperationWithImage
    - ArithmeticOperationWithValue
    - BlendWithImage
    - BlendWithValue
    - DirectionalBlending2d
    - CombineByMask
    - ImageFormula
    - EigenDecomposition2d
    - EigenDecomposition3d
  - Logical Operations
  - - MaskImage
    - LogicalOperationWithImage
    - LogicalOperationWithValue
    - LogicalNot
    - InvertImage
    - BitShift
- Image Filtering
- - Grayscale Transforms
  - - RescaleIntensity
    - StackRescaleIntensity
    - MatchContrast
    - HistogramEqualization
    - Clahe2d
    - Clahe3d
    - AdaptiveHistogramEqualization
    - ApplyGrayscaleLut
    - BackgroundImage2d
    - RadialBackgroundImage2d
    - ShadingCorrection
    - Exponential
    - Logarithm
    - Square
    - SquareRoot
    - RingArtifactRemoval3d
    - BeamHardeningCorrection3d
  - Color Transforms
  - - ColorToLightness
    - GetColorChannel
    - ColorToGrayscale
    - GrayscaleToColor
    - ColorSpaceConversion
    - ColorAntialiasing2d
    - BayerToRgb2d
    - DecorrelationStretch2d
    - BlendAlphaChannelWithImage
    - BlendAlphaChannelWithValue
  - Smoothing And Denoising
  - - BoxFilter2d
    - BoxFilter3d
    - MedianFilter2d
    - MedianFilter3d
    - GaussianFilter2d
    - GaussianFilter3d
    - ExponentialFilter2d
    - RecursiveExponentialFilter2d
    - RecursiveExponentialFilter3d
    - NonLocalMeansFilter2d
    - NonLocalMeansFilter3d
    - CurvatureDrivenDiffusion
    - BilateralFilter2d
    - BilateralFilter3d
    - MajorityFilter2d
    - MajorityFilter3d
    - SigmaFilter2d
    - SigmaFilter3d
    - Despeckle2d
    - Despeckle3d
    - NagaoFilter2d
    - NagaoFilter3d
    - SnnFilter2d
    - SnnFilter3d
    - FlowInpainting
  - Sharpening
  - - Deblurring2d
    - Delineate2d
    - Delineate3d
    - UnsharpMasking2d
    - UnsharpMasking3d
    - Shade2d
    - RichardsonLucyDeconvolution
  - Texture Filters
  - - MeanFilter2d
    - MeanFilter3d
    - VarianceFilter2d
    - VarianceFilter3d
    - SkewnessFilter2d
    - SkewnessFilter3d
    - KurtosisFilter2d
    - KurtosisFilter3d
    - ContrastFilter2d
    - ContrastFilter3d
    - VariationFilter2d
    - VariationFilter3d
    - EnergyFilter2d
    - EnergyFilter3d
    - EntropyFilter2d
    - EntropyFilter3d
    - AutocorrelationFilter
    - LocalAutocorrelationFilter2d
    - ImageCurvature2d
    - ImageCurvature3d
    - StructureEnhancementFilter2d
    - StructureEnhancementFilter3d
    - ScaleSpaceLogFilter2d
    - ScaleSpaceLogFilter3d
  - Frequency Domain
  - - ComplexFft
    - ComplexFftInverse
    - ComplexCenteredFft
    - ComplexCenteredFftInverse
    - CartesianToPolar2d
    - PolarToCartesian2d
    - ConvolutionWithImage
    - ConvolutionWithImage2d
    - RadialFrequencyFilter2d
    - GaborFiltering2d
- Edge Detection
- - Gradient
  - - GradientOperator2d
    - GradientOperator3d
    - VectorToMagnitude2d
    - VectorToMagnitude3d
    - GradientVector2d
    - GradientVector3d
    - GradientMagnitude2d
    - GradientMagnitude3d
    - MorphologicalGradient2d
    - MorphologicalGradient3d
    - RadialGradientCentered2d
    - RadialGradientCentered3d
    - RadialGradientContour2d
    - RadialGradientContour3d
    - RadialGradientLabel2d
    - RadialGradientLabel3d
  - Laplacian
  - - DobFilter2d
    - DobFilter3d
    - MorphologicalLaplacian
    - RecursiveLaplacian2d
    - RecursiveLaplacian3d
  - Other Derivatives
  - - GaussianDerivative2d
    - GaussianDerivative3d
    - GaussianHessianMatrix2d
    - GaussianHessianMatrix3d
    - GaussianGradientTensor2d
    - GaussianGradientTensor3d
  - Edge Marking
  - - ImageLocalMaxima2d
    - ImageLocalMaxima3d
    - RidgeDetection
    - ZeroCrossings2d
    - DijkstraShortestPath2d
    - EigenvaluesToStructureness2d
    - EigenvaluesToStructureness3d
    - TensorVoting2d
    - CannyEdgeDetector2d
    - CannyEdgeDetector3d
- Image Segmentation
- - Binarization
  - - Thresholding
    - ThresholdingByCriterion
    - AutoThresholdingBright
    - AutoThresholdingDark
    - ColorThresholding
    - TopHat
    - FeatureAdaptiveThresholding
    - AdaptiveThresholding2d
    - AdaptiveThresholding3d
    - HysteresisThresholding
  - Labeling
  - - Labeling2d
    - Labeling3d
    - ReorderLabels
    - AssignLabel
    - AddObjectToLabel
    - GroupCloseLabelsl2d
  - Feature Selection
  - - KillBorder2d
    - KillBorder3d
    - RemoveSmallSpots
    - ObjectBoundaries
    - BinarySmoothing2d
    - BinarySmoothing3d
    - LabelInterfaces
  - Separating And Filling
  - - FillHoles2d
    - FillHoles3d
    - RemoveSmallHoles
    - FillImageBorder3d
    - ExpandLabelBoundaries
    - SeparateObjects
    - HExtremaWatershed
    - SeparateObjectsByBlock
    - HExtremaWatershedByBlock
    - ConvexHull2d
  - Region Growing
  - - MarkerBasedWatershed2d
    - MarkerBasedWatershed3d
    - MarkerBasedWatershedByBlock
    - MarkerBasedWatershedBasinsByBlock
    - ExpandLabelsOnBackground
    - FloodFillThreshold2d
    - FloodFillThreshold3d
    - Waterpixel
  - Computational Geometry
  - - PolylineResampler2d
    - PolylineResampler3d
    - PolylineExtrusion3d
    - SurfaceFitting3d
- Mathematical Morphology
- - Erosion And Dilation
  - - Erosion2d
    - Erosion3d
    - Dilation2d
    - Dilation3d
    - ErosionDisk2d
    - ErosionDisk3d
    - ErosionBall3d
    - DilationDisk2d
    - DilationDisk3d
    - DilationBall3d
    - ErosionLine2d
    - ErosionLine3d
    - DilationLine2d
    - DilationLine3d
    - ErosionColor2d
    - DilationColor2d
    - SelectiveErosion2d
    - SelectiveErosion3d
    - SelectiveDilation2d
    - SelectiveDilation3d
  - Opening And Closing
  - - Opening2d
    - Opening3d
    - Closing2d
    - Closing3d
    - OpeningDisk2d
    - OpeningDisk3d
    - OpeningBall3d
    - ClosingDisk2d
    - ClosingDisk3d
    - ClosingBall3d
    - OpeningLine2d
    - OpeningLine3d
    - ClosingLine2d
    - ClosingLine3d
    - OpeningLineMaximum
    - ClosingLineMinimum
    - OpeningColor2d
    - ClosingColor2d
    - OpeningByReconstruction2d
    - OpeningByReconstruction3d
    - ClosingByReconstruction2d
    - ClosingByReconstruction3d
    - OpeningDiskByReconstruction2d
    - OpeningBallByReconstruction3d
    - ClosingDiskByReconstruction2d
    - ClosingBallByReconstruction3d
    - SelectiveOpening2d
    - SelectiveOpening3d
    - SelectiveClosing2d
    - SelectiveClosing3d
  - Hit Or Miss And Skeleton
  - - Skeleton
    - Centerline3d
    - InfluenceZones
    - Centroid2d
    - EndPoints2d
    - EndPoints3d
    - Pruning2d
    - Pruning3d
    - IsolatedPoints2d
    - IsolatedPoints3d
    - TriplePoints2d
    - InteriorPoints2d
    - ApplyMorphologicalLut2d
    - ApplyMorphologicalLut3d
  - Geodesic Transformations
  - - ReconstructionFromMarkers2d
    - ReconstructionFromMarkers3d
    - GrayscaleReconstruction2d
    - GrayscaleReconstruction3d
    - GrayscaleFillHoles2d
    - GrayscaleFillHoles3d
    - HExtrema2d
    - HExtrema3d
    - RegionalExtrema2d
    - RegionalExtrema3d
    - UltimateErosion
  - Distance Maps
  - - DistanceMap2d
    - DistanceMap3d
    - EuclideanDistanceMap3d
    - EuclideanDistanceMap2d
    - GeodesicDistanceMap
    - ClosestBoundaryPoints2d
    - ClosestBoundaryPoints3d
    - TimeMap
    - LocalThicknessMap3d
    - GeodesicPropagation2d
    - GeodesicMaxima
    - GeodesicMinima
- Image Analysis
- - Image Measurements
  - - BinaryAnalysis
    - Area2d
    - Area3d
    - IntensityIntegral2d
    - IntensityIntegral3d
    - ObjectCount
    - DistanceMean2d
    - EulerNumber2d
    - EulerNumber3d
    - FractalDimension
    - CurvatureIntegrals3d
  - Image Statistics
  - - IntensityExtrema
    - IntensityStatistics
    - IntensityMaskedStatistics
    - IntensityHistogram
    - IntensityBinHistogram
    - AutoThresholdingValue
    - CompareImage
    - CompareValue
    - SimilarityMetricValue
    - SsimValue2d
    - SsimValue3d
    - RegionSimilarity
    - RadialIntensityProfile2d
    - RadialIntensityProfile3d
    - CylindricalIntensityProfile3d
    - RadialAutocorrelationProfile
    - Cooccurrence2d
    - MeasureGaussianNoise
    - LocalMaxima2d
    - LocalMaxima3d
    - PeakExtractor
    - LocalDensityMap2d
    - LocalDensityMap3d
    - SegmentationMetrics
  - Individual Measurements
  - - VolumeFractionByLabel
    - LabelCountByRegion
    - VolumeFractionByRegion
    - LabelAnalysis
    - LabelFiltering
    - LabelFilteringAnalysis
    - FilterAnalysis
    - MeasurementToImage
    - FilterByMeasurement
    - SieveLabeling
  - Moments And Orientations
  - - MomentsOfInertia2d
    - MomentsOfInertia3d
    - InertiaMoment2d
    - Eccentricity2d
    - OrientationMapFourier3d
    - OrientationMatchingFourier3d
  - Morphometry
  - - ObjectVolume
    - TotalImageVolume
    - ObjectBoundaryArea
    - TotalImageBoundaryArea
    - AverageObjectAreaPerSlice3d
    - AverageObjectCountPerSlice3d
    - ObjectImageRatio
    - ObjectSpecificSurface
    - ObjectSurfaceDensity
    - PorosityPercentage3d
    - FragmentationIndex
    - StructureModelIndex3d
    - AverageObjectThickness3d
    - AverageSpaceThickness3d
    - ObjectLinearDensity3d
    - DegreeOfAnisotropy
  - Propagation
  - - AxisPropagationBinary3d
    - AxisPropagationBinaryWithSeeds3d
    - AxisPropagationLabel3d
    - AxisPropagationLabelWithSeeds3d
    - AxisPropagationDistance3d
    - EstimateShortestPath3d
    - PercolationThreshold3d
    - AxisConnectivity3d
    - CentroidPathTortuosity3d
- Machine Learning
- - Classification
  - - AutoSegmentation3Phases
    - AutoIntensityClassification
    - SupervisedTextureClassification2d
    - SupervisedTextureClassification3d
    - TextureClassificationCreate
    - TextureClassificationTrain
    - TextureClassificationApply
  - Deep learning
  - - OnnxPredictionFiltering2d
    - OnnxPredictionFiltering3d
    - OnnxPredictionSegmentation2d
    - OnnxPredictionSegmentation3d
    - OnnxPredictionTwoOutputs2d
    - OnnxPredictionTwoOutputs3d
- Business Application
- - Dental
  - - DentalWallSegmentation3d
    - DentalMeshExtraction3d
    - DentalUnfolding3d
- IO
- - Image Data
  - - ReadVipImage
    - WriteVipImage
  - Algebraic Data
  - - ReadArrayXd
    - ReadArrayXi64
    - WriteArrayXd
    - WriteArrayXi64
  - Model
  - - ReadOnnxModel
- CUDA
- - Geometry And Matching
  - - CudaCrossCorrelation2d
    - CudaTemplateMatching3d
  - Image Filtering
  - - CudaBoxFilter2d
    - CudaMedianFilter2d
    - CudaGaussianFilter3d
    - CudaAdaptiveManifoldNlmFilter
  - Mathematical Morphology
  - - CudaErosion2d
    - CudaDilation2d
    - CudaOpening2d
    - CudaClosing2d
- Utilities
- Initialization
- Processing
- Syntax Check
- Visualization
- Data Object
- Image Data
- Kernels
- - MorphologicalKernel2d
  - MorphologicalKernel3d
  - MorphologicalLut2d
  - MorphologicalLut3d
- Model
- - TextureClassificationModel
  - OnnxModel
- Global Measurements
- - Image Measurements
  - - Area2dMsr
    - Area3dMsr
    - IntensityIntegral2dMsr
    - IntensityIntegral3dMsr
    - ObjectCountMsr
    - DistanceMeanMsr
    - Euler2dMsr
    - Euler3dMsr
    - FractalMsr
    - CurvatureIntegralsMsr
  - Image Statistics
  - - IntensityExtremaMsr
    - StatisticsMsr
    - IntensityHistogramMsr
    - IntensityBinHistogramMsr
    - CompareMsr
    - SimilarityMetricValueMsr
    - SsimValueMsr
    - RegionSimilarityMsr
    - SegmentationMetricsObjectMsr
    - SegmentationMetricsImageMsr
    - CylindricalIntensityProfileMsr
    - RadialIntensityProfileMsr
    - CorrelationMsr
    - CoocurrrenceMsr
    - GaussianNoiseMsr
    - LocalMaximaMsr
    - PeakExtractorMsr
  - Individual Measurements
  - - VolumeFractionByLabelMsr
    - LabelCountByRegionMsr
    - VolumeFractionByRegionMsr
  - Moments And Orientations
  - - MomentsOfInertia2dMsr
    - MomentsOfInertia3dMsr
    - MeanInertiaMomentMsr
    - Eccentricity2dMsr
    - LocalOrientation3dMsr
  - Morphometry
  - - ObjectVolumeMsr
    - ImageVolumeMsr
    - ObjectBoundaryAreaMsr
    - ImageBoundaryAreaMsr
    - AverageObjectAreaPerSliceMsr
    - AverageObjectCountPerSliceMsr
    - ObjectImageRatioMsr
    - ObjectSpecificSurfaceMsr
    - ObjectSurfaceDensityMsr
    - PorosityPercentageMsr
    - FragmentationMsr
    - StructureModelIndexMsr
    - AverageObjectThicknessMsr
    - AverageSpaceThicknessMsr
    - ObjectLinearDensityMsr
    - AnisotropyDegreeMsr
  - Propagation
  - - AxisPropagationBinary3dMsr
    - AxisPropagationLabel3dMsr
    - AxisPropagationDistance3dMsr
    - PercolationThreshold3dMsr
    - CentroidTortuosity3dMsr
  - Geometry And Matching
  - - CrossCorrelation2dMsr
  - Edge Detection
  - - CannyEdgeDetectorMsr
  - Image Segmentation
  - - AutoThresholdingMsr
    - AutoSegmentation3PhasesMsr
  - Mathematical Morphology
  - - ApplyMorphologicalLutMsr
- Analysis Measurements
- - AnalysisMsr
  - Measurement
  - Native Measurements
  - - Geometry
    - Feret
    - Intensity
    - Histogram
    - Inertia
    - Locate
    - Segment
    - Cooccurrence
  - CustomMeasurement
  - MeasurementAttributes
  - - Quantile
    - Histogram
    - Feret2d
    - Feret3d
    - NeighborCount
    - Cooccurrence
    - Breadth3d
  - MeasurementGroup
- Measurement Information
- - FieldInformation
  - CustomMeasurementInfo
- CUDA
- - CudaContext
- User Guide
- First Steps
- - Hello ImageDev
  - Initialize ImageDev
- Image Management
- - Create 2D Image
  - Create 3D Image
  - Data Transfer
- Standard Processing
- - Denoising
  - Thresholding
- Image Analysis
- - Global Analysis
  - Label Analysis
  - Measurement Browsing
  - Measurement Group
  - Custom Analysis
- Advanced Processing
- - Algorithm Tracking
- Typical Use Cases
- - Particle Analysis
  - Pore Analysis

# ComplexFftInverse

Computes the Fast Fourier inverse Transform of an image.
Access to parameter description
For an introduction: see section Frequency Domain.
This algorithm computes the inverse FFT of an image. The result is two floating point images, respectively the real and imaginary parts of the complex inverse Fourier Transform.
Remarks

- A classical operation is to first filter the spectrum of an image (especially to suppress high frequencies usually associated with noise), and then reconstruct the input image using ComplexFftInverse with the filtered spectrum and unchanged phase as input images.
- Images are centered in the upper left corner. The ComplexCenteredFft algorithm can be used to directly get a centered FFT.

See also

- ComplexFft
- ComplexCenteredFftInverse

##
Function Syntax

This function returns a ComplexFftInverseOutput structure containing outputRealImage and outputImaginaryImage.

    // Output structure of the complexFftInverse function.
    struct ComplexFftInverseOutput
    {
        /// The output real part image. Its dimensions are forced to the same values as the input. Its data type is forced to floating point.
        std::shared_ptr< iolink::ImageView > outputRealImage;
        /// The output imaginary part image. Its dimensions are forced to the same values as the input. Its data type is forced to floating point.
        std::shared_ptr< iolink::ImageView > outputImaginaryImage;
    };

    // Function prototype
    ComplexFftInverseOutput
    complexFftInverse( std::shared_ptr< iolink::ImageView > inputRealImage,
                       std::shared_ptr< iolink::ImageView > inputImaginaryImage,
                       std::shared_ptr< iolink::ImageView > outputRealImage = nullptr,
                       std::shared_ptr< iolink::ImageView > outputImaginaryImage = nullptr );

This function returns a tuple containing output_real_image and output_imaginary_image.

    // Function prototype.
    complex_fft_inverse(input_real_image: idt.ImageType,
                        input_imaginary_image: idt.ImageType,
                        output_real_image: idt.ImageType = None,
                        output_imaginary_image: idt.ImageType = None) -> Tuple[idt.ImageType, idt.ImageType]

This function returns a ComplexFftInverseOutput structure containing outputRealImage and outputImaginaryImage.

    /// Output structure of the ComplexFftInverse function.
    public struct ComplexFftInverseOutput
    {
        ///
        /// The output real part image. Its dimensions are forced to the same values as the input. Its data type is forced to floating point.
        ///
        public IOLink.ImageView outputRealImage;
        ///
        /// The output imaginary part image. Its dimensions are forced to the same values as the input. Its data type is forced to floating point.
        ///
        public IOLink.ImageView outputImaginaryImage;
    };

    // Function prototype.
    public static ComplexFftInverseOutput
    ComplexFftInverse( IOLink.ImageView inputRealImage,
                       IOLink.ImageView inputImaginaryImage,
                       IOLink.ImageView outputRealImage = null,
                       IOLink.ImageView outputImaginaryImage = null );

##
Class Syntax

    // Command constructor.
    ComplexFftInverse();

    /// Gets the inputRealImage parameter.
    /// The real part input image. It must be a floating point image.
    std::shared_ptr< iolink::ImageView > inputRealImage() const;
    /// Sets the inputRealImage parameter.
    /// The real part input image. It must be a floating point image.
    void setInputRealImage( std::shared_ptr< iolink::ImageView > inputRealImage );

    /// Gets the inputImaginaryImage parameter.
    /// The imaginary part input image. This image must have same dimensions and data type as the real input image.
    std::shared_ptr< iolink::ImageView > inputImaginaryImage() const;
    /// Sets the inputImaginaryImage parameter.
    /// The imaginary part input image. This image must have same dimensions and data type as the real input image.
    void setInputImaginaryImage( std::shared_ptr< iolink::ImageView > inputImaginaryImage );

    /// Gets the outputRealImage parameter.
    /// The output real part image. Its dimensions are forced to the same values as the input. Its data type is forced to floating point.
    std::shared_ptr< iolink::ImageView > outputRealImage() const;
    /// Sets the outputRealImage parameter.
    /// The output real part image. Its dimensions are forced to the same values as the input. Its data type is forced to floating point.
    void setOutputRealImage( std::shared_ptr< iolink::ImageView > outputRealImage );

    /// Gets the outputImaginaryImage parameter.
    /// The output imaginary part image. Its dimensions are forced to the same values as the input. Its data type is forced to floating point.
    std::shared_ptr< iolink::ImageView > outputImaginaryImage() const;
    /// Sets the outputImaginaryImage parameter.
    /// The output imaginary part image. Its dimensions are forced to the same values as the input. Its data type is forced to floating point.
    void setOutputImaginaryImage( std::shared_ptr< iolink::ImageView > outputImaginaryImage );

    // Method to launch the command.
    void execute();

    # Property of the inputRealImage parameter.
    ComplexFftInverse.input_real_image
    # Property of the inputImaginaryImage parameter.
    ComplexFftInverse.input_imaginary_image
    # Property of the outputRealImage parameter.
    ComplexFftInverse.output_real_image
    # Property of the outputImaginaryImage parameter.
    ComplexFftInverse.output_imaginary_image

    // Method to launch the command.
    execute()

    // Command constructor.
    ComplexFftInverse()

    // Property of the inputRealImage parameter.
    ComplexFftInverse.inputRealImage
    // Property of the inputImaginaryImage parameter.
    ComplexFftInverse.inputImaginaryImage
    // Property of the outputRealImage parameter.
    ComplexFftInverse.outputRealImage
    // Property of the outputImaginaryImage parameter.
    ComplexFftInverse.outputImaginaryImage

    // Method to launch the command.
    Execute()

## Parameters

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| inputRealImage | The real part input image. It must be a floating point image. | Image | Grayscale or Multispectral | nullptr
| inputImaginaryImage | The imaginary part input image. This image must have same dimensions and data type as the real input image. | Image | Grayscale or Multispectral | nullptr
| outputRealImage | The output real part image. Its dimensions are forced to the same values as the input. Its data type is forced to floating point. | Image |  | nullptr
| outputImaginaryImage | The output imaginary part image. Its dimensions are forced to the same values as the input. Its data type is forced to floating point. | Image |  | nullptr

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| input_real_image | The real part input image. It must be a floating point image. | image | Grayscale or Multispectral | None
| input_imaginary_image | The imaginary part input image. This image must have same dimensions and data type as the real input image. | image | Grayscale or Multispectral | None
| output_real_image | The output real part image. Its dimensions are forced to the same values as the input. Its data type is forced to floating point. | image |  | None
| output_imaginary_image | The output imaginary part image. Its dimensions are forced to the same values as the input. Its data type is forced to floating point. | image |  | None

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| inputRealImage | The real part input image. It must be a floating point image. | Image | Grayscale or Multispectral | null
| inputImaginaryImage | The imaginary part input image. This image must have same dimensions and data type as the real input image. | Image | Grayscale or Multispectral | null
| outputRealImage | The output real part image. Its dimensions are forced to the same values as the input. Its data type is forced to floating point. | Image |  | null
| outputImaginaryImage | The output imaginary part image. Its dimensions are forced to the same values as the input. Its data type is forced to floating point. | Image |  | null

## Object Examples

    auto polystyrene_float = readVipImage( std::string( IMAGEDEVDATA_IMAGES_FOLDER ) + "polystyrene_float.vip" );

    ComplexFftInverse complexFftInverseAlgo;
    complexFftInverseAlgo.setInputRealImage( polystyrene_float );
    complexFftInverseAlgo.setInputImaginaryImage( polystyrene_float );
    complexFftInverseAlgo.execute();

    std::cout << "outputRealImage:" << complexFftInverseAlgo.outputRealImage()->toString();
    std::cout << "outputImaginaryImage:" << complexFftInverseAlgo.outputImaginaryImage()->toString();

    polystyrene_float = imagedev.read_vip_image(imagedev_data.get_image_path("polystyrene_float.vip"))

    complex_fft_inverse_algo = imagedev.ComplexFftInverse()
    complex_fft_inverse_algo.input_real_image = polystyrene_float
    complex_fft_inverse_algo.input_imaginary_image = polystyrene_float
    complex_fft_inverse_algo.execute()

    print("output_real_image:", str(complex_fft_inverse_algo.output_real_image))
    print("output_imaginary_image:", str(complex_fft_inverse_algo.output_imaginary_image))

    ImageView polystyrene_float = Data.ReadVipImage( @"Data/images/polystyrene_float.vip" );

    ComplexFftInverse complexFftInverseAlgo = new ComplexFftInverse
    {
        inputRealImage = polystyrene_float,
        inputImaginaryImage = polystyrene_float
    };
    complexFftInverseAlgo.Execute();

    Console.WriteLine( "outputRealImage:" + complexFftInverseAlgo.outputRealImage.ToString() );
    Console.WriteLine( "outputImaginaryImage:" + complexFftInverseAlgo.outputImaginaryImage.ToString() );

## Function Examples

    auto polystyrene_float = readVipImage( std::string( IMAGEDEVDATA_IMAGES_FOLDER ) + "polystyrene_float.vip" );

    auto result = complexFftInverse( polystyrene_float, polystyrene_float );

    std::cout << "outputRealImage:" << result.outputRealImage->toString();
    std::cout << "outputImaginaryImage:" << result.outputImaginaryImage->toString();

    polystyrene_float = imagedev.read_vip_image(imagedev_data.get_image_path("polystyrene_float.vip"))

    result_output_real_image, result_output_imaginary_image = imagedev.complex_fft_inverse(polystyrene_float, polystyrene_float)

    print("output_real_image:", str(result_output_real_image))
    print("output_imaginary_image:", str(result_output_imaginary_image))

    ImageView polystyrene_float = Data.ReadVipImage( @"Data/images/polystyrene_float.vip" );

    Processing.ComplexFftInverseOutput result = Processing.ComplexFftInverse( polystyrene_float, polystyrene_float );

    Console.WriteLine( "outputRealImage:" + result.outputRealImage.ToString() );
    Console.WriteLine( "outputImaginaryImage:" + result.outputImaginaryImage.ToString() );

© 2025 Thermo Fisher Scientific Inc. All rights reserved.