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

# CudaAdaptiveManifoldNlmFilter

Smooths an image using an advanced edge preserving filter.
Access to parameter description
For an introduction:

- section CUDA
- NonLocalMeansFilter3d

This module implements a non-local-means filtering algorithm using an adaptive-manifolds-based approach, as described by Gastal and Oliveira in Adaptive Manifolds for Real-Time High-Dimensional Filtering (2012).
The original non-local means algorithm was proposed by Buades et al. in A Non Local Algorithm for Image Denoising (2005). As many other denoising algorithms, it assumes that the noise in the dataset is white noise. This is a safe assumption for most datasets. The non-local-means algorithm naturally preserves most features present in the image, even small and thin ones. However, the algorithm must not be confused with a feature enhancement algorithm, such as edge enhancement. If edge enhancement is required, it is suggested to run non-local means filtering first followed by edge enhancement. This should give the best results.
In order to determine the new value for the current voxel, the original non-local means algorithm compares the neighborhoods of all voxels in a given search window with the neighborhood of the current voxel. The similarity between the neighborhoods determines the weight with which the value of a voxel in the search window will influence the new value of the current voxel. The final weights are determined by applying a Gauss kernel to the similarity values.
Even with restricted search windows, the original non-local means shows a poor performance due to its $O(n^3)$ complexity. Recent research in the literature has been focused on providing techniques to improve the performance of this algorithm. One of the techniques that has shown the most promising results is the high-dimensional filtering. High-dimensional filter is based on a signal-processing approach. The neighborhood surrounding a pixel constitutes a patch. The set of all patches is mapped onto a space of $n_r + n_s$ dimensions, where $n_r$ is the number of range dimensions (i.e., the size of the neighborhood), and $n_s$ is the size of the spatial dimensions (for 3D data, it is $3$). A blurring step is performed into this high-dimensional space, and then the values of the filtered dataset are retrieved.
Although this technique enables several optimization techniques, filtering the whole high-dimensional space is not cost-effective, as the original dataset only covers a very small portion of it. The adaptive-manifolds approach dramatically improves the performance. This algorithm generates several manifolds within the high-dimensional space that approximate the patch set. Only the data on the manifolds is blurred, and the filtered dataset is retrieved from these manifolds. This approximation to the non-local means algorithm reduces its complexity to linear in the number of pixels and in the dimension of the space.
A more detailed discussion and comparison of the Adaptive Manifold Non-Local Means filtering to other denoising methods is given in the following technical report.
Julian Lamas-Rodriguez, Moritz Ehlke, Rene Hoffmann and Stefan Zachow, GPU-accelerated denoising of large tomographic data sets with low SNR, 2015, ZIB-Report 15-14.
References

- A. Buades, B. Coll, J.M.Morel. "A Non-Local Algorithm for Image Denoising". Proceedings of the 2005 IEEE Computer Society Conference on Computer Vision and Pattern Recognition (CVPR), vol. 2, pp. 60-65, 2005.
- J. Lamas-Rodriguez, M. Ehlke, R. Hoffmann and S. Zachow, GPU-accelerated denoising of large tomographic data sets with low SNR , ZIB-Report, vol. 15, pp. 1-65, 2015.

See also

- CudaMedianFilter2d
- CudaGaussianFilter3d
- NonLocalMeansFilter2d
- NonLocalMeansFilter3d

##
Function Syntax

This function returns outputImage.

    // Function prototype
    std::shared_ptr< iolink::ImageView >
    cudaAdaptiveManifoldNlmFilter( std::shared_ptr< iolink::ImageView > inputImage,
                                   double spatialStandardDeviation,
                                   double intensityStandardDeviation,
                                   uint32_t kernelRadius,
                                   uint32_t patchRadius,
                                   CudaContext::Ptr cudaContext,
                                   std::shared_ptr< iolink::ImageView > outputImage = nullptr );

This function returns outputImage.

    // Function prototype.
    cuda_adaptive_manifold_nlm_filter(input_image: idt.ImageType,
                                      spatial_standard_deviation: float = 5,
                                      intensity_standard_deviation: float = 0.2,
                                      kernel_radius: int = 10,
                                      patch_radius: int = 3,
                                      cuda_context: Union[CudaContext, None] = None,
                                      output_image: idt.ImageType = None) -> idt.ImageType

This function returns outputImage.

    // Function prototype.
    public static IOLink.ImageView
    CudaAdaptiveManifoldNlmFilter( IOLink.ImageView inputImage,
                                   double spatialStandardDeviation = 5,
                                   double intensityStandardDeviation = 0.2,
                                   UInt32 kernelRadius = 10,
                                   UInt32 patchRadius = 3,
                                   Data.CudaContext cudaContext = null,
                                   IOLink.ImageView outputImage = null );

##
Class Syntax

    // Command constructor.
    CudaAdaptiveManifoldNlmFilter();

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

    /// Gets the spatialStandardDeviation parameter.
    /// The spatial standard deviation. Intuitively, it allows controlling how fast the similarity between two voxels decreases depending on their distance. The higher this value is, the blurrier the result is.
    double spatialStandardDeviation() const;
    /// Sets the spatialStandardDeviation parameter.
    /// The spatial standard deviation. Intuitively, it allows controlling how fast the similarity between two voxels decreases depending on their distance. The higher this value is, the blurrier the result is.
    void setSpatialStandardDeviation( const double& spatialStandardDeviation );

    /// Gets the intensityStandardDeviation parameter.
    /// The intensity/range standard deviation. Intuitively, it allows controlling how fast the similarity between two voxels decreases depending on the intensities of their neighborhoods.
    double intensityStandardDeviation() const;
    /// Sets the intensityStandardDeviation parameter.
    /// The intensity/range standard deviation. Intuitively, it allows controlling how fast the similarity between two voxels decreases depending on the intensities of their neighborhoods.
    void setIntensityStandardDeviation( const double& intensityStandardDeviation );

    /// Gets the kernelRadius parameter.
    /// The search window size to apply. The algorithm looks for matches within this area around each point.
    uint32_t kernelRadius() const;
    /// Sets the kernelRadius parameter.
    /// The search window size to apply. The algorithm looks for matches within this area around each point.
    void setKernelRadius( const uint32_t& kernelRadius );

    /// Gets the patchRadius parameter.
    /// Size of the neighborhood window. The influence of each point in the search window on the base point is weighted by comparing the neighborhood window of this point with the neighborhood window of the base point of the search window.
    uint32_t patchRadius() const;
    /// Sets the patchRadius parameter.
    /// Size of the neighborhood window. The influence of each point in the search window on the base point is weighted by comparing the neighborhood window of this point with the neighborhood window of the base point of the search window.
    void setPatchRadius( const uint32_t& patchRadius );

    /// Gets the cudaContext parameter.
    /// CUDA context information.
    CudaContext::Ptr cudaContext() const;
    /// Sets the cudaContext parameter.
    /// CUDA context information.
    void setCudaContext( const CudaContext::Ptr& cudaContext );

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

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

    # Property of the inputImage parameter.
    CudaAdaptiveManifoldNlmFilter.input_image
    # Property of the spatialStandardDeviation parameter.
    CudaAdaptiveManifoldNlmFilter.spatial_standard_deviation
    # Property of the intensityStandardDeviation parameter.
    CudaAdaptiveManifoldNlmFilter.intensity_standard_deviation
    # Property of the kernelRadius parameter.
    CudaAdaptiveManifoldNlmFilter.kernel_radius
    # Property of the patchRadius parameter.
    CudaAdaptiveManifoldNlmFilter.patch_radius
    # Property of the cudaContext parameter.
    CudaAdaptiveManifoldNlmFilter.cuda_context
    # Property of the outputImage parameter.
    CudaAdaptiveManifoldNlmFilter.output_image

    // Method to launch the command.
    execute()

    // Command constructor.
    CudaAdaptiveManifoldNlmFilter()

    // Property of the inputImage parameter.
    CudaAdaptiveManifoldNlmFilter.inputImage
    // Property of the spatialStandardDeviation parameter.
    CudaAdaptiveManifoldNlmFilter.spatialStandardDeviation
    // Property of the intensityStandardDeviation parameter.
    CudaAdaptiveManifoldNlmFilter.intensityStandardDeviation
    // Property of the kernelRadius parameter.
    CudaAdaptiveManifoldNlmFilter.kernelRadius
    // Property of the patchRadius parameter.
    CudaAdaptiveManifoldNlmFilter.patchRadius
    // Property of the cudaContext parameter.
    CudaAdaptiveManifoldNlmFilter.cudaContext
    // Property of the outputImage parameter.
    CudaAdaptiveManifoldNlmFilter.outputImage

    // Method to launch the command.
    Execute()

## Parameters

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| inputImage | The input image. The image type can be integer or float. | Image | Grayscale or Multispectral | nullptr
| spatialStandardDeviation | The spatial standard deviation. Intuitively, it allows controlling how fast the similarity between two voxels decreases depending on their distance. The higher this value is, the blurrier the result is. | Float64 | >=0 | 5
| intensityStandardDeviation | The intensity/range standard deviation. Intuitively, it allows controlling how fast the similarity between two voxels decreases depending on the intensities of their neighborhoods. It affects the blurriness of the result in much the same way as the spatial standard deviation, but the effect is not as strong. Limitation: Furthermore, memory fragmentation can prevent the allocation of large CUDA memory blocks. In both cases, the computation might fail due to lack of memory. The recommendation, therefore, is to run the computation alone. | Float64 | >0 | 0.2
| kernelRadius | The search window size to apply. The algorithm looks for matches within this area around each point. The value represents the radius of the search window area in number of voxels. The larger the search window is, the better the results usually are. But the size of the search window also effects the run time significantly. The larger the search window, the longer the run time. This value has to be set to a large enough value so that similar structures can be found within the search window area. Too small values will result in simple blurring of the image because there is not enough structural information within the search window area. A search window size of 10 is usually a good choice. | UInt32 | >=1 | 10
| patchRadius | Size of the neighborhood window. The influence of each point in the search window on the base point is weighted by comparing the neighborhood window of this point with the neighborhood window of the base point of the search window. The value represents the radius of the neighborhood area in number of voxels, and affects the quality of the result as well as the run time. If this value is either much smaller or much larger than fine structures in the data the algorithm shows little or no effect at all. The larger the value, the longer the run time. For most use cases, a maximum value of five is sufficient to achieve good filtering results. Therefore, the maximum value of this port is set to five to avoid unnecessarily long run times. | UInt32 | [3, 5] | 3
| cudaContext | CUDA context information. | CudaContext |  | nullptr
| outputImage | The output image. Its dimensions and type are forced to the same values as the input image. | Image |  | nullptr

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| input_image | The input image. The image type can be integer or float. | image | Grayscale or Multispectral | None
| spatial_standard_deviation | The spatial standard deviation. Intuitively, it allows controlling how fast the similarity between two voxels decreases depending on their distance. The higher this value is, the blurrier the result is. | float64 | >=0 | 5
| intensity_standard_deviation | The intensity/range standard deviation. Intuitively, it allows controlling how fast the similarity between two voxels decreases depending on the intensities of their neighborhoods. It affects the blurriness of the result in much the same way as the spatial standard deviation, but the effect is not as strong. Limitation: Furthermore, memory fragmentation can prevent the allocation of large CUDA memory blocks. In both cases, the computation might fail due to lack of memory. The recommendation, therefore, is to run the computation alone. | float64 | >0 | 0.2
| kernel_radius | The search window size to apply. The algorithm looks for matches within this area around each point. The value represents the radius of the search window area in number of voxels. The larger the search window is, the better the results usually are. But the size of the search window also effects the run time significantly. The larger the search window, the longer the run time. This value has to be set to a large enough value so that similar structures can be found within the search window area. Too small values will result in simple blurring of the image because there is not enough structural information within the search window area. A search window size of 10 is usually a good choice. | uint32 | >=1 | 10
| patch_radius | Size of the neighborhood window. The influence of each point in the search window on the base point is weighted by comparing the neighborhood window of this point with the neighborhood window of the base point of the search window. The value represents the radius of the neighborhood area in number of voxels, and affects the quality of the result as well as the run time. If this value is either much smaller or much larger than fine structures in the data the algorithm shows little or no effect at all. The larger the value, the longer the run time. For most use cases, a maximum value of five is sufficient to achieve good filtering results. Therefore, the maximum value of this port is set to five to avoid unnecessarily long run times. | uint32 | [3, 5] | 3
| cuda_context | CUDA context information. | cuda_context |  | None
| output_image | The output image. Its dimensions and type are forced to the same values as the input image. | image |  | None

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| inputImage | The input image. The image type can be integer or float. | Image | Grayscale or Multispectral | null
| spatialStandardDeviation | The spatial standard deviation. Intuitively, it allows controlling how fast the similarity between two voxels decreases depending on their distance. The higher this value is, the blurrier the result is. | Float64 | >=0 | 5
| intensityStandardDeviation | The intensity/range standard deviation. Intuitively, it allows controlling how fast the similarity between two voxels decreases depending on the intensities of their neighborhoods. It affects the blurriness of the result in much the same way as the spatial standard deviation, but the effect is not as strong. Limitation: Furthermore, memory fragmentation can prevent the allocation of large CUDA memory blocks. In both cases, the computation might fail due to lack of memory. The recommendation, therefore, is to run the computation alone. | Float64 | >0 | 0.2
| kernelRadius | The search window size to apply. The algorithm looks for matches within this area around each point. The value represents the radius of the search window area in number of voxels. The larger the search window is, the better the results usually are. But the size of the search window also effects the run time significantly. The larger the search window, the longer the run time. This value has to be set to a large enough value so that similar structures can be found within the search window area. Too small values will result in simple blurring of the image because there is not enough structural information within the search window area. A search window size of 10 is usually a good choice. | UInt32 | >=1 | 10
| patchRadius | Size of the neighborhood window. The influence of each point in the search window on the base point is weighted by comparing the neighborhood window of this point with the neighborhood window of the base point of the search window. The value represents the radius of the neighborhood area in number of voxels, and affects the quality of the result as well as the run time. If this value is either much smaller or much larger than fine structures in the data the algorithm shows little or no effect at all. The larger the value, the longer the run time. For most use cases, a maximum value of five is sufficient to achieve good filtering results. Therefore, the maximum value of this port is set to five to avoid unnecessarily long run times. | UInt32 | [3, 5] | 3
| cudaContext | CUDA context information. | CudaContext |  | null
| outputImage | The output image. Its dimensions and type are forced to the same values as the input image. | Image |  | null

## Object Examples

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

    CudaAdaptiveManifoldNlmFilter cudaAdaptiveManifoldNlmFilterAlgo;
    cudaAdaptiveManifoldNlmFilterAlgo.setInputImage( foam );
    cudaAdaptiveManifoldNlmFilterAlgo.setSpatialStandardDeviation( 5.0 );
    cudaAdaptiveManifoldNlmFilterAlgo.setIntensityStandardDeviation( 0.2 );
    cudaAdaptiveManifoldNlmFilterAlgo.setKernelRadius( 10 );
    cudaAdaptiveManifoldNlmFilterAlgo.setPatchRadius( 3 );
    cudaAdaptiveManifoldNlmFilterAlgo.setCudaContext( nullptr );
    cudaAdaptiveManifoldNlmFilterAlgo.execute();

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

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

    cuda_adaptive_manifold_nlm_filter_algo = imagedev.CudaAdaptiveManifoldNlmFilter()
    cuda_adaptive_manifold_nlm_filter_algo.input_image = foam
    cuda_adaptive_manifold_nlm_filter_algo.spatial_standard_deviation = 5.0
    cuda_adaptive_manifold_nlm_filter_algo.intensity_standard_deviation = 0.2
    cuda_adaptive_manifold_nlm_filter_algo.kernel_radius = 10
    cuda_adaptive_manifold_nlm_filter_algo.patch_radius = 3
    cuda_adaptive_manifold_nlm_filter_algo.cuda_context = None
    cuda_adaptive_manifold_nlm_filter_algo.execute()

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

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

    CudaAdaptiveManifoldNlmFilter cudaAdaptiveManifoldNlmFilterAlgo = new CudaAdaptiveManifoldNlmFilter
    {
        inputImage = foam,
        spatialStandardDeviation = 5.0,
        intensityStandardDeviation = 0.2,
        kernelRadius = 10,
        patchRadius = 3,
        cudaContext = null
    };
    cudaAdaptiveManifoldNlmFilterAlgo.Execute();

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

## Function Examples

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

    auto result = cudaAdaptiveManifoldNlmFilter( foam, 5.0, 0.2, 10, 3, nullptr );

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

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

    result = imagedev.cuda_adaptive_manifold_nlm_filter(foam, 5.0, 0.2, 10, 3, None)

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

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

    IOLink.ImageView result = Processing.CudaAdaptiveManifoldNlmFilter( foam, 5.0, 0.2, 10, 3, null );

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

© 2025 Thermo Fisher Scientific Inc. All rights reserved.