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

# RingArtifactRemoval3d

Removes ring artifacts from a Computed Tomography volume.
Access to parameter description
This algorithm removes rings from CT images by comparing the means of voxel values in each ring and the mean value of the whole sample. Adjustments are then made to all voxel values.
First, an average cylindrical intensity profile $P$ is computed around the Z axis.
Then, this profile is subtracted from each intensity of the input image $I$. To preserve the initial data range, the mean value of the processed area is added.
The corrected value $O$ of a voxel $v$ of the input image $I$ is given by: $$ O(v) = I(v) - P(r) + \mu_e$$ where $P$ is the cylindrical profile intensity, $r$ is the distance from the ring center to $v$, and $\mu_e$ is the sample mean.
To focus the correction on phases of interest, two thresholds are proposed to

- Retain only values inside the threshold range for the cylindrical profile extraction.
- Retain only values inside the threshold range for the sample mean value computation.

The rings to remove must be in the XY plane of the volume. The CT volume is supposed to have been acquired along the Z rotation axis. If not, the volume must be rotated beforehand in order to align the rotation axis with the volume Z axis.

(a) | (b)

Figure 1. (a) Original CT image with ring artifacts. (b) Corrected image with ring artifact removal filter
See also

- CylindricalIntensityProfile3d
- RadialFunctionImage3d
- ShadingCorrection
- BeamHardeningCorrection3d

##
Function Syntax

This function returns outputImage.

    // Function prototype
    std::shared_ptr< iolink::ImageView >
    ringArtifactRemoval3d( std::shared_ptr< iolink::ImageView > inputImage,
                           RingArtifactRemoval3d::CenterMode centerMode,
                           const iolink::Vector2u32& center,
                           const iolink::Vector2d& thresholdRange,
                           const iolink::Vector2u32& radiusRange,
                           bool ignoreThresholdsForRings,
                           double coverPercentage,
                           bool singleRingMode,
                           const iolink::Vector2u32& singleRingRadiusRange,
                           const iolink::Vector2u32& singleRingSliceRange,
                           std::shared_ptr< iolink::ImageView > outputImage = nullptr );

This function returns outputImage.

    // Function prototype.
    ring_artifact_removal_3d(input_image: idt.ImageType,
                             center_mode: RingArtifactRemoval3d.CenterMode = RingArtifactRemoval3d.CenterMode.IMAGE_CENTER,
                             center: Iterable[int] = [0, 0],
                             threshold_range: Union[Iterable[int], Iterable[float]] = [0, 65535],
                             radius_range: Iterable[int] = [0, 255],
                             ignore_thresholds_for_rings: bool = False,
                             cover_percentage: float = 0,
                             single_ring_mode: bool = False,
                             single_ring_radius_range: Iterable[int] = [0, 255],
                             single_ring_slice_range: Iterable[int] = [0, 255],
                             output_image: idt.ImageType = None) -> idt.ImageType

This function returns outputImage.

    // Function prototype.
    public static IOLink.ImageView
    RingArtifactRemoval3d( IOLink.ImageView inputImage,
                           RingArtifactRemoval3d.CenterMode centerMode = ImageDev.RingArtifactRemoval3d.CenterMode.IMAGE_CENTER,
                           uint[] center = null,
                           double[] thresholdRange = null,
                           uint[] radiusRange = null,
                           bool ignoreThresholdsForRings = false,
                           double coverPercentage = 0,
                           bool singleRingMode = false,
                           uint[] singleRingRadiusRange = null,
                           uint[] singleRingSliceRange = null,
                           IOLink.ImageView outputImage = null );

##
Class Syntax

    // Command constructor.
    RingArtifactRemoval3d();

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

    /// Gets the centerMode parameter.
    /// The way to define the center of the cylindrical sample.
    RingArtifactRemoval3d::CenterMode centerMode() const;
    /// Sets the centerMode parameter.
    /// The way to define the center of the cylindrical sample.
    void setCenterMode( const RingArtifactRemoval3d::CenterMode& centerMode );

    /// Gets the center parameter.
    /// The X and Y coordinates center, defined in voxel units, for each volume slice of the concentric rings to remove. This parameter is ignored if the center mode is set to IMAGE_CENTER.
    iolink::Vector2u32 center() const;
    /// Sets the center parameter.
    /// The X and Y coordinates center, defined in voxel units, for each volume slice of the concentric rings to remove. This parameter is ignored if the center mode is set to IMAGE_CENTER.
    void setCenter( const iolink::Vector2u32& center );

    /// Gets the thresholdRange parameter.
    /// Only voxel intensities inside this range are considered to compute the mean values used by the correction. Other values are processed anyway by the algorithm.
    iolink::Vector2d thresholdRange() const;
    /// Sets the thresholdRange parameter.
    /// Only voxel intensities inside this range are considered to compute the mean values used by the correction. Other values are processed anyway by the algorithm.
    void setThresholdRange( const iolink::Vector2d& thresholdRange );

    /// Gets the radiusRange parameter.
    /// The minimum and maximum radius, in voxel units, defining a hollow cylinder along the Z axis, which is used to compute the whole sample mean value.
    iolink::Vector2u32 radiusRange() const;
    /// Sets the radiusRange parameter.
    /// The minimum and maximum radius, in voxel units, defining a hollow cylinder along the Z axis, which is used to compute the whole sample mean value.
    void setRadiusRange( const iolink::Vector2u32& radiusRange );

    /// Gets the ignoreThresholdsForRings parameter.
    /// Enable or disable the coverPercentage parameter.
    bool ignoreThresholdsForRings() const;
    /// Sets the ignoreThresholdsForRings parameter.
    /// Enable or disable the coverPercentage parameter.
    void setIgnoreThresholdsForRings( const bool& ignoreThresholdsForRings );

    /// Gets the coverPercentage parameter.
    /// If the percentage of voxels between the thresholds in any one ring is less than this value, then all the voxels in the ring are used in the calculation. This parameter is ignored if ignoreThresholdsForRings is disabled.
    double coverPercentage() const;
    /// Sets the coverPercentage parameter.
    /// If the percentage of voxels between the thresholds in any one ring is less than this value, then all the voxels in the ring are used in the calculation. This parameter is ignored if ignoreThresholdsForRings is disabled.
    void setCoverPercentage( const double& coverPercentage );

    /// Gets the singleRingMode parameter.
    /// Option to remove only one user-defined ring.
    bool singleRingMode() const;
    /// Sets the singleRingMode parameter.
    /// Option to remove only one user-defined ring.
    void setSingleRingMode( const bool& singleRingMode );

    /// Gets the singleRingRadiusRange parameter.
    /// The minimum and maximum radius, in voxel units, of the ring to remove. This parameter is ignored if the single ring mode is disabled.
    iolink::Vector2u32 singleRingRadiusRange() const;
    /// Sets the singleRingRadiusRange parameter.
    /// The minimum and maximum radius, in voxel units, of the ring to remove. This parameter is ignored if the single ring mode is disabled.
    void setSingleRingRadiusRange( const iolink::Vector2u32& singleRingRadiusRange );

    /// Gets the singleRingSliceRange parameter.
    /// The first and last slice index where the ring to remove is visible. This parameter is ignored if the single ring mode is disabled.
    iolink::Vector2u32 singleRingSliceRange() const;
    /// Sets the singleRingSliceRange parameter.
    /// The first and last slice index where the ring to remove is visible. This parameter is ignored if the single ring mode is disabled.
    void setSingleRingSliceRange( const iolink::Vector2u32& singleRingSliceRange );

    /// Gets the outputImage parameter.
    /// The corrected image.
    std::shared_ptr< iolink::ImageView > outputImage() const;
    /// Sets the outputImage parameter.
    /// The corrected image.
    void setOutputImage( std::shared_ptr< iolink::ImageView > outputImage );

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

    # Property of the inputImage parameter.
    RingArtifactRemoval3d.input_image
    # Property of the centerMode parameter.
    RingArtifactRemoval3d.center_mode
    # Property of the center parameter.
    RingArtifactRemoval3d.center
    # Property of the thresholdRange parameter.
    RingArtifactRemoval3d.threshold_range
    # Property of the radiusRange parameter.
    RingArtifactRemoval3d.radius_range
    # Property of the ignoreThresholdsForRings parameter.
    RingArtifactRemoval3d.ignore_thresholds_for_rings
    # Property of the coverPercentage parameter.
    RingArtifactRemoval3d.cover_percentage
    # Property of the singleRingMode parameter.
    RingArtifactRemoval3d.single_ring_mode
    # Property of the singleRingRadiusRange parameter.
    RingArtifactRemoval3d.single_ring_radius_range
    # Property of the singleRingSliceRange parameter.
    RingArtifactRemoval3d.single_ring_slice_range
    # Property of the outputImage parameter.
    RingArtifactRemoval3d.output_image

    // Method to launch the command.
    execute()

    // Command constructor.
    RingArtifactRemoval3d()

    // Property of the inputImage parameter.
    RingArtifactRemoval3d.inputImage
    // Property of the centerMode parameter.
    RingArtifactRemoval3d.centerMode
    // Property of the center parameter.
    RingArtifactRemoval3d.center
    // Property of the thresholdRange parameter.
    RingArtifactRemoval3d.thresholdRange
    // Property of the radiusRange parameter.
    RingArtifactRemoval3d.radiusRange
    // Property of the ignoreThresholdsForRings parameter.
    RingArtifactRemoval3d.ignoreThresholdsForRings
    // Property of the coverPercentage parameter.
    RingArtifactRemoval3d.coverPercentage
    // Property of the singleRingMode parameter.
    RingArtifactRemoval3d.singleRingMode
    // Property of the singleRingRadiusRange parameter.
    RingArtifactRemoval3d.singleRingRadiusRange
    // Property of the singleRingSliceRange parameter.
    RingArtifactRemoval3d.singleRingSliceRange
    // Property of the outputImage parameter.
    RingArtifactRemoval3d.outputImage

    // Method to launch the command.
    Execute()

## Parameters

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| inputImage | The 3D input image to correct. | Image | Grayscale or Multispectral | nullptr
| centerMode | The way to define the center of the cylindrical sample.
IMAGE_CENTER | The center of the rings is the center of the input image.
OTHER | The center of the rings is user-defined.
| Enumeration |  | IMAGE_CENTER
| center | The X and Y coordinates center, defined in voxel units, for each volume slice of the concentric rings to remove. This parameter is ignored if the center mode is set to IMAGE_CENTER. | Vector2u32 | Any value | {0, 0}
| thresholdRange | Only voxel intensities inside this range are considered to compute the mean values used by the correction. Other values are processed anyway by the algorithm. | Vector2d | Any value | {0.f, 65535.f}
| radiusRange | The minimum and maximum radius, in voxel units, defining a hollow cylinder along the Z axis, which is used to compute the whole sample mean value. | Vector2u32 | Any value | {0, 255}
| ignoreThresholdsForRings | Enable or disable the coverPercentage parameter. | Bool |  | false
| coverPercentage | If the percentage of voxels between the thresholds in any one ring is less than this value, then all the voxels in the ring are used in the calculation. This parameter is ignored if ignoreThresholdsForRings is disabled. | Float64 | [0, 100] | 0
| singleRingMode | Option to remove only one user-defined ring. | Bool |  | false
| singleRingRadiusRange | The minimum and maximum radius, in voxel units, of the ring to remove. This parameter is ignored if the single ring mode is disabled. | Vector2u32 | Any value | {0, 255}
| singleRingSliceRange | The first and last slice index where the ring to remove is visible. This parameter is ignored if the single ring mode is disabled. | Vector2u32 | Any value | {0, 255}
| outputImage | The corrected image. | Image |  | nullptr

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| input_image | The 3D input image to correct. | image | Grayscale or Multispectral | None
| center_mode | The way to define the center of the cylindrical sample.
IMAGE_CENTER | The center of the rings is the center of the input image.
OTHER | The center of the rings is user-defined.
| enumeration |  | IMAGE_CENTER
| center | The X and Y coordinates center, defined in voxel units, for each volume slice of the concentric rings to remove. This parameter is ignored if the center mode is set to IMAGE_CENTER. | vector2u32 | Any value | [0, 0]
| threshold_range | Only voxel intensities inside this range are considered to compute the mean values used by the correction. Other values are processed anyway by the algorithm. | vector2d | Any value | [0, 65535]
| radius_range | The minimum and maximum radius, in voxel units, defining a hollow cylinder along the Z axis, which is used to compute the whole sample mean value. | vector2u32 | Any value | [0, 255]
| ignore_thresholds_for_rings | Enable or disable the coverPercentage parameter. | bool |  | False
| cover_percentage | If the percentage of voxels between the thresholds in any one ring is less than this value, then all the voxels in the ring are used in the calculation. This parameter is ignored if ignoreThresholdsForRings is disabled. | float64 | [0, 100] | 0
| single_ring_mode | Option to remove only one user-defined ring. | bool |  | False
| single_ring_radius_range | The minimum and maximum radius, in voxel units, of the ring to remove. This parameter is ignored if the single ring mode is disabled. | vector2u32 | Any value | [0, 255]
| single_ring_slice_range | The first and last slice index where the ring to remove is visible. This parameter is ignored if the single ring mode is disabled. | vector2u32 | Any value | [0, 255]
| output_image | The corrected image. | image |  | None

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| inputImage | The 3D input image to correct. | Image | Grayscale or Multispectral | null
| centerMode | The way to define the center of the cylindrical sample.
IMAGE_CENTER | The center of the rings is the center of the input image.
OTHER | The center of the rings is user-defined.
| Enumeration |  | IMAGE_CENTER
| center | The X and Y coordinates center, defined in voxel units, for each volume slice of the concentric rings to remove. This parameter is ignored if the center mode is set to IMAGE_CENTER. | Vector2u32 | Any value | {0, 0}
| thresholdRange | Only voxel intensities inside this range are considered to compute the mean values used by the correction. Other values are processed anyway by the algorithm. | Vector2d | Any value | {0f, 65535f}
| radiusRange | The minimum and maximum radius, in voxel units, defining a hollow cylinder along the Z axis, which is used to compute the whole sample mean value. | Vector2u32 | Any value | {0, 255}
| ignoreThresholdsForRings | Enable or disable the coverPercentage parameter. | Bool |  | false
| coverPercentage | If the percentage of voxels between the thresholds in any one ring is less than this value, then all the voxels in the ring are used in the calculation. This parameter is ignored if ignoreThresholdsForRings is disabled. | Float64 | [0, 100] | 0
| singleRingMode | Option to remove only one user-defined ring. | Bool |  | false
| singleRingRadiusRange | The minimum and maximum radius, in voxel units, of the ring to remove. This parameter is ignored if the single ring mode is disabled. | Vector2u32 | Any value | {0, 255}
| singleRingSliceRange | The first and last slice index where the ring to remove is visible. This parameter is ignored if the single ring mode is disabled. | Vector2u32 | Any value | {0, 255}
| outputImage | The corrected image. | Image |  | null

## Object Examples

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

    RingArtifactRemoval3d ringArtifactRemoval3dAlgo;
    ringArtifactRemoval3dAlgo.setInputImage( foam );
    ringArtifactRemoval3dAlgo.setCenterMode( RingArtifactRemoval3d::CenterMode::OTHER );
    ringArtifactRemoval3dAlgo.setCenter( {40, 50} );
    ringArtifactRemoval3dAlgo.setThresholdRange( {0, 255} );
    ringArtifactRemoval3dAlgo.setRadiusRange( {0, 80} );
    ringArtifactRemoval3dAlgo.setIgnoreThresholdsForRings( true );
    ringArtifactRemoval3dAlgo.setCoverPercentage( 70.0 );
    ringArtifactRemoval3dAlgo.setSingleRingMode( true );
    ringArtifactRemoval3dAlgo.setSingleRingRadiusRange( {30, 70} );
    ringArtifactRemoval3dAlgo.setSingleRingSliceRange( {1, 8} );
    ringArtifactRemoval3dAlgo.execute();

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

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

    ring_artifact_removal_3d_algo = imagedev.RingArtifactRemoval3d()
    ring_artifact_removal_3d_algo.input_image = foam
    ring_artifact_removal_3d_algo.center_mode = imagedev.RingArtifactRemoval3d.OTHER
    ring_artifact_removal_3d_algo.center = [40, 50]
    ring_artifact_removal_3d_algo.threshold_range = [0, 255]
    ring_artifact_removal_3d_algo.radius_range = [0, 80]
    ring_artifact_removal_3d_algo.ignore_thresholds_for_rings = True
    ring_artifact_removal_3d_algo.cover_percentage = 70.0
    ring_artifact_removal_3d_algo.single_ring_mode = True
    ring_artifact_removal_3d_algo.single_ring_radius_range = [30, 70]
    ring_artifact_removal_3d_algo.single_ring_slice_range = [1, 8]
    ring_artifact_removal_3d_algo.execute()

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

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

    RingArtifactRemoval3d ringArtifactRemoval3dAlgo = new RingArtifactRemoval3d
    {
        inputImage = foam,
        centerMode = RingArtifactRemoval3d.CenterMode.OTHER,
        center = new uint[]{40, 50},
        thresholdRange = new double[]{0, 255},
        radiusRange = new uint[]{0, 80},
        ignoreThresholdsForRings = true,
        coverPercentage = 70.0,
        singleRingMode = true,
        singleRingRadiusRange = new uint[]{30, 70},
        singleRingSliceRange = new uint[]{1, 8}
    };
    ringArtifactRemoval3dAlgo.Execute();

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

## Function Examples

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

    auto result = ringArtifactRemoval3d( foam, RingArtifactRemoval3d::CenterMode::OTHER, {40, 50}, {0, 255}, {0, 80}, true, 70.0, true, {30, 70}, {1, 8} );

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

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

    result = imagedev.ring_artifact_removal_3d(foam, imagedev.RingArtifactRemoval3d.OTHER, [40, 50], [0, 255], [0, 80], True, 70.0, True, [30, 70], [1, 8])

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

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

    IOLink.ImageView result = Processing.RingArtifactRemoval3d( foam, RingArtifactRemoval3d.CenterMode.OTHER, new uint[]{40, 50}, new double[]{0, 255}, new uint[]{0, 80}, true, 70.0, true, new uint[]{30, 70}, new uint[]{1, 8} );

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

© 2025 Thermo Fisher Scientific Inc. All rights reserved.