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

# BeamHardeningCorrection3d

Performs a beam hardening correction dedicated to cylindrical objects of a Computed Tomography volume.
Access to parameter description
This algorithm performs a simple correction for beam hardening that mainly works for homogeneous cylindrical objects. Beam hardening manifests by a radial increase of the attenuation coefficient when the X-ray beam crosses a material interface presenting a high density difference. On cylindrical material samples, like geological cores, it is materialized by an intensity peak on the cylinder border.
First, an average cylindrical intensity profile $P$ is computed around a user-defined rotation axis. Theoretically, this axis must correspond to the CT rotation axis, but it does not necessarily need to be aligned with one of the input image axis.
This profile can be smoothed with a gaussian filter, and is then normalized by the mean intensity value of the inner part of the cylindrical object.
Finally, all intensities are divided by this smoothed profile to perform a radial averaging.
The corrected value $O$ of a voxel $v$ of the input image $I$ is given by: $$ O(v) = \frac {I(v)}{P(r)}\times\mu_c$$ where $P$ is the cylindrical profile intensity, $r$ is the distance from the correction center to $v$ and $\mu_c$ the normalization factor (inner part mean intensity).
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.
- Apply the correction only on voxel intensities belonging to this range.

This algorithm assumes that the inner part is representative of the whole object to compute the normalization factor, and therefore this correction should be applied only to fairly homogeneous samples.

(a) | (b)

Figure 1. (a) Original CT image with beam hardening and line profile from image
center (left of the curve) to exterior (right). (b) Corrected image with ring artifact removal filter.
See also

- CylindricalIntensityProfile3d
- RadialFunctionImage3d
- ShadingCorrection
- RingArtifactRemoval3d

##
Function Syntax

This function returns outputImage.

    // Function prototype
    std::shared_ptr< iolink::ImageView >
    beamHardeningCorrection3d( std::shared_ptr< iolink::ImageView > inputImage,
                               BeamHardeningCorrection3d::AxisDirection axisDirection,
                               BeamHardeningCorrection3d::AxisOrientation axisOrientation,
                               BeamHardeningCorrection3d::CenterMode centerMode,
                               const iolink::Vector3u32& mainCenter,
                               const iolink::Vector3u32& secondaryCenter,
                               double radiusPercentage,
                               const iolink::Vector2u32& radiusRange,
                               const iolink::Vector2d& thresholdRange,
                               double standardDeviation,
                               BeamHardeningCorrection3d::PaddingPolicy paddingPolicy,
                               double paddingValue,
                               std::shared_ptr< iolink::ImageView > outputImage = nullptr );

This function returns outputImage.

    // Function prototype.
    beam_hardening_correction_3d(input_image: idt.ImageType,
                                 axis_direction: BeamHardeningCorrection3d.AxisDirection = BeamHardeningCorrection3d.AxisDirection.Z_AXIS,
                                 axis_orientation: BeamHardeningCorrection3d.AxisOrientation = BeamHardeningCorrection3d.AxisOrientation.STRAIGHT,
                                 center_mode: BeamHardeningCorrection3d.CenterMode = BeamHardeningCorrection3d.CenterMode.IMAGE_CENTER,
                                 main_center: Iterable[int] = [0, 0, 0],
                                 secondary_center: Iterable[int] = [0, 0, 0],
                                 radius_percentage: float = 25,
                                 radius_range: Iterable[int] = [0, 0],
                                 threshold_range: Union[Iterable[int], Iterable[float]] = [0, 65535],
                                 standard_deviation: float = 0,
                                 padding_policy: BeamHardeningCorrection3d.PaddingPolicy = BeamHardeningCorrection3d.PaddingPolicy.INPUT_VALUE,
                                 padding_value: float = 0,
                                 output_image: idt.ImageType = None) -> idt.ImageType

This function returns outputImage.

    // Function prototype.
    public static IOLink.ImageView
    BeamHardeningCorrection3d( IOLink.ImageView inputImage,
                               BeamHardeningCorrection3d.AxisDirection axisDirection = ImageDev.BeamHardeningCorrection3d.AxisDirection.Z_AXIS,
                               BeamHardeningCorrection3d.AxisOrientation axisOrientation = ImageDev.BeamHardeningCorrection3d.AxisOrientation.STRAIGHT,
                               BeamHardeningCorrection3d.CenterMode centerMode = ImageDev.BeamHardeningCorrection3d.CenterMode.IMAGE_CENTER,
                               uint[] mainCenter = null,
                               uint[] secondaryCenter = null,
                               double radiusPercentage = 25,
                               uint[] radiusRange = null,
                               double[] thresholdRange = null,
                               double standardDeviation = 0,
                               BeamHardeningCorrection3d.PaddingPolicy paddingPolicy = ImageDev.BeamHardeningCorrection3d.PaddingPolicy.INPUT_VALUE,
                               double paddingValue = 0,
                               IOLink.ImageView outputImage = null );

##
Class Syntax

    // Command constructor.
    BeamHardeningCorrection3d();

    /// 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 axisDirection parameter.
    /// The axis along which the correction has to be carried out.
    BeamHardeningCorrection3d::AxisDirection axisDirection() const;
    /// Sets the axisDirection parameter.
    /// The axis along which the correction has to be carried out.
    void setAxisDirection( const BeamHardeningCorrection3d::AxisDirection& axisDirection );

    /// Gets the axisOrientation parameter.
    /// Set the cylinder axis to be used during correction: straight or sheared. This option is ignored if the axis direction is not Z_AXIS (forced to straight).
    BeamHardeningCorrection3d::AxisOrientation axisOrientation() const;
    /// Sets the axisOrientation parameter.
    /// Set the cylinder axis to be used during correction: straight or sheared. This option is ignored if the axis direction is not Z_AXIS (forced to straight).
    void setAxisOrientation( const BeamHardeningCorrection3d::AxisOrientation& axisOrientation );

    /// Gets the centerMode parameter.
    /// The way to define the main center of the cylindrical sample. It is ignored if the axis orientation is set to SHEARED (forced to OTHER).
    BeamHardeningCorrection3d::CenterMode centerMode() const;
    /// Sets the centerMode parameter.
    /// The way to define the main center of the cylindrical sample. It is ignored if the axis orientation is set to SHEARED (forced to OTHER).
    void setCenterMode( const BeamHardeningCorrection3d::CenterMode& centerMode );

    /// Gets the mainCenter parameter.
    /// The midpoint of the sample in voxel coordinates.
    iolink::Vector3u32 mainCenter() const;
    /// Sets the mainCenter parameter.
    /// The midpoint of the sample in voxel coordinates.
    void setMainCenter( const iolink::Vector3u32& mainCenter );

    /// Gets the secondaryCenter parameter.
    /// The midpoint of the last plane of the sample in voxel coordinates (ignored with STRAIGHT axis setting).
    iolink::Vector3u32 secondaryCenter() const;
    /// Sets the secondaryCenter parameter.
    /// The midpoint of the last plane of the sample in voxel coordinates (ignored with STRAIGHT axis setting).
    void setSecondaryCenter( const iolink::Vector3u32& secondaryCenter );

    /// Gets the radiusPercentage parameter.
    /// The portion, in percent, of the maximum radius that is effectively considered for computing the normalization factor. The average value of the area inside this percentage of the maximum radius is used to normalize the data.
    double radiusPercentage() const;
    /// Sets the radiusPercentage parameter.
    /// The portion, in percent, of the maximum radius that is effectively considered for computing the normalization factor. The average value of the area inside this percentage of the maximum radius is used to normalize the data.
    void setRadiusPercentage( const double& radiusPercentage );

    /// Gets the radiusRange parameter.
    /// The minimum and maximum radius, in voxel units, between which the correction is done. If the maximum radius is equal to 0, the largest possible radius is used.
    iolink::Vector2u32 radiusRange() const;
    /// Sets the radiusRange parameter.
    /// The minimum and maximum radius, in voxel units, between which the correction is done. If the maximum radius is equal to 0, the largest possible radius is used.
    void setRadiusRange( const iolink::Vector2u32& radiusRange );

    /// Gets the thresholdRange parameter.
    /// Values out of this range are not included in the statistics to calculate the correction.
    iolink::Vector2d thresholdRange() const;
    /// Sets the thresholdRange parameter.
    /// Values out of this range are not included in the statistics to calculate the correction.
    void setThresholdRange( const iolink::Vector2d& thresholdRange );

    /// Gets the standardDeviation parameter.
    /// The standard deviation, in voxel units, of the gaussian filtering used to smooth the histogram before performing the correction. No smoothing is applied if this value is set to 0.
    double standardDeviation() const;
    /// Sets the standardDeviation parameter.
    /// The standard deviation, in voxel units, of the gaussian filtering used to smooth the histogram before performing the correction. No smoothing is applied if this value is set to 0.
    void setStandardDeviation( const double& standardDeviation );

    /// Gets the paddingPolicy parameter.
    /// The way to manage uncomputed values (that is, voxels that are out of the maximum radius).
    BeamHardeningCorrection3d::PaddingPolicy paddingPolicy() const;
    /// Sets the paddingPolicy parameter.
    /// The way to manage uncomputed values (that is, voxels that are out of the maximum radius).
    void setPaddingPolicy( const BeamHardeningCorrection3d::PaddingPolicy& paddingPolicy );

    /// Gets the paddingValue parameter.
    /// The intensity value used to fill uncomputed voxels (that is, voxels that are out of the maximum radius). It is used only with the fixed value padding policy.
    double paddingValue() const;
    /// Sets the paddingValue parameter.
    /// The intensity value used to fill uncomputed voxels (that is, voxels that are out of the maximum radius). It is used only with the fixed value padding policy.
    void setPaddingValue( const double& paddingValue );

    /// Gets the outputImage parameter.
    /// The corrected 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 corrected 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.
    BeamHardeningCorrection3d.input_image
    # Property of the axisDirection parameter.
    BeamHardeningCorrection3d.axis_direction
    # Property of the axisOrientation parameter.
    BeamHardeningCorrection3d.axis_orientation
    # Property of the centerMode parameter.
    BeamHardeningCorrection3d.center_mode
    # Property of the mainCenter parameter.
    BeamHardeningCorrection3d.main_center
    # Property of the secondaryCenter parameter.
    BeamHardeningCorrection3d.secondary_center
    # Property of the radiusPercentage parameter.
    BeamHardeningCorrection3d.radius_percentage
    # Property of the radiusRange parameter.
    BeamHardeningCorrection3d.radius_range
    # Property of the thresholdRange parameter.
    BeamHardeningCorrection3d.threshold_range
    # Property of the standardDeviation parameter.
    BeamHardeningCorrection3d.standard_deviation
    # Property of the paddingPolicy parameter.
    BeamHardeningCorrection3d.padding_policy
    # Property of the paddingValue parameter.
    BeamHardeningCorrection3d.padding_value
    # Property of the outputImage parameter.
    BeamHardeningCorrection3d.output_image

    // Method to launch the command.
    execute()

    // Command constructor.
    BeamHardeningCorrection3d()

    // Property of the inputImage parameter.
    BeamHardeningCorrection3d.inputImage
    // Property of the axisDirection parameter.
    BeamHardeningCorrection3d.axisDirection
    // Property of the axisOrientation parameter.
    BeamHardeningCorrection3d.axisOrientation
    // Property of the centerMode parameter.
    BeamHardeningCorrection3d.centerMode
    // Property of the mainCenter parameter.
    BeamHardeningCorrection3d.mainCenter
    // Property of the secondaryCenter parameter.
    BeamHardeningCorrection3d.secondaryCenter
    // Property of the radiusPercentage parameter.
    BeamHardeningCorrection3d.radiusPercentage
    // Property of the radiusRange parameter.
    BeamHardeningCorrection3d.radiusRange
    // Property of the thresholdRange parameter.
    BeamHardeningCorrection3d.thresholdRange
    // Property of the standardDeviation parameter.
    BeamHardeningCorrection3d.standardDeviation
    // Property of the paddingPolicy parameter.
    BeamHardeningCorrection3d.paddingPolicy
    // Property of the paddingValue parameter.
    BeamHardeningCorrection3d.paddingValue
    // Property of the outputImage parameter.
    BeamHardeningCorrection3d.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
| axisDirection | The axis along which the correction has to be carried out.
X_AXIS | The correction is applied on YZ slices.
Y_AXIS | The correction is applied on XZ slices.
Z_AXIS | The correction is applied on XY slices.
| Enumeration |  | Z_AXIS
| axisOrientation | Set the cylinder axis to be used during correction: straight or sheared. This option is ignored if the axis direction is not Z_AXIS (forced to straight).
STRAIGHT | A straight axis assumes that the sample is a vertical cylinder.
SHEARED | A sheared axis considers a sheared cylinder determined by the midpoints at the top and bottom of the sample. This option is only available when the rotation axis is Z_AXIS at this stage.
| Enumeration |  | STRAIGHT
| centerMode | The way to define the main center of the cylindrical sample. It is ignored if the axis orientation is set to SHEARED (forced to OTHER).
IMAGE_CENTER | The correction center is the center of the input image.
OTHER | The correction center is user-defined.
| Enumeration |  | IMAGE_CENTER
| mainCenter | The midpoint of the sample in voxel coordinates. With straight axis setting, this point is considered as the center of the sample. With sheared axis setting, it is considered as the center of the first plane of the sample. It is ignored if the axis orientation is set to STRAIGHT and center mode to IMAGE_CENTER. | Vector3u32 | Any value | {0, 0, 0}
| secondaryCenter | The midpoint of the last plane of the sample in voxel coordinates (ignored with STRAIGHT axis setting). It is only used if axis direction is Z_AXIS and the orientation is set to SHEARED. | Vector3u32 | Any value | {0, 0, 0}
| radiusPercentage | The portion, in percent, of the maximum radius that is effectively considered for computing the normalization factor. The average value of the area inside this percentage of the maximum radius is used to normalize the data. | Float64 | [0, 100] | 25
| radiusRange | The minimum and maximum radius, in voxel units, between which the correction is done. If the maximum radius is equal to 0, the largest possible radius is used. | Vector2u32 | Any value | {0, 0}
| thresholdRange | Values out of this range are not included in the statistics to calculate the correction. | Vector2d | Any value | {0.f, 65535.f}
| standardDeviation | The standard deviation, in voxel units, of the gaussian filtering used to smooth the histogram before performing the correction. No smoothing is applied if this value is set to 0. | Float64 | >=0 | 0
| paddingPolicy | The way to manage uncomputed values (that is, voxels that are out of the maximum radius).
INPUT_VALUE | The input intensity value is transferred.
FIXED_VALUE | The uncomputed area is filled with a padding value.
| Enumeration |  | INPUT_VALUE
| paddingValue | The intensity value used to fill uncomputed voxels (that is, voxels that are out of the maximum radius). It is used only with the fixed value padding policy. | Float64 | Any value | 0
| outputImage | The corrected 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 3D input image to correct. | image | Grayscale or Multispectral | None
| axis_direction | The axis along which the correction has to be carried out.
X_AXIS | The correction is applied on YZ slices.
Y_AXIS | The correction is applied on XZ slices.
Z_AXIS | The correction is applied on XY slices.
| enumeration |  | Z_AXIS
| axis_orientation | Set the cylinder axis to be used during correction: straight or sheared. This option is ignored if the axis direction is not Z_AXIS (forced to straight).
STRAIGHT | A straight axis assumes that the sample is a vertical cylinder.
SHEARED | A sheared axis considers a sheared cylinder determined by the midpoints at the top and bottom of the sample. This option is only available when the rotation axis is Z_AXIS at this stage.
| enumeration |  | STRAIGHT
| center_mode | The way to define the main center of the cylindrical sample. It is ignored if the axis orientation is set to SHEARED (forced to OTHER).
IMAGE_CENTER | The correction center is the center of the input image.
OTHER | The correction center is user-defined.
| enumeration |  | IMAGE_CENTER
| main_center | The midpoint of the sample in voxel coordinates. With straight axis setting, this point is considered as the center of the sample. With sheared axis setting, it is considered as the center of the first plane of the sample. It is ignored if the axis orientation is set to STRAIGHT and center mode to IMAGE_CENTER. | vector3u32 | Any value | [0, 0, 0]
| secondary_center | The midpoint of the last plane of the sample in voxel coordinates (ignored with STRAIGHT axis setting). It is only used if axis direction is Z_AXIS and the orientation is set to SHEARED. | vector3u32 | Any value | [0, 0, 0]
| radius_percentage | The portion, in percent, of the maximum radius that is effectively considered for computing the normalization factor. The average value of the area inside this percentage of the maximum radius is used to normalize the data. | float64 | [0, 100] | 25
| radius_range | The minimum and maximum radius, in voxel units, between which the correction is done. If the maximum radius is equal to 0, the largest possible radius is used. | vector2u32 | Any value | [0, 0]
| threshold_range | Values out of this range are not included in the statistics to calculate the correction. | vector2d | Any value | [0, 65535]
| standard_deviation | The standard deviation, in voxel units, of the gaussian filtering used to smooth the histogram before performing the correction. No smoothing is applied if this value is set to 0. | float64 | >=0 | 0
| padding_policy | The way to manage uncomputed values (that is, voxels that are out of the maximum radius).
INPUT_VALUE | The input intensity value is transferred.
FIXED_VALUE | The uncomputed area is filled with a padding value.
| enumeration |  | INPUT_VALUE
| padding_value | The intensity value used to fill uncomputed voxels (that is, voxels that are out of the maximum radius). It is used only with the fixed value padding policy. | float64 | Any value | 0
| output_image | The corrected 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 3D input image to correct. | Image | Grayscale or Multispectral | null
| axisDirection | The axis along which the correction has to be carried out.
X_AXIS | The correction is applied on YZ slices.
Y_AXIS | The correction is applied on XZ slices.
Z_AXIS | The correction is applied on XY slices.
| Enumeration |  | Z_AXIS
| axisOrientation | Set the cylinder axis to be used during correction: straight or sheared. This option is ignored if the axis direction is not Z_AXIS (forced to straight).
STRAIGHT | A straight axis assumes that the sample is a vertical cylinder.
SHEARED | A sheared axis considers a sheared cylinder determined by the midpoints at the top and bottom of the sample. This option is only available when the rotation axis is Z_AXIS at this stage.
| Enumeration |  | STRAIGHT
| centerMode | The way to define the main center of the cylindrical sample. It is ignored if the axis orientation is set to SHEARED (forced to OTHER).
IMAGE_CENTER | The correction center is the center of the input image.
OTHER | The correction center is user-defined.
| Enumeration |  | IMAGE_CENTER
| mainCenter | The midpoint of the sample in voxel coordinates. With straight axis setting, this point is considered as the center of the sample. With sheared axis setting, it is considered as the center of the first plane of the sample. It is ignored if the axis orientation is set to STRAIGHT and center mode to IMAGE_CENTER. | Vector3u32 | Any value | {0, 0, 0}
| secondaryCenter | The midpoint of the last plane of the sample in voxel coordinates (ignored with STRAIGHT axis setting). It is only used if axis direction is Z_AXIS and the orientation is set to SHEARED. | Vector3u32 | Any value | {0, 0, 0}
| radiusPercentage | The portion, in percent, of the maximum radius that is effectively considered for computing the normalization factor. The average value of the area inside this percentage of the maximum radius is used to normalize the data. | Float64 | [0, 100] | 25
| radiusRange | The minimum and maximum radius, in voxel units, between which the correction is done. If the maximum radius is equal to 0, the largest possible radius is used. | Vector2u32 | Any value | {0, 0}
| thresholdRange | Values out of this range are not included in the statistics to calculate the correction. | Vector2d | Any value | {0f, 65535f}
| standardDeviation | The standard deviation, in voxel units, of the gaussian filtering used to smooth the histogram before performing the correction. No smoothing is applied if this value is set to 0. | Float64 | >=0 | 0
| paddingPolicy | The way to manage uncomputed values (that is, voxels that are out of the maximum radius).
INPUT_VALUE | The input intensity value is transferred.
FIXED_VALUE | The uncomputed area is filled with a padding value.
| Enumeration |  | INPUT_VALUE
| paddingValue | The intensity value used to fill uncomputed voxels (that is, voxels that are out of the maximum radius). It is used only with the fixed value padding policy. | Float64 | Any value | 0
| outputImage | The corrected image. Its dimensions and type are forced to the same values as the input. | Image |  | null

## Object Examples

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

    BeamHardeningCorrection3d beamHardeningCorrection3dAlgo;
    beamHardeningCorrection3dAlgo.setInputImage( foam );
    beamHardeningCorrection3dAlgo.setAxisDirection( BeamHardeningCorrection3d::AxisDirection::Z_AXIS );
    beamHardeningCorrection3dAlgo.setAxisOrientation( BeamHardeningCorrection3d::AxisOrientation::STRAIGHT );
    beamHardeningCorrection3dAlgo.setCenterMode( BeamHardeningCorrection3d::CenterMode::OTHER );
    beamHardeningCorrection3dAlgo.setMainCenter( {40, 50, 0} );
    beamHardeningCorrection3dAlgo.setSecondaryCenter( {0, 0, 0} );
    beamHardeningCorrection3dAlgo.setRadiusPercentage( 25 );
    beamHardeningCorrection3dAlgo.setRadiusRange( {0, 80} );
    beamHardeningCorrection3dAlgo.setThresholdRange( {0, 255} );
    beamHardeningCorrection3dAlgo.setStandardDeviation( 4 );
    beamHardeningCorrection3dAlgo.setPaddingPolicy( BeamHardeningCorrection3d::PaddingPolicy::INPUT_VALUE );
    beamHardeningCorrection3dAlgo.setPaddingValue( 0 );
    beamHardeningCorrection3dAlgo.execute();

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

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

    beam_hardening_correction_3d_algo = imagedev.BeamHardeningCorrection3d()
    beam_hardening_correction_3d_algo.input_image = foam
    beam_hardening_correction_3d_algo.axis_direction = imagedev.BeamHardeningCorrection3d.Z_AXIS
    beam_hardening_correction_3d_algo.axis_orientation = imagedev.BeamHardeningCorrection3d.STRAIGHT
    beam_hardening_correction_3d_algo.center_mode = imagedev.BeamHardeningCorrection3d.OTHER
    beam_hardening_correction_3d_algo.main_center = [40, 50, 0]
    beam_hardening_correction_3d_algo.secondary_center = [0, 0, 0]
    beam_hardening_correction_3d_algo.radius_percentage = 25
    beam_hardening_correction_3d_algo.radius_range = [0, 80]
    beam_hardening_correction_3d_algo.threshold_range = [0, 255]
    beam_hardening_correction_3d_algo.standard_deviation = 4
    beam_hardening_correction_3d_algo.padding_policy = imagedev.BeamHardeningCorrection3d.INPUT_VALUE
    beam_hardening_correction_3d_algo.padding_value = 0
    beam_hardening_correction_3d_algo.execute()

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

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

    BeamHardeningCorrection3d beamHardeningCorrection3dAlgo = new BeamHardeningCorrection3d
    {
        inputImage = foam,
        axisDirection = BeamHardeningCorrection3d.AxisDirection.Z_AXIS,
        axisOrientation = BeamHardeningCorrection3d.AxisOrientation.STRAIGHT,
        centerMode = BeamHardeningCorrection3d.CenterMode.OTHER,
        mainCenter = new uint[]{40, 50, 0},
        secondaryCenter = new uint[]{0, 0, 0},
        radiusPercentage = 25,
        radiusRange = new uint[]{0, 80},
        thresholdRange = new double[]{0, 255},
        standardDeviation = 4,
        paddingPolicy = BeamHardeningCorrection3d.PaddingPolicy.INPUT_VALUE,
        paddingValue = 0
    };
    beamHardeningCorrection3dAlgo.Execute();

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

## Function Examples

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

    auto result = beamHardeningCorrection3d( foam, BeamHardeningCorrection3d::AxisDirection::Z_AXIS, BeamHardeningCorrection3d::AxisOrientation::STRAIGHT, BeamHardeningCorrection3d::CenterMode::OTHER, {40, 50, 0}, {0, 0, 0}, 25, {0, 80}, {0, 255}, 4, BeamHardeningCorrection3d::PaddingPolicy::INPUT_VALUE, 0 );

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

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

    result = imagedev.beam_hardening_correction_3d(foam, imagedev.BeamHardeningCorrection3d.Z_AXIS, imagedev.BeamHardeningCorrection3d.STRAIGHT, imagedev.BeamHardeningCorrection3d.OTHER, [40, 50, 0], [0, 0, 0], 25, [0, 80], [0, 255], 4, imagedev.BeamHardeningCorrection3d.INPUT_VALUE, 0)

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

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

    IOLink.ImageView result = Processing.BeamHardeningCorrection3d( foam, BeamHardeningCorrection3d.AxisDirection.Z_AXIS, BeamHardeningCorrection3d.AxisOrientation.STRAIGHT, BeamHardeningCorrection3d.CenterMode.OTHER, new uint[]{40, 50, 0}, new uint[]{0, 0, 0}, 25, new uint[]{0, 80}, new double[]{0, 255}, 4, BeamHardeningCorrection3d.PaddingPolicy.INPUT_VALUE, 0 );

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

© 2025 Thermo Fisher Scientific Inc. All rights reserved.