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

# RadialFrequencyFilter2d

Filters a two-dimensional image by applying a radial background subtraction on the Fourier transform.
Access to parameter description
This algorithm applies a radial background correction in the Fourier domain, then eliminates the high frequencies by applying a circular mask and reverts to the spatial domain. This filter is especially useful for highlighting periodic structures such as crystalline material in high-resolution electron microscope images, as shown in Figure 1.

Figure 1. Input HRTEM image and result of radial frequency filter
This algorithm:

- Computes the centered Fourier transform (modulus and argument).
- Estimates a background image from the modulus of the Fourier transform by using a radial basis function.
- Subtracts the background image to the modulus of the Fourier transform.
- Computes the image having as modulus the result of the subtraction and as argument the original argument of the input image.

The background model can be based on different types of approximation. The model type is defined by the backgroundModel parameter.
The subtraction can be computed in different ways. The subtraction formula is defined by the filterMode parameter.
Reference:
R. Kilaas, "Optimal and near-optimal filters in high-resolution electron microscopy". Journal of Microscopy, 190, pp. 45-51, 1998.
See also

- ComplexCenteredFft
- RadialBackgroundImage2d
- RadialIntensityProfile2d
- RadialFunctionImage2d

##
Function Syntax

This function returns outputImage.

    // Function prototype
    std::shared_ptr< iolink::ImageView >
    radialFrequencyFilter2d( std::shared_ptr< iolink::ImageView > inputImage,
                             RadialFrequencyFilter2d::FilterMode filterMode,
                             RadialFrequencyFilter2d::BackgroundModel backgroundModel,
                             bool removeHighFrequencies,
                             double cutoffFrequency,
                             double transitionBand,
                             std::shared_ptr< iolink::ImageView > outputImage = nullptr );

This function returns outputImage.

    // Function prototype.
    radial_frequency_filter_2d(input_image: idt.ImageType,
                               filter_mode: RadialFrequencyFilter2d.FilterMode = RadialFrequencyFilter2d.FilterMode.SUBTRACT,
                               background_model: RadialFrequencyFilter2d.BackgroundModel = RadialFrequencyFilter2d.BackgroundModel.AVERAGE,
                               remove_high_frequencies: bool = True,
                               cutoff_frequency: float = 0.8,
                               transition_band: float = 0.05,
                               output_image: idt.ImageType = None) -> idt.ImageType

This function returns outputImage.

    // Function prototype.
    public static IOLink.ImageView
    RadialFrequencyFilter2d( IOLink.ImageView inputImage,
                             RadialFrequencyFilter2d.FilterMode filterMode = ImageDev.RadialFrequencyFilter2d.FilterMode.SUBTRACT,
                             RadialFrequencyFilter2d.BackgroundModel backgroundModel = ImageDev.RadialFrequencyFilter2d.BackgroundModel.AVERAGE,
                             bool removeHighFrequencies = true,
                             double cutoffFrequency = 0.8,
                             double transitionBand = 0.05,
                             IOLink.ImageView outputImage = null );

##
Class Syntax

    // Command constructor.
    RadialFrequencyFilter2d();

    /// Gets the inputImage parameter.
    /// The input image. Its data type can be integer or floating point.
    std::shared_ptr< iolink::ImageView > inputImage() const;
    /// Sets the inputImage parameter.
    /// The input image. Its data type can be integer or floating point.
    void setInputImage( std::shared_ptr< iolink::ImageView > inputImage );

    /// Gets the filterMode parameter.
    /// The way to compute the background subtraction in the Fourier domain.
    RadialFrequencyFilter2d::FilterMode filterMode() const;
    /// Sets the filterMode parameter.
    /// The way to compute the background subtraction in the Fourier domain.
    void setFilterMode( const RadialFrequencyFilter2d::FilterMode& filterMode );

    /// Gets the backgroundModel parameter.
    /// The way to estimate the background model of the Fourier transform module.
    RadialFrequencyFilter2d::BackgroundModel backgroundModel() const;
    /// Sets the backgroundModel parameter.
    /// The way to estimate the background model of the Fourier transform module.
    void setBackgroundModel( const RadialFrequencyFilter2d::BackgroundModel& backgroundModel );

    /// Gets the removeHighFrequencies parameter.
    /// Indicates whether high frequencies outside the cut-off frequency should be removed by a circular mask. This post processing applies a low pass filter and can be useful for removing noise.
    bool removeHighFrequencies() const;
    /// Sets the removeHighFrequencies parameter.
    /// Indicates whether high frequencies outside the cut-off frequency should be removed by a circular mask. This post processing applies a low pass filter and can be useful for removing noise.
    void setRemoveHighFrequencies( const bool& removeHighFrequencies );

    /// Gets the cutoffFrequency parameter.
    /// Fraction of the Maximum Frequency of the image. A value of 0.5 implies that the circular mask has a diameter equal to the half width of the FFT image. This parameter is ignored if removeHighFrequencies is set to false. It must be a strictly positive value, lower than or equal to 1.
    double cutoffFrequency() const;
    /// Sets the cutoffFrequency parameter.
    /// Fraction of the Maximum Frequency of the image. A value of 0.5 implies that the circular mask has a diameter equal to the half width of the FFT image. This parameter is ignored if removeHighFrequencies is set to false. It must be a strictly positive value, lower than or equal to 1.
    void setCutoffFrequency( const double& cutoffFrequency );

    /// Gets the transitionBand parameter.
    /// Fraction of the cut-off frequency to define the width of the transition band. This parameter is ignored if removeHighFrequencies is set to false. It must be a positive or null value, lower than or equal to 1.
    double transitionBand() const;
    /// Sets the transitionBand parameter.
    /// Fraction of the cut-off frequency to define the width of the transition band. This parameter is ignored if removeHighFrequencies is set to false. It must be a positive or null value, lower than or equal to 1.
    void setTransitionBand( const double& transitionBand );

    /// Gets the outputImage parameter.
    /// The output image. The output image characteristics are forced to the same as the input image.
    std::shared_ptr< iolink::ImageView > outputImage() const;
    /// Sets the outputImage parameter.
    /// The output image. The output image characteristics are forced to the same as the input image.
    void setOutputImage( std::shared_ptr< iolink::ImageView > outputImage );

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

    # Property of the inputImage parameter.
    RadialFrequencyFilter2d.input_image
    # Property of the filterMode parameter.
    RadialFrequencyFilter2d.filter_mode
    # Property of the backgroundModel parameter.
    RadialFrequencyFilter2d.background_model
    # Property of the removeHighFrequencies parameter.
    RadialFrequencyFilter2d.remove_high_frequencies
    # Property of the cutoffFrequency parameter.
    RadialFrequencyFilter2d.cutoff_frequency
    # Property of the transitionBand parameter.
    RadialFrequencyFilter2d.transition_band
    # Property of the outputImage parameter.
    RadialFrequencyFilter2d.output_image

    // Method to launch the command.
    execute()

    // Command constructor.
    RadialFrequencyFilter2d()

    // Property of the inputImage parameter.
    RadialFrequencyFilter2d.inputImage
    // Property of the filterMode parameter.
    RadialFrequencyFilter2d.filterMode
    // Property of the backgroundModel parameter.
    RadialFrequencyFilter2d.backgroundModel
    // Property of the removeHighFrequencies parameter.
    RadialFrequencyFilter2d.removeHighFrequencies
    // Property of the cutoffFrequency parameter.
    RadialFrequencyFilter2d.cutoffFrequency
    // Property of the transitionBand parameter.
    RadialFrequencyFilter2d.transitionBand
    // Property of the outputImage parameter.
    RadialFrequencyFilter2d.outputImage

    // Method to launch the command.
    Execute()

## Parameters

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| inputImage | The input image. Its data type can be integer or floating point. | Image | Grayscale or Multispectral | nullptr
| filterMode | The way to compute the background subtraction in the Fourier domain.
SUBTRACT | The background image B is simply subtracted from the modulus of the Fourier transform |I|. $|O|=|I|-B$, where $|O|$ is the modulus of the output image. The negative pixel values are clamped to zero.
WIENER | The square of the background image B is subtracted from the square of the modulus of the Fourier transform |I|. The result of the subtraction is divided by the modulus of the Fourier transform: $|O|=\frac{|I|^2-B^2}{|I|}$, where $|O|$ is the modulus of the output image. The negative pixel values are clamped to zero.
| Enumeration |  | SUBTRACT
| backgroundModel | The way to estimate the background model of the Fourier transform module.
AVERAGE | The background is estimated as a radial average of the Fourier transform of the whole image.
POLYNOME | The background is estimated by a polynomial fit to the radial average of the Fourier transform of the whole image.
| Enumeration |  | AVERAGE
| removeHighFrequencies | Indicates whether high frequencies outside the cut-off frequency should be removed by a circular mask. This post processing applies a low pass filter and can be useful for removing noise. | Bool |  | true
| cutoffFrequency | Fraction of the Maximum Frequency of the image. A value of 0.5 implies that the circular mask has a diameter equal to the half width of the FFT image. This parameter is ignored if removeHighFrequencies is set to false. It must be a strictly positive value, lower than or equal to 1. | Float64 | ]0, 1] | 0.8
| transitionBand | Fraction of the cut-off frequency to define the width of the transition band. This parameter is ignored if removeHighFrequencies is set to false. It must be a positive or null value, lower than or equal to 1. The transition band smooths the border of the circular mask between [cutoffFrequency*(1 - transitionBand)] and [cutoffFrequency*(1 + transitionBand)]. | Float64 | [0, 1] | 0.05
| outputImage | The output image. The output image characteristics are forced to the same as the input image. | Image |  | nullptr

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| input_image | The input image. Its data type can be integer or floating point. | image | Grayscale or Multispectral | None
| filter_mode | The way to compute the background subtraction in the Fourier domain.
SUBTRACT | The background image B is simply subtracted from the modulus of the Fourier transform |I|. $|O|=|I|-B$, where $|O|$ is the modulus of the output image. The negative pixel values are clamped to zero.
WIENER | The square of the background image B is subtracted from the square of the modulus of the Fourier transform |I|. The result of the subtraction is divided by the modulus of the Fourier transform: $|O|=\frac{|I|^2-B^2}{|I|}$, where $|O|$ is the modulus of the output image. The negative pixel values are clamped to zero.
| enumeration |  | SUBTRACT
| background_model | The way to estimate the background model of the Fourier transform module.
AVERAGE | The background is estimated as a radial average of the Fourier transform of the whole image.
POLYNOME | The background is estimated by a polynomial fit to the radial average of the Fourier transform of the whole image.
| enumeration |  | AVERAGE
| remove_high_frequencies | Indicates whether high frequencies outside the cut-off frequency should be removed by a circular mask. This post processing applies a low pass filter and can be useful for removing noise. | bool |  | True
| cutoff_frequency | Fraction of the Maximum Frequency of the image. A value of 0.5 implies that the circular mask has a diameter equal to the half width of the FFT image. This parameter is ignored if removeHighFrequencies is set to false. It must be a strictly positive value, lower than or equal to 1. | float64 | ]0, 1] | 0.8
| transition_band | Fraction of the cut-off frequency to define the width of the transition band. This parameter is ignored if removeHighFrequencies is set to false. It must be a positive or null value, lower than or equal to 1. The transition band smooths the border of the circular mask between [cutoffFrequency*(1 - transitionBand)] and [cutoffFrequency*(1 + transitionBand)]. | float64 | [0, 1] | 0.05
| output_image | The output image. The output image characteristics are forced to the same as the input image. | image |  | None

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| inputImage | The input image. Its data type can be integer or floating point. | Image | Grayscale or Multispectral | null
| filterMode | The way to compute the background subtraction in the Fourier domain.
SUBTRACT | The background image B is simply subtracted from the modulus of the Fourier transform |I|. $|O|=|I|-B$, where $|O|$ is the modulus of the output image. The negative pixel values are clamped to zero.
WIENER | The square of the background image B is subtracted from the square of the modulus of the Fourier transform |I|. The result of the subtraction is divided by the modulus of the Fourier transform: $|O|=\frac{|I|^2-B^2}{|I|}$, where $|O|$ is the modulus of the output image. The negative pixel values are clamped to zero.
| Enumeration |  | SUBTRACT
| backgroundModel | The way to estimate the background model of the Fourier transform module.
AVERAGE | The background is estimated as a radial average of the Fourier transform of the whole image.
POLYNOME | The background is estimated by a polynomial fit to the radial average of the Fourier transform of the whole image.
| Enumeration |  | AVERAGE
| removeHighFrequencies | Indicates whether high frequencies outside the cut-off frequency should be removed by a circular mask. This post processing applies a low pass filter and can be useful for removing noise. | Bool |  | true
| cutoffFrequency | Fraction of the Maximum Frequency of the image. A value of 0.5 implies that the circular mask has a diameter equal to the half width of the FFT image. This parameter is ignored if removeHighFrequencies is set to false. It must be a strictly positive value, lower than or equal to 1. | Float64 | ]0, 1] | 0.8
| transitionBand | Fraction of the cut-off frequency to define the width of the transition band. This parameter is ignored if removeHighFrequencies is set to false. It must be a positive or null value, lower than or equal to 1. The transition band smooths the border of the circular mask between [cutoffFrequency*(1 - transitionBand)] and [cutoffFrequency*(1 + transitionBand)]. | Float64 | [0, 1] | 0.05
| outputImage | The output image. The output image characteristics are forced to the same as the input image. | Image |  | null

## Object Examples

    auto polystyrene = ioformat::readImage( std::string( IMAGEDEVDATA_IMAGES_FOLDER ) + "polystyrene.tif" );

    RadialFrequencyFilter2d radialFrequencyFilter2dAlgo;
    radialFrequencyFilter2dAlgo.setInputImage( polystyrene );
    radialFrequencyFilter2dAlgo.setFilterMode( RadialFrequencyFilter2d::FilterMode::SUBTRACT );
    radialFrequencyFilter2dAlgo.setBackgroundModel( RadialFrequencyFilter2d::BackgroundModel::AVERAGE );
    radialFrequencyFilter2dAlgo.setRemoveHighFrequencies( true );
    radialFrequencyFilter2dAlgo.setCutoffFrequency( 0.8 );
    radialFrequencyFilter2dAlgo.setTransitionBand( 0.05 );
    radialFrequencyFilter2dAlgo.execute();

    std::cout << "outputImage:" << radialFrequencyFilter2dAlgo.outputImage()->toString();

    polystyrene = ioformat.read_image(imagedev_data.get_image_path("polystyrene.tif"))

    radial_frequency_filter_2d_algo = imagedev.RadialFrequencyFilter2d()
    radial_frequency_filter_2d_algo.input_image = polystyrene
    radial_frequency_filter_2d_algo.filter_mode = imagedev.RadialFrequencyFilter2d.SUBTRACT
    radial_frequency_filter_2d_algo.background_model = imagedev.RadialFrequencyFilter2d.AVERAGE
    radial_frequency_filter_2d_algo.remove_high_frequencies = True
    radial_frequency_filter_2d_algo.cutoff_frequency = 0.8
    radial_frequency_filter_2d_algo.transition_band = 0.05
    radial_frequency_filter_2d_algo.execute()

    print("output_image:", str(radial_frequency_filter_2d_algo.output_image))

    ImageView polystyrene = ViewIO.ReadImage( @"Data/images/polystyrene.tif" );

    RadialFrequencyFilter2d radialFrequencyFilter2dAlgo = new RadialFrequencyFilter2d
    {
        inputImage = polystyrene,
        filterMode = RadialFrequencyFilter2d.FilterMode.SUBTRACT,
        backgroundModel = RadialFrequencyFilter2d.BackgroundModel.AVERAGE,
        removeHighFrequencies = true,
        cutoffFrequency = 0.8,
        transitionBand = 0.05
    };
    radialFrequencyFilter2dAlgo.Execute();

    Console.WriteLine( "outputImage:" + radialFrequencyFilter2dAlgo.outputImage.ToString() );

## Function Examples

    auto polystyrene = ioformat::readImage( std::string( IMAGEDEVDATA_IMAGES_FOLDER ) + "polystyrene.tif" );

    auto result = radialFrequencyFilter2d( polystyrene, RadialFrequencyFilter2d::FilterMode::SUBTRACT, RadialFrequencyFilter2d::BackgroundModel::AVERAGE, true, 0.8, 0.05 );

    std::cout << "outputImage:" << result->toString();

    polystyrene = ioformat.read_image(imagedev_data.get_image_path("polystyrene.tif"))

    result = imagedev.radial_frequency_filter_2d(polystyrene, imagedev.RadialFrequencyFilter2d.SUBTRACT, imagedev.RadialFrequencyFilter2d.AVERAGE, True, 0.8, 0.05)

    print("output_image:", str(result))

    ImageView polystyrene = ViewIO.ReadImage( @"Data/images/polystyrene.tif" );

    IOLink.ImageView result = Processing.RadialFrequencyFilter2d( polystyrene, RadialFrequencyFilter2d.FilterMode.SUBTRACT, RadialFrequencyFilter2d.BackgroundModel.AVERAGE, true, 0.8, 0.05 );

    Console.WriteLine( "outputImage:" + result.ToString() );

© 2025 Thermo Fisher Scientific Inc. All rights reserved.