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

# NonLocalMeansFilter2d

Adaptive filter denoising a two-dimensional image.
Access to parameter description
For an introduction to image filters: see Images Filtering.
This algorithm computes a weighted mean of a large set of pixels (search windows) around the pixel to be denoised (target pixel). The pixel weight in the search window is a function of the similarity between this pixel and the target pixel. A pixel very similar to the target pixel is assigned to a weight close to 1.0. A pixel very different from the target pixel is assigned to a weight close to 0 and has a small influence on the resulting denoised value.
The similarity between a pixel and the target pixel is based on the squared intensity differences between two patches of user-defined size, centered on the current pixel and the target pixel.
Images are often corrupted by noise because of the acquisition process. For an image $y$ defined on $\Omega$, which is the image domain, the noise added by acquisition is assimilated to an additive white gaussian noise: $$ y[k] = x[k] + e[k], \forall k \in \Omega $$ where $$ e[k] \sim \mathcal{N}(0, \sigma), \forall k \in \Omega $$
The denoised image $z$ is an estimation of $x$ as follows: $$ z[k] = \frac{\sum_{n\in\mathbb{Z}^3} w[k,n]\cdot y[k+n]}{\sum_{n\in\mathbb{Z}^3} w[k,n]} $$ with $$ w[k,n] = f(n)\exp\left(-\frac{ssd(k,n)}{\lambda}\right) $$ where:

- $ssd(k,n)$ is the similarity criterion (sum of squared differences)
- $\lambda$ is the similarity
- $f(n)$ is the indicator function of the search region
- and $h(n)$ is the indicator function of the patch region.

The algorithm looks for matchings within the search window area around each pixel.
The basic implementation of the previous equation has a complexity of $\mathcal{O}(P^2S^2NM)$ that can be reduced to $\mathcal{O}(S^2NM)$ where $N$ and $M$ are respectively the X and Y dimensions of the input image, $P$ is the patch size, and $S$ is the search window size.
Reference:
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.
See also

- BoxFilter2d
- BilateralFilter2d
- NonLocalMeansFilter3d

See related example

- Denoising

##
Function Syntax

This function returns outputImage.

    // Function prototype
    std::shared_ptr< iolink::ImageView >
    nonLocalMeansFilter2d( std::shared_ptr< iolink::ImageView > inputImage,
                           uint32_t patchRadius,
                           uint32_t kernelRadius,
                           double similarity,
                           NonLocalMeansFilter2d::KernelShape kernelShape,
                           std::shared_ptr< iolink::ImageView > outputImage = nullptr );

This function returns outputImage.

    // Function prototype.
    non_local_means_filter_2d(input_image: idt.ImageType,
                              patch_radius: int = 3,
                              kernel_radius: int = 6,
                              similarity: float = 0.6,
                              kernel_shape: NonLocalMeansFilter2d.KernelShape = NonLocalMeansFilter2d.KernelShape.SQUARE,
                              output_image: idt.ImageType = None) -> idt.ImageType

This function returns outputImage.

    // Function prototype.
    public static IOLink.ImageView
    NonLocalMeansFilter2d( IOLink.ImageView inputImage,
                           UInt32 patchRadius = 3,
                           UInt32 kernelRadius = 6,
                           double similarity = 0.6,
                           NonLocalMeansFilter2d.KernelShape kernelShape = ImageDev.NonLocalMeansFilter2d.KernelShape.SQUARE,
                           IOLink.ImageView outputImage = null );

##
Class Syntax

    // Command constructor.
    NonLocalMeansFilter2d();

    /// 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 patchRadius parameter.
    /// The patch box half size side length, in pixels.
    uint32_t patchRadius() const;
    /// Sets the patchRadius parameter.
    /// The patch box half size side length, in pixels.
    void setPatchRadius( const uint32_t& patchRadius );

    /// Gets the kernelRadius parameter.
    /// The search window half size side length or radius, in pixels.
    uint32_t kernelRadius() const;
    /// Sets the kernelRadius parameter.
    /// The search window half size side length or radius, in pixels.
    void setKernelRadius( const uint32_t& kernelRadius );

    /// Gets the similarity parameter.
    /// The similarity is used to compute weight w(k,n) assigned to each pixel in the search window.
    double similarity() const;
    /// Sets the similarity parameter.
    /// The similarity is used to compute weight w(k,n) assigned to each pixel in the search window.
    void setSimilarity( const double& similarity );

    /// Gets the kernelShape parameter.
    /// The shape of the search window.
    NonLocalMeansFilter2d::KernelShape kernelShape() const;
    /// Sets the kernelShape parameter.
    /// The shape of the search window.
    void setKernelShape( const NonLocalMeansFilter2d::KernelShape& kernelShape );

    /// Gets the outputImage parameter.
    /// The output image. Its dimensions, type, and calibration are forced to the same values as the input.
    std::shared_ptr< iolink::ImageView > outputImage() const;
    /// Sets the outputImage parameter.
    /// The output image. Its dimensions, type, and calibration 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.
    NonLocalMeansFilter2d.input_image
    # Property of the patchRadius parameter.
    NonLocalMeansFilter2d.patch_radius
    # Property of the kernelRadius parameter.
    NonLocalMeansFilter2d.kernel_radius
    # Property of the similarity parameter.
    NonLocalMeansFilter2d.similarity
    # Property of the kernelShape parameter.
    NonLocalMeansFilter2d.kernel_shape
    # Property of the outputImage parameter.
    NonLocalMeansFilter2d.output_image

    // Method to launch the command.
    execute()

    // Command constructor.
    NonLocalMeansFilter2d()

    // Property of the inputImage parameter.
    NonLocalMeansFilter2d.inputImage
    // Property of the patchRadius parameter.
    NonLocalMeansFilter2d.patchRadius
    // Property of the kernelRadius parameter.
    NonLocalMeansFilter2d.kernelRadius
    // Property of the similarity parameter.
    NonLocalMeansFilter2d.similarity
    // Property of the kernelShape parameter.
    NonLocalMeansFilter2d.kernelShape
    // Property of the outputImage parameter.
    NonLocalMeansFilter2d.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
| kernelShape | The shape of the search window.
SQUARE | The search window is a square.
DISK | The search window is a disk.
| Enumeration |  | SQUARE
| kernelRadius | The search window half size side length or radius, in pixels. In case of a square, a value N produces a square of 2N+1 pixels side length. In case of a disk, a value N produces a disk with a 2N+1 pixels diameter. The larger the search window, the better the results usually are. But the size of the search window also affects the run time significantly. 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 result in simple blurring of the image because there is not enough structural data within the search window area. | UInt32 | >=1 | 6
| patchRadius | The patch box half size side length, in pixels. The weight of a pixel in the search windows is computed by comparing the neighborhood of this pixel with the neighborhood of the target pixel. This value represents the edge size of the neighborhood volume, in number of pixels (patch neighborhood is a square), and affects the quality of the result. If this value is either much smaller or much larger than the finest structures of the image, the algorithm shows few or no effect at all. This parameter has almost no effect on the computation time. | UInt32 | Any value | 3
| similarity | The similarity is used to compute weight w(k,n) assigned to each pixel in the search window. The squared similarity is proportional to the standard deviation of the assumed gaussian noise of the input image. The larger this value, the more the resulting image is smoothed. The similarity has no effect on the computation time. | Float64 | >=0.001 | 0.6
| outputImage | The output image. Its dimensions, type, and calibration are forced to the same values as the input. | Image |  | nullptr

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| input_image | The input image. | image | Grayscale or Multispectral | None
| kernel_shape | The shape of the search window.
SQUARE | The search window is a square.
DISK | The search window is a disk.
| enumeration |  | SQUARE
| kernel_radius | The search window half size side length or radius, in pixels. In case of a square, a value N produces a square of 2N+1 pixels side length. In case of a disk, a value N produces a disk with a 2N+1 pixels diameter. The larger the search window, the better the results usually are. But the size of the search window also affects the run time significantly. 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 result in simple blurring of the image because there is not enough structural data within the search window area. | uint32 | >=1 | 6
| patch_radius | The patch box half size side length, in pixels. The weight of a pixel in the search windows is computed by comparing the neighborhood of this pixel with the neighborhood of the target pixel. This value represents the edge size of the neighborhood volume, in number of pixels (patch neighborhood is a square), and affects the quality of the result. If this value is either much smaller or much larger than the finest structures of the image, the algorithm shows few or no effect at all. This parameter has almost no effect on the computation time. | uint32 | Any value | 3
| similarity | The similarity is used to compute weight w(k,n) assigned to each pixel in the search window. The squared similarity is proportional to the standard deviation of the assumed gaussian noise of the input image. The larger this value, the more the resulting image is smoothed. The similarity has no effect on the computation time. | float64 | >=0.001 | 0.6
| output_image | The output image. Its dimensions, type, and calibration are forced to the same values as the input. | image |  | None

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| inputImage | The input image. | Image | Grayscale or Multispectral | null
| kernelShape | The shape of the search window.
SQUARE | The search window is a square.
DISK | The search window is a disk.
| Enumeration |  | SQUARE
| kernelRadius | The search window half size side length or radius, in pixels. In case of a square, a value N produces a square of 2N+1 pixels side length. In case of a disk, a value N produces a disk with a 2N+1 pixels diameter. The larger the search window, the better the results usually are. But the size of the search window also affects the run time significantly. 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 result in simple blurring of the image because there is not enough structural data within the search window area. | UInt32 | >=1 | 6
| patchRadius | The patch box half size side length, in pixels. The weight of a pixel in the search windows is computed by comparing the neighborhood of this pixel with the neighborhood of the target pixel. This value represents the edge size of the neighborhood volume, in number of pixels (patch neighborhood is a square), and affects the quality of the result. If this value is either much smaller or much larger than the finest structures of the image, the algorithm shows few or no effect at all. This parameter has almost no effect on the computation time. | UInt32 | Any value | 3
| similarity | The similarity is used to compute weight w(k,n) assigned to each pixel in the search window. The squared similarity is proportional to the standard deviation of the assumed gaussian noise of the input image. The larger this value, the more the resulting image is smoothed. The similarity has no effect on the computation time. | Float64 | >=0.001 | 0.6
| outputImage | The output image. Its dimensions, type, and calibration are forced to the same values as the input. | Image |  | null

## Object Examples

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

    NonLocalMeansFilter2d nonLocalMeansFilter2dAlgo;
    nonLocalMeansFilter2dAlgo.setInputImage( polystyrene );
    nonLocalMeansFilter2dAlgo.setPatchRadius( 3 );
    nonLocalMeansFilter2dAlgo.setKernelRadius( 3 );
    nonLocalMeansFilter2dAlgo.setSimilarity( 0.6 );
    nonLocalMeansFilter2dAlgo.setKernelShape( NonLocalMeansFilter2d::KernelShape::SQUARE );
    nonLocalMeansFilter2dAlgo.execute();

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

    polystyrene = ioformat.read_image(imagedev_data.get_image_path("polystyrene.tif"))

    non_local_means_filter_2d_algo = imagedev.NonLocalMeansFilter2d()
    non_local_means_filter_2d_algo.input_image = polystyrene
    non_local_means_filter_2d_algo.patch_radius = 3
    non_local_means_filter_2d_algo.kernel_radius = 3
    non_local_means_filter_2d_algo.similarity = 0.6
    non_local_means_filter_2d_algo.kernel_shape = imagedev.NonLocalMeansFilter2d.SQUARE
    non_local_means_filter_2d_algo.execute()

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

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

    NonLocalMeansFilter2d nonLocalMeansFilter2dAlgo = new NonLocalMeansFilter2d
    {
        inputImage = polystyrene,
        patchRadius = 3,
        kernelRadius = 3,
        similarity = 0.6,
        kernelShape = NonLocalMeansFilter2d.KernelShape.SQUARE
    };
    nonLocalMeansFilter2dAlgo.Execute();

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

## Function Examples

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

    auto result = nonLocalMeansFilter2d( polystyrene, 3, 3, 0.6, NonLocalMeansFilter2d::KernelShape::SQUARE );

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

    polystyrene = ioformat.read_image(imagedev_data.get_image_path("polystyrene.tif"))

    result = imagedev.non_local_means_filter_2d(polystyrene, 3, 3, 0.6, imagedev.NonLocalMeansFilter2d.SQUARE)

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

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

    IOLink.ImageView result = Processing.NonLocalMeansFilter2d( polystyrene, 3, 3, 0.6, NonLocalMeansFilter2d.KernelShape.SQUARE );

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

© 2025 Thermo Fisher Scientific Inc. All rights reserved.