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

# Clahe3d

Performs a contrast limited adaptive histogram equalization (CLAHE) on a three-dimensional image.
Access to parameter description
The Contrast Limited Adaptive Histogram Equalization (CLAHE) algorithm is a widely used method for locally enhancing the contrast of images. It improves the visibility of details in low-contrast images by assigning each pixel an output value based on a transformation function derived from the histogram of a surrounding tile.
Homegenous regions can generate strong peaks in the histogram. Applying equalization to such histograms tends to over-amplify noise. To address this, a contrast limiting mechanism is applied, which truncates the histogram of each tile at a specified clip limit. If a histogram bin exceeds this limit, the corresponding pixel intensities are redistributed uniformly among other bins.
The maximum number of elements $M$ in a histogram bin is given by: $$ M = Cl \times \frac{P}{N} $$ Where:

- $Cl$ is the clipLimit parameter.
- $P$ is the number of pixels contained in a tile, given by the tileSize parameter.
- $N$ is the number of bins, given by numberOfBins parameter.
- $P/N$ is the average histogram content.

Once the histogram is computed and clipped, a histogram equalization process is performed independently on each tile. This process redistributes the pixel intensities within the tile's histogram range, effectively enhancing the contrast.
By default, the histograms are computed only on contiguous tiles, providing accurate results for each tile center. Other pixel values are computed by interpolating the histograms computed for overlapping tiles. Alternatively, the actual histogram of each image pixel can be computed by changing the computationMode parameter. The first method is faster, while the second is more accurate.
The CLAHE algorithm can be sumarized by the following steps:

- Divide the image into tiles of a fixed size.
- Compute the histogram for each tile.
- Clip the histograms, if necessary.
- Perform a histogram equalization on each tile.

Reference:
K.Zuiderveld. "Contrast Limited Adaptive Histogram Equalization". Graphics Gems IV, pp.474-485, 1994.
See also

- HistogramEqualization
- AdaptiveHistogramEqualization
- Clahe2d

##
Function Syntax

This function returns outputImage.

    // Function prototype
    std::shared_ptr< iolink::ImageView >
    clahe3d( std::shared_ptr< iolink::ImageView > inputImage,
             const iolink::Vector3u32& tileSize,
             Clahe3d::ComputationMode computationMode,
             double clipLimit,
             uint32_t numberOfBins,
             std::shared_ptr< iolink::ImageView > outputImage = nullptr );

This function returns outputImage.

    // Function prototype.
    clahe_3d(input_image: idt.ImageType,
             tile_size: Iterable[int] = [64, 64, 64],
             computation_mode: Clahe3d.ComputationMode = Clahe3d.ComputationMode.INTERPOLATED,
             clip_limit: float = 1,
             number_of_bins: int = 256,
             output_image: idt.ImageType = None) -> idt.ImageType

This function returns outputImage.

    // Function prototype.
    public static IOLink.ImageView
    Clahe3d( IOLink.ImageView inputImage,
             uint[] tileSize = null,
             Clahe3d.ComputationMode computationMode = ImageDev.Clahe3d.ComputationMode.INTERPOLATED,
             double clipLimit = 1,
             UInt32 numberOfBins = 256,
             IOLink.ImageView outputImage = null );

##
Class Syntax

    // Command constructor.
    Clahe3d();

    /// 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 tileSize parameter.
    /// The X, Y and Z size, in pixels, of the tile used to compute the histogram.
    iolink::Vector3u32 tileSize() const;
    /// Sets the tileSize parameter.
    /// The X, Y and Z size, in pixels, of the tile used to compute the histogram.
    void setTileSize( const iolink::Vector3u32& tileSize );

    /// Gets the computationMode parameter.
    /// The way to compute histograms for the transformation function.
    Clahe3d::ComputationMode computationMode() const;
    /// Sets the computationMode parameter.
    /// The way to compute histograms for the transformation function.
    void setComputationMode( const Clahe3d::ComputationMode& computationMode );

    /// Gets the clipLimit parameter.
    /// The ratio defining the maximum number of elements contained in a histogram bin as a multiple of the average histogram contents.
    double clipLimit() const;
    /// Sets the clipLimit parameter.
    /// The ratio defining the maximum number of elements contained in a histogram bin as a multiple of the average histogram contents.
    void setClipLimit( const double& clipLimit );

    /// Gets the numberOfBins parameter.
    /// The number of bins of the histogram.
    uint32_t numberOfBins() const;
    /// Sets the numberOfBins parameter.
    /// The number of bins of the histogram.
    void setNumberOfBins( const uint32_t& numberOfBins );

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

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

    # Property of the inputImage parameter.
    Clahe3d.input_image
    # Property of the tileSize parameter.
    Clahe3d.tile_size
    # Property of the computationMode parameter.
    Clahe3d.computation_mode
    # Property of the clipLimit parameter.
    Clahe3d.clip_limit
    # Property of the numberOfBins parameter.
    Clahe3d.number_of_bins
    # Property of the outputImage parameter.
    Clahe3d.output_image

    // Method to launch the command.
    execute()

    // Command constructor.
    Clahe3d()

    // Property of the inputImage parameter.
    Clahe3d.inputImage
    // Property of the tileSize parameter.
    Clahe3d.tileSize
    // Property of the computationMode parameter.
    Clahe3d.computationMode
    // Property of the clipLimit parameter.
    Clahe3d.clipLimit
    // Property of the numberOfBins parameter.
    Clahe3d.numberOfBins
    // Property of the outputImage parameter.
    Clahe3d.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
| tileSize | The X, Y and Z size, in pixels, of the tile used to compute the histogram. | Vector3u32 | Any value | {64, 64, 64}
| computationMode | The way to compute histograms for the transformation function.
INTERPOLATED | The image is divided in contiguous tiles. A histogram is calculated for each tile and the transformation function for a given pixel is determined by interpolation of these histograms.
SLIDING | A histogram is computed for the tile surrounding each pixel and the transformation function is based on this histogram.
| Enumeration |  | INTERPOLATED
| clipLimit | The ratio defining the maximum number of elements contained in a histogram bin as a multiple of the average histogram contents. This maximum number of elements is equal to the clip limit multiplied by the number of pixels of a tile divided by the number of bins of the histogram. A clip limit value equals to the number of bins of the histogram means that no contrast amplification limitation is applied. A clip limit value equals to 0 means that the output image the same as the input image. | Float64 | >=0 | 1
| numberOfBins | The number of bins of the histogram. | UInt32 | >=1 | 256
| outputImage | The output image. The output image characteristics are forced to the same as the input image. | Image |  | nullptr

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| input_image | The input image. | image | Grayscale or Multispectral | None
| tile_size | The X, Y and Z size, in pixels, of the tile used to compute the histogram. | vector3u32 | Any value | [64, 64, 64]
| computation_mode | The way to compute histograms for the transformation function.
INTERPOLATED | The image is divided in contiguous tiles. A histogram is calculated for each tile and the transformation function for a given pixel is determined by interpolation of these histograms.
SLIDING | A histogram is computed for the tile surrounding each pixel and the transformation function is based on this histogram.
| enumeration |  | INTERPOLATED
| clip_limit | The ratio defining the maximum number of elements contained in a histogram bin as a multiple of the average histogram contents. This maximum number of elements is equal to the clip limit multiplied by the number of pixels of a tile divided by the number of bins of the histogram. A clip limit value equals to the number of bins of the histogram means that no contrast amplification limitation is applied. A clip limit value equals to 0 means that the output image the same as the input image. | float64 | >=0 | 1
| number_of_bins | The number of bins of the histogram. | uint32 | >=1 | 256
| output_image | The output image. The output image characteristics are forced to the same as the input image. | image |  | None

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| inputImage | The input image. | Image | Grayscale or Multispectral | null
| tileSize | The X, Y and Z size, in pixels, of the tile used to compute the histogram. | Vector3u32 | Any value | {64, 64, 64}
| computationMode | The way to compute histograms for the transformation function.
INTERPOLATED | The image is divided in contiguous tiles. A histogram is calculated for each tile and the transformation function for a given pixel is determined by interpolation of these histograms.
SLIDING | A histogram is computed for the tile surrounding each pixel and the transformation function is based on this histogram.
| Enumeration |  | INTERPOLATED
| clipLimit | The ratio defining the maximum number of elements contained in a histogram bin as a multiple of the average histogram contents. This maximum number of elements is equal to the clip limit multiplied by the number of pixels of a tile divided by the number of bins of the histogram. A clip limit value equals to the number of bins of the histogram means that no contrast amplification limitation is applied. A clip limit value equals to 0 means that the output image the same as the input image. | Float64 | >=0 | 1
| numberOfBins | The number of bins of the histogram. | UInt32 | >=1 | 256
| outputImage | The output image. The output image characteristics are forced to the same as the input image. | Image |  | null

## Object Examples

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

    Clahe3d clahe3dAlgo;
    clahe3dAlgo.setInputImage( foam );
    clahe3dAlgo.setTileSize( {32, 32, 32} );
    clahe3dAlgo.setComputationMode( Clahe3d::ComputationMode::INTERPOLATED );
    clahe3dAlgo.setClipLimit( 3 );
    clahe3dAlgo.setNumberOfBins( 256 );
    clahe3dAlgo.execute();

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

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

    clahe_3d_algo = imagedev.Clahe3d()
    clahe_3d_algo.input_image = foam
    clahe_3d_algo.tile_size = [32, 32, 32]
    clahe_3d_algo.computation_mode = imagedev.Clahe3d.INTERPOLATED
    clahe_3d_algo.clip_limit = 3
    clahe_3d_algo.number_of_bins = 256
    clahe_3d_algo.execute()

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

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

    Clahe3d clahe3dAlgo = new Clahe3d
    {
        inputImage = foam,
        tileSize = new uint[]{32, 32, 32},
        computationMode = Clahe3d.ComputationMode.INTERPOLATED,
        clipLimit = 3,
        numberOfBins = 256
    };
    clahe3dAlgo.Execute();

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

## Function Examples

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

    auto result = clahe3d( foam, {32, 32, 32}, Clahe3d::ComputationMode::INTERPOLATED, 3, 256 );

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

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

    result = imagedev.clahe_3d(foam, [32, 32, 32], imagedev.Clahe3d.INTERPOLATED, 3, 256)

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

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

    IOLink.ImageView result = Processing.Clahe3d( foam, new uint[]{32, 32, 32}, Clahe3d.ComputationMode.INTERPOLATED, 3, 256 );

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

© 2025 Thermo Fisher Scientific Inc. All rights reserved.