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

# CorrelationByDifference2d

Performs a correlation by the difference between a two-dimensional grayscale image and a grayscale kernel.
Access to parameter description
For an introduction: section Image Correlation.
This algorithm performs a correlation with a difference metric between a gray level image $I$ and a gray level kernel $K$, returning the correlation image $O$.
The different possibilities for selecting a correlation peak are presented below using a 1-D correlation between an image and kernel. In the image, the kernel appears 6 times with different contrast and luminosity.
Figure 1. 1D image and kernel
The 6 examples show the kernel appearing with different contrast and luminosity.
Figure 2. Examples of possible 1D correlation
The correlation by difference metric is computed in accordance with the CorrelationMode parameter.

### DIRECT Correlation Mode

$$ O(n,m)=\sum_{i=1}^{kx} \sum_{j=1}^{ky} \left|K(i,j)-I(n+i-\frac{kx}{2},m+j-\frac{ky}{2})\right| $$ In this mode, 3 of the 6 patterns matching the kernel are detected. These are only patterns having similar luminosity. The best matching is obtained with the similar contrast and luminosity pattern.
Figure 3. Example of Difference 1D direct correlation

### MEAN Correlation Mode

$$ O(n,m)=\sum_{i=1}^{kx} \sum_{j=1}^{ky} \left|\left(K(i,j)-\mu(K)\right)-\left(I(n+i-\frac{kx}{2}, m+j-\frac{ky}{2})-\mu(I)(n,m)\right)\right| $$ In this mode, 2 of the 6 patterns matching the kernel are detected. These are only patterns having similar contrast. The confidence rate is the same for the 2 patterns.
Figure 4. Example of Difference 1D mean correlation

### VARIANCE Correlation Mode

$$ O(n,m)=\frac{\sum\limits_{i=1}^{kx} \sum\limits_{j=1}^{ky} \left|K(i,j)-I(n+i-\frac{kx}{2}, m+j-\frac{ky}{2})\right|}{\sqrt{\sigma^2(K)\times \sigma^2(I)(n,m)}} $$ In this mode, 3 of the 6 patterns matching the kernel are detected. These are only patterns having similar luminosity. The confidence rate is the same for the 3 patterns.
Figure 5. Example of Difference 1D variance correlation

### MEAN_VARIANCE Correlation Mode

$$ O(n,m)=\frac{\sum\limits_{i=1}^{kx} \sum\limits_{j=1}^{ky} \left|\left(K(i,j)-\mu(K)\right) -\left(I(n+i-\frac{kx}{2},m+j-\frac{ky}{2})-\mu(I)(n,m)\right)\right|}{\sqrt{\sigma^2(K)\times \sigma^2(I)(n,m)}} $$ In this mode, the 6 patterns matching the kernel are detected, with the same confidence rate.
Figure 6. Example of Difference 1D mean and variance correlation
where: $$ \mu(K)=\frac{\sum\limits_{i=1}^{kx} \sum\limits_{j=1}^{ky} K(i,j)}{kx\times ky} $$ $$ \mu(I)(n,m)=\frac{\sum\limits_{i=1}^{kx} \sum\limits_{j=1}^{ky} I(n+i,m+j)}{kx\times ky} $$ $$ \sigma^2(K)=\sum_{i=1}^{kx} \sum_{j=1}^{ky} \left(K(i,j)-\mu(K)\right)^{2} $$ $$ \sigma^2(I)(n,m)=\sum_{i=1}^{kx} \sum_{j=1}^{ky} \left( I(n+i-\frac{kx}{2},m+j-\frac{ky}{2} ) - \mu(I)(n,m)\right)^{2} $$
Note: This algorithm returns the main correlation peak in the outputMeasurement object. More correlation peaks can be extracted from the outputImage correlation image with the LocalMaxima2d algorithm.
See also

- CrossCorrelation2d
- CorrelationBySignChange2d
- LocalMaxima2d

##
Function Syntax

This function returns a CorrelationByDifference2dOutput structure containing outputImage and outputMeasurement.

    // Output structure of the correlationByDifference2d function.
    struct CorrelationByDifference2dOutput
    {
        /// The output correlation image. Its dimensions are forced to the same values as the input. Its data type is forced to floating point.
        std::shared_ptr< iolink::ImageView > outputImage;
        /// The correlation matching results.
        CorrelationMsr::Ptr outputMeasurement;
    };

    // Function prototype
    CorrelationByDifference2dOutput
    correlationByDifference2d( std::shared_ptr< iolink::ImageView > inputImage,
                               std::shared_ptr< iolink::ImageView > inputKernelImage,
                               CorrelationByDifference2d::OffsetMode offsetMode,
                               CorrelationByDifference2d::CorrelationMode correlationMode,
                               std::shared_ptr< iolink::ImageView > outputImage = nullptr,
                               CorrelationMsr::Ptr outputMeasurement = nullptr );

This function returns a tuple containing output_image and output_measurement.

    // Function prototype.
    correlation_by_difference_2d(input_image: idt.ImageType,
                                 input_kernel_image: idt.ImageType,
                                 offset_mode: CorrelationByDifference2d.OffsetMode = CorrelationByDifference2d.OffsetMode.OFFSET_1,
                                 correlation_mode: CorrelationByDifference2d.CorrelationMode = CorrelationByDifference2d.CorrelationMode.DIRECT,
                                 output_image: idt.ImageType = None,
                                 output_measurement: Union[Any, None] = None) -> Tuple[idt.ImageType, CorrelationMsr]

This function returns a CorrelationByDifference2dOutput structure containing outputImage and outputMeasurement.

    /// Output structure of the CorrelationByDifference2d function.
    public struct CorrelationByDifference2dOutput
    {
        ///
        /// The output correlation image. Its dimensions are forced to the same values as the input. Its data type is forced to floating point.
        ///
        public IOLink.ImageView outputImage;
        /// The correlation matching results.
        public CorrelationMsr outputMeasurement;
    };

    // Function prototype.
    public static CorrelationByDifference2dOutput
    CorrelationByDifference2d( IOLink.ImageView inputImage,
                               IOLink.ImageView inputKernelImage,
                               CorrelationByDifference2d.OffsetMode offsetMode = ImageDev.CorrelationByDifference2d.OffsetMode.OFFSET_1,
                               CorrelationByDifference2d.CorrelationMode correlationMode = ImageDev.CorrelationByDifference2d.CorrelationMode.DIRECT,
                               IOLink.ImageView outputImage = null,
                               CorrelationMsr outputMeasurement = null );

##
Class Syntax

    // Command constructor.
    CorrelationByDifference2d();

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

    /// Gets the inputKernelImage parameter.
    /// The correlation kernel.
    std::shared_ptr< iolink::ImageView > inputKernelImage() const;
    /// Sets the inputKernelImage parameter.
    /// The correlation kernel.
    void setInputKernelImage( std::shared_ptr< iolink::ImageView > inputKernelImage );

    /// Gets the offsetMode parameter.
    /// The calculation offset, in pixels. The greater this value, computation is faster but detection is less precise.
    CorrelationByDifference2d::OffsetMode offsetMode() const;
    /// Sets the offsetMode parameter.
    /// The calculation offset, in pixels. The greater this value, computation is faster but detection is less precise.
    void setOffsetMode( const CorrelationByDifference2d::OffsetMode& offsetMode );

    /// Gets the correlationMode parameter.
    /// The normalization mode for correlation.
    CorrelationByDifference2d::CorrelationMode correlationMode() const;
    /// Sets the correlationMode parameter.
    /// The normalization mode for correlation.
    void setCorrelationMode( const CorrelationByDifference2d::CorrelationMode& correlationMode );

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

    /// Gets the outputMeasurement parameter.
    /// The correlation matching results.
    CorrelationMsr::Ptr outputMeasurement() const;

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

    # Property of the inputImage parameter.
    CorrelationByDifference2d.input_image
    # Property of the inputKernelImage parameter.
    CorrelationByDifference2d.input_kernel_image
    # Property of the offsetMode parameter.
    CorrelationByDifference2d.offset_mode
    # Property of the correlationMode parameter.
    CorrelationByDifference2d.correlation_mode
    # Property of the outputImage parameter.
    CorrelationByDifference2d.output_image
    # Property of the outputMeasurement parameter.
    CorrelationByDifference2d.output_measurement

    // Method to launch the command.
    execute()

    // Command constructor.
    CorrelationByDifference2d()

    // Property of the inputImage parameter.
    CorrelationByDifference2d.inputImage
    // Property of the inputKernelImage parameter.
    CorrelationByDifference2d.inputKernelImage
    // Property of the offsetMode parameter.
    CorrelationByDifference2d.offsetMode
    // Property of the correlationMode parameter.
    CorrelationByDifference2d.correlationMode
    // Property of the outputImage parameter.
    CorrelationByDifference2d.outputImage
    // Property of the outputMeasurement parameter.
    CorrelationByDifference2d.outputMeasurement

    // Method to launch the command.
    Execute()

## Parameters

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| inputImage | The input grayscale image. | Image | Binary, Label or Grayscale | nullptr
| inputKernelImage | The correlation kernel. | Image | Binary, Label or Grayscale | nullptr
| offsetMode | The calculation offset, in pixels. The greater this value, computation is faster but detection is less precise.
OFFSET_1 | The correlation is computed with a step of 1.
OFFSET_2 | The correlation is computed with a step of 2.
OFFSET_4 | The correlation is computed with a step of 4.
OFFSET_8 | The correlation is computed with a step of 8.
| Enumeration |  | OFFSET_1
| correlationMode | The normalization mode for correlation.
DIRECT | Direct correlation (no normalization).
MEAN | Mean normalized correlation (luminosity).
VARIANCE | Variance normalized correlation (contrast).
MEAN_VARIANCE | Mean and variance normalized correlation (luminosity and contrast).
| Enumeration |  | DIRECT
| outputImage | The output correlation image. Its dimensions are forced to the same values as the input. Its data type is forced to floating point. | Image |  | nullptr
| outputMeasurement | The correlation matching results. | CorrelationMsr |  | nullptr

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| input_image | The input grayscale image. | image | Binary, Label or Grayscale | None
| input_kernel_image | The correlation kernel. | image | Binary, Label or Grayscale | None
| offset_mode | The calculation offset, in pixels. The greater this value, computation is faster but detection is less precise.
OFFSET_1 | The correlation is computed with a step of 1.
OFFSET_2 | The correlation is computed with a step of 2.
OFFSET_4 | The correlation is computed with a step of 4.
OFFSET_8 | The correlation is computed with a step of 8.
| enumeration |  | OFFSET_1
| correlation_mode | The normalization mode for correlation.
DIRECT | Direct correlation (no normalization).
MEAN | Mean normalized correlation (luminosity).
VARIANCE | Variance normalized correlation (contrast).
MEAN_VARIANCE | Mean and variance normalized correlation (luminosity and contrast).
| enumeration |  | DIRECT
| output_image | The output correlation image. Its dimensions are forced to the same values as the input. Its data type is forced to floating point. | image |  | None
| output_measurement | The correlation matching results. | CorrelationMsr |  | None

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| inputImage | The input grayscale image. | Image | Binary, Label or Grayscale | null
| inputKernelImage | The correlation kernel. | Image | Binary, Label or Grayscale | null
| offsetMode | The calculation offset, in pixels. The greater this value, computation is faster but detection is less precise.
OFFSET_1 | The correlation is computed with a step of 1.
OFFSET_2 | The correlation is computed with a step of 2.
OFFSET_4 | The correlation is computed with a step of 4.
OFFSET_8 | The correlation is computed with a step of 8.
| Enumeration |  | OFFSET_1
| correlationMode | The normalization mode for correlation.
DIRECT | Direct correlation (no normalization).
MEAN | Mean normalized correlation (luminosity).
VARIANCE | Variance normalized correlation (contrast).
MEAN_VARIANCE | Mean and variance normalized correlation (luminosity and contrast).
| Enumeration |  | DIRECT
| outputImage | The output correlation image. Its dimensions are forced to the same values as the input. Its data type is forced to floating point. | Image |  | null
| outputMeasurement | The correlation matching results. | CorrelationMsr |  | null

## Object Examples

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

    CorrelationByDifference2d correlationByDifference2dAlgo;
    correlationByDifference2dAlgo.setInputImage( polystyrene );
    correlationByDifference2dAlgo.setInputKernelImage( polystyrene );
    correlationByDifference2dAlgo.setOffsetMode( CorrelationByDifference2d::OffsetMode::OFFSET_1 );
    correlationByDifference2dAlgo.setCorrelationMode( CorrelationByDifference2d::CorrelationMode::DIRECT );
    correlationByDifference2dAlgo.execute();

    std::cout << "outputImage:" << correlationByDifference2dAlgo.outputImage()->toString();
    std::cout << "minComputed: " << correlationByDifference2dAlgo.outputMeasurement()->minComputed( 0 ) ;

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

    correlation_by_difference_2d_algo = imagedev.CorrelationByDifference2d()
    correlation_by_difference_2d_algo.input_image = polystyrene
    correlation_by_difference_2d_algo.input_kernel_image = polystyrene
    correlation_by_difference_2d_algo.offset_mode = imagedev.CorrelationByDifference2d.OFFSET_1
    correlation_by_difference_2d_algo.correlation_mode = imagedev.CorrelationByDifference2d.DIRECT
    correlation_by_difference_2d_algo.execute()

    print("output_image:", str(correlation_by_difference_2d_algo.output_image))
    print("minComputed: ", str(correlation_by_difference_2d_algo.output_measurement.min_computed(0)))

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

    CorrelationByDifference2d correlationByDifference2dAlgo = new CorrelationByDifference2d
    {
        inputImage = polystyrene,
        inputKernelImage = polystyrene,
        offsetMode = CorrelationByDifference2d.OffsetMode.OFFSET_1,
        correlationMode = CorrelationByDifference2d.CorrelationMode.DIRECT
    };
    correlationByDifference2dAlgo.Execute();

    Console.WriteLine( "outputImage:" + correlationByDifference2dAlgo.outputImage.ToString() );
    Console.WriteLine( "minComputed: " + correlationByDifference2dAlgo.outputMeasurement.minComputed( 0 ) );

## Function Examples

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

    auto result = correlationByDifference2d( polystyrene, polystyrene, CorrelationByDifference2d::OffsetMode::OFFSET_1, CorrelationByDifference2d::CorrelationMode::DIRECT );

    std::cout << "outputImage:" << result.outputImage->toString();
    std::cout << "minComputed: " << result.outputMeasurement->minComputed( 0 ) ;

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

    result_output_image, result_output_measurement = imagedev.correlation_by_difference_2d(polystyrene, polystyrene, imagedev.CorrelationByDifference2d.OFFSET_1, imagedev.CorrelationByDifference2d.DIRECT)

    print("output_image:", str(result_output_image))
    print("minComputed: ", str(result_output_measurement.min_computed(0)))

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

    Processing.CorrelationByDifference2dOutput result = Processing.CorrelationByDifference2d( polystyrene, polystyrene, CorrelationByDifference2d.OffsetMode.OFFSET_1, CorrelationByDifference2d.CorrelationMode.DIRECT );

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

© 2025 Thermo Fisher Scientific Inc. All rights reserved.