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

# RadialBackgroundImage2d

Computes a radial background image from a grayscale image.
Access to parameter description
This algorithm:

- Computes the average radial profile: profile of intensities around concentric circles as a function of distance from a point in the image.
- Creates an image from the average radial profile.

The center of the radial profile can be the center of the image or a user-defined position.
If the a binary mask is set, the radial profile will be computed only with masked pixels.
To create the output image, the algorithm uses either an average radial profile or a polynomial estimation of the average radial profile.
Thus, all pixels of the output image located at a same distance from the defined center have the same intensity.
See also

- BackgroundImage2d
- ShadingCorrection
- RadialIntensityProfile2d
- RadialFunctionImage2d
- RadialFrequencyFilter2d

##
Function Syntax

This function returns outputImage.

    // Function prototype
    std::shared_ptr< iolink::ImageView >
    radialBackgroundImage2d( std::shared_ptr< iolink::ImageView > inputImage,
                             std::shared_ptr< iolink::ImageView > inputMaskImage,
                             RadialBackgroundImage2d::BackgroundModel backgroundModel,
                             RadialBackgroundImage2d::CenterMode centerMode,
                             const iolink::Vector2i32& centerPoint,
                             std::shared_ptr< iolink::ImageView > outputImage = nullptr );

This function returns outputImage.

    // Function prototype.
    radial_background_image_2d(input_image: idt.ImageType,
                               input_mask_image: idt.ImageType,
                               background_model: RadialBackgroundImage2d.BackgroundModel = RadialBackgroundImage2d.BackgroundModel.AVERAGE,
                               center_mode: RadialBackgroundImage2d.CenterMode = RadialBackgroundImage2d.CenterMode.IMAGE_CENTER,
                               center_point: Iterable[int] = [1, 1],
                               output_image: idt.ImageType = None) -> idt.ImageType

This function returns outputImage.

    // Function prototype.
    public static IOLink.ImageView
    RadialBackgroundImage2d( IOLink.ImageView inputImage,
                             IOLink.ImageView inputMaskImage,
                             RadialBackgroundImage2d.BackgroundModel backgroundModel = ImageDev.RadialBackgroundImage2d.BackgroundModel.AVERAGE,
                             RadialBackgroundImage2d.CenterMode centerMode = ImageDev.RadialBackgroundImage2d.CenterMode.IMAGE_CENTER,
                             int[] centerPoint = null,
                             IOLink.ImageView outputImage = null );

##
Class Syntax

    // Command constructor.
    RadialBackgroundImage2d();

    /// Gets the inputImage parameter.
    /// The input image.
    std::shared_ptr< iolink::ImageView > inputImage() const;
    /// Sets the inputImage parameter.
    /// The input image.
    void setInputImage( std::shared_ptr< iolink::ImageView > inputImage );

    /// Gets the inputMaskImage parameter.
    /// The binary mask image for the polynomial interpolation. If it equals null, the background is computed from all pixels of the input image. This image must have same dimensions as the input image.
    std::shared_ptr< iolink::ImageView > inputMaskImage() const;
    /// Sets the inputMaskImage parameter.
    /// The binary mask image for the polynomial interpolation. If it equals null, the background is computed from all pixels of the input image. This image must have same dimensions as the input image.
    void setInputMaskImage( std::shared_ptr< iolink::ImageView > inputMaskImage );

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

    /// Gets the centerMode parameter.
    /// The way to define the center of the radial profiles.
    RadialBackgroundImage2d::CenterMode centerMode() const;
    /// Sets the centerMode parameter.
    /// The way to define the center of the radial profiles.
    void setCenterMode( const RadialBackgroundImage2d::CenterMode& centerMode );

    /// Gets the centerPoint parameter.
    /// The X and Y coordinates used as center if the center mode parameter is set to OTHER. This parameter is ignored in IMAGE_CENTER mode.
    iolink::Vector2i32 centerPoint() const;
    /// Sets the centerPoint parameter.
    /// The X and Y coordinates used as center if the center mode parameter is set to OTHER. This parameter is ignored in IMAGE_CENTER mode.
    void setCenterPoint( const iolink::Vector2i32& centerPoint );

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

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

    # Property of the inputImage parameter.
    RadialBackgroundImage2d.input_image
    # Property of the inputMaskImage parameter.
    RadialBackgroundImage2d.input_mask_image
    # Property of the backgroundModel parameter.
    RadialBackgroundImage2d.background_model
    # Property of the centerMode parameter.
    RadialBackgroundImage2d.center_mode
    # Property of the centerPoint parameter.
    RadialBackgroundImage2d.center_point
    # Property of the outputImage parameter.
    RadialBackgroundImage2d.output_image

    // Method to launch the command.
    execute()

    // Command constructor.
    RadialBackgroundImage2d()

    // Property of the inputImage parameter.
    RadialBackgroundImage2d.inputImage
    // Property of the inputMaskImage parameter.
    RadialBackgroundImage2d.inputMaskImage
    // Property of the backgroundModel parameter.
    RadialBackgroundImage2d.backgroundModel
    // Property of the centerMode parameter.
    RadialBackgroundImage2d.centerMode
    // Property of the centerPoint parameter.
    RadialBackgroundImage2d.centerPoint
    // Property of the outputImage parameter.
    RadialBackgroundImage2d.outputImage

    // Method to launch the command.
    Execute()

## Parameters

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| inputImage | The input image. | Image | Grayscale or Multispectral | nullptr
| inputMaskImage | The binary mask image for the polynomial interpolation. If it equals null, the background is computed from all pixels of the input image. This image must have same dimensions as the input image. | Image | Binary | nullptr
| 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.
POLYNOMIAL_ORDER1 | The background is estimated by fitting a polynomial of degree one on the radial average of the masked image.
POLYNOMIAL_ORDER2 | The background is estimated by fitting a polynomial of degree two on the radial average of the masked image.
POLYNOMIAL_ORDER3 | The background is estimated by fitting a polynomial of degree three on the radial average of the masked image.
POLYNOMIAL_ORDER4 | The background is estimated by fitting a polynomial of degree four on the radial average of the masked image.
POLYNOMIAL_ORDER5 | The background is estimated by fitting a polynomial of degree five on the radial average of the masked image.
POLYNOMIAL_ORDER6 | The background is estimated by fitting a polynomial of degree six on the radial average of the masked image.
| Enumeration |  | AVERAGE
| centerMode | The way to define the center of the radial profiles.
IMAGE_CENTER | The center of the radial profiles is the center of the input image.
OTHER | The center of the radial profiles is user-defined.
| Enumeration |  | IMAGE_CENTER
| centerPoint | The X and Y coordinates used as center if the center mode parameter is set to OTHER. This parameter is ignored in IMAGE_CENTER mode. | Vector2i32 | Any value | {1, 1}
| outputImage | The output image. Its dimensions and type are forced to the same values as the input. | Image |  | nullptr

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| input_image | The input image. | image | Grayscale or Multispectral | None
| input_mask_image | The binary mask image for the polynomial interpolation. If it equals null, the background is computed from all pixels of the input image. This image must have same dimensions as the input image. | image | Binary | None
| 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.
POLYNOMIAL_ORDER1 | The background is estimated by fitting a polynomial of degree one on the radial average of the masked image.
POLYNOMIAL_ORDER2 | The background is estimated by fitting a polynomial of degree two on the radial average of the masked image.
POLYNOMIAL_ORDER3 | The background is estimated by fitting a polynomial of degree three on the radial average of the masked image.
POLYNOMIAL_ORDER4 | The background is estimated by fitting a polynomial of degree four on the radial average of the masked image.
POLYNOMIAL_ORDER5 | The background is estimated by fitting a polynomial of degree five on the radial average of the masked image.
POLYNOMIAL_ORDER6 | The background is estimated by fitting a polynomial of degree six on the radial average of the masked image.
| enumeration |  | AVERAGE
| center_mode | The way to define the center of the radial profiles.
IMAGE_CENTER | The center of the radial profiles is the center of the input image.
OTHER | The center of the radial profiles is user-defined.
| enumeration |  | IMAGE_CENTER
| center_point | The X and Y coordinates used as center if the center mode parameter is set to OTHER. This parameter is ignored in IMAGE_CENTER mode. | vector2i32 | Any value | [1, 1]
| output_image | The output image. Its dimensions and type are forced to the same values as the input. | image |  | None

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| inputImage | The input image. | Image | Grayscale or Multispectral | null
| inputMaskImage | The binary mask image for the polynomial interpolation. If it equals null, the background is computed from all pixels of the input image. This image must have same dimensions as the input image. | Image | Binary | null
| 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.
POLYNOMIAL_ORDER1 | The background is estimated by fitting a polynomial of degree one on the radial average of the masked image.
POLYNOMIAL_ORDER2 | The background is estimated by fitting a polynomial of degree two on the radial average of the masked image.
POLYNOMIAL_ORDER3 | The background is estimated by fitting a polynomial of degree three on the radial average of the masked image.
POLYNOMIAL_ORDER4 | The background is estimated by fitting a polynomial of degree four on the radial average of the masked image.
POLYNOMIAL_ORDER5 | The background is estimated by fitting a polynomial of degree five on the radial average of the masked image.
POLYNOMIAL_ORDER6 | The background is estimated by fitting a polynomial of degree six on the radial average of the masked image.
| Enumeration |  | AVERAGE
| centerMode | The way to define the center of the radial profiles.
IMAGE_CENTER | The center of the radial profiles is the center of the input image.
OTHER | The center of the radial profiles is user-defined.
| Enumeration |  | IMAGE_CENTER
| centerPoint | The X and Y coordinates used as center if the center mode parameter is set to OTHER. This parameter is ignored in IMAGE_CENTER mode. | Vector2i32 | Any value | {1, 1}
| outputImage | The output image. Its dimensions and type are forced to the same values as the input. | Image |  | null

## Object Examples

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

    RadialBackgroundImage2d radialBackgroundImage2dAlgo;
    radialBackgroundImage2dAlgo.setInputImage( polystyrene );
    radialBackgroundImage2dAlgo.setInputMaskImage( polystyrene_sep );
    radialBackgroundImage2dAlgo.setBackgroundModel( RadialBackgroundImage2d::BackgroundModel::AVERAGE );
    radialBackgroundImage2dAlgo.setCenterMode( RadialBackgroundImage2d::CenterMode::IMAGE_CENTER );
    radialBackgroundImage2dAlgo.setCenterPoint( {1, 1} );
    radialBackgroundImage2dAlgo.execute();

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

    polystyrene = ioformat.read_image(imagedev_data.get_image_path("polystyrene.tif"))
    polystyrene_sep = imagedev.read_vip_image(imagedev_data.get_image_path("polystyrene_sep.vip"))

    radial_background_image_2d_algo = imagedev.RadialBackgroundImage2d()
    radial_background_image_2d_algo.input_image = polystyrene
    radial_background_image_2d_algo.input_mask_image = polystyrene_sep
    radial_background_image_2d_algo.background_model = imagedev.RadialBackgroundImage2d.AVERAGE
    radial_background_image_2d_algo.center_mode = imagedev.RadialBackgroundImage2d.IMAGE_CENTER
    radial_background_image_2d_algo.center_point = [1, 1]
    radial_background_image_2d_algo.execute()

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

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

    RadialBackgroundImage2d radialBackgroundImage2dAlgo = new RadialBackgroundImage2d
    {
        inputImage = polystyrene,
        inputMaskImage = polystyrene_sep,
        backgroundModel = RadialBackgroundImage2d.BackgroundModel.AVERAGE,
        centerMode = RadialBackgroundImage2d.CenterMode.IMAGE_CENTER,
        centerPoint = new int[]{1, 1}
    };
    radialBackgroundImage2dAlgo.Execute();

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

## Function Examples

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

    auto result = radialBackgroundImage2d( polystyrene, polystyrene_sep, RadialBackgroundImage2d::BackgroundModel::AVERAGE, RadialBackgroundImage2d::CenterMode::IMAGE_CENTER, {1, 1} );

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

    polystyrene = ioformat.read_image(imagedev_data.get_image_path("polystyrene.tif"))
    polystyrene_sep = imagedev.read_vip_image(imagedev_data.get_image_path("polystyrene_sep.vip"))

    result = imagedev.radial_background_image_2d(polystyrene, polystyrene_sep, imagedev.RadialBackgroundImage2d.AVERAGE, imagedev.RadialBackgroundImage2d.IMAGE_CENTER, [1, 1])

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

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

    IOLink.ImageView result = Processing.RadialBackgroundImage2d( polystyrene, polystyrene_sep, RadialBackgroundImage2d.BackgroundModel.AVERAGE, RadialBackgroundImage2d.CenterMode.IMAGE_CENTER, new int[]{1, 1} );

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

© 2025 Thermo Fisher Scientific Inc. All rights reserved.