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

# CorrelationBySignChange2d

Performs a correlation by sign change 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 sign change metric between a gray level image $I$ and a gray level kernel $K$, returning the correlation image $O$.
$S$ is the sign change criterion performed on the difference image. It corresponds to the number of sign changes calculated on every line.
Figure 1. Example of sign correlation
The object in the model and the object in the image have luminosity, contrast, and noise differences. After normalization depending on the correlation type, the sign change criterion is applied on the difference image. The noise is supposed to be additive and zero mean. The statistical density function of the noise is supposed to be symmetrical. The best matching will correspond to the maximum number of sign changes.
This correlation gives very good results with big kernels. It was created for medical applications where images are often very noisy.
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 2. 1D image and kernel
The 6 examples show the kernel appearing with different contrast and luminosity.
Figure 3. Examples of possible 1D correlation
The correlation by sign change metric is computed in accordance with the CorrelationMode parameter.

### DIRECT Correlation Mode

$$ O(n,m)=\sum_{i=1}^{kx} \sum_{j=1}^{ky} S\left[K(i,j)-I(n+i-\frac{kx}{2},m+j-\frac{ky}{2})\right] $$

### MEAN Correlation Mode

$$ O(n,m)=\sum_{i=1}^{kx} \sum_{j=1}^{ky} S\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] $$

### VARIANCE Correlation Mode

$$ O(n,m)=\frac{\sum\limits_{i=1}^{kx} \sum\limits_{j=1}^{ky} S\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)}} $$

### MEAN_VARIANCE Correlation Mode

$$ O(n,m)=\frac{\sum\limits_{i=1}^{kx} \sum\limits_{j=1}^{ky} S\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)}} $$
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
- CorrelationByDifference2d
- LocalMaxima2d

##
Function Syntax

This function returns a CorrelationBySignChange2dOutput structure containing outputImage and outputMeasurement.

    // Output structure of the correlationBySignChange2d function.
    struct CorrelationBySignChange2dOutput
    {
        /// 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
    CorrelationBySignChange2dOutput
    correlationBySignChange2d( std::shared_ptr< iolink::ImageView > inputImage,
                               std::shared_ptr< iolink::ImageView > inputKernelImage,
                               CorrelationBySignChange2d::OffsetMode offsetMode,
                               CorrelationBySignChange2d::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_sign_change_2d(input_image: idt.ImageType,
                                  input_kernel_image: idt.ImageType,
                                  offset_mode: CorrelationBySignChange2d.OffsetMode = CorrelationBySignChange2d.OffsetMode.OFFSET_1,
                                  correlation_mode: CorrelationBySignChange2d.CorrelationMode = CorrelationBySignChange2d.CorrelationMode.DIRECT,
                                  output_image: idt.ImageType = None,
                                  output_measurement: Union[Any, None] = None) -> Tuple[idt.ImageType, CorrelationMsr]

This function returns a CorrelationBySignChange2dOutput structure containing outputImage and outputMeasurement.

    /// Output structure of the CorrelationBySignChange2d function.
    public struct CorrelationBySignChange2dOutput
    {
        ///
        /// 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 CorrelationBySignChange2dOutput
    CorrelationBySignChange2d( IOLink.ImageView inputImage,
                               IOLink.ImageView inputKernelImage,
                               CorrelationBySignChange2d.OffsetMode offsetMode = ImageDev.CorrelationBySignChange2d.OffsetMode.OFFSET_1,
                               CorrelationBySignChange2d.CorrelationMode correlationMode = ImageDev.CorrelationBySignChange2d.CorrelationMode.DIRECT,
                               IOLink.ImageView outputImage = null,
                               CorrelationMsr outputMeasurement = null );

##
Class Syntax

    // Command constructor.
    CorrelationBySignChange2d();

    /// 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.
    CorrelationBySignChange2d::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 CorrelationBySignChange2d::OffsetMode& offsetMode );

    /// Gets the correlationMode parameter.
    /// The normalization mode for correlation.
    CorrelationBySignChange2d::CorrelationMode correlationMode() const;
    /// Sets the correlationMode parameter.
    /// The normalization mode for correlation.
    void setCorrelationMode( const CorrelationBySignChange2d::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.
    CorrelationBySignChange2d.input_image
    # Property of the inputKernelImage parameter.
    CorrelationBySignChange2d.input_kernel_image
    # Property of the offsetMode parameter.
    CorrelationBySignChange2d.offset_mode
    # Property of the correlationMode parameter.
    CorrelationBySignChange2d.correlation_mode
    # Property of the outputImage parameter.
    CorrelationBySignChange2d.output_image
    # Property of the outputMeasurement parameter.
    CorrelationBySignChange2d.output_measurement

    // Method to launch the command.
    execute()

    // Command constructor.
    CorrelationBySignChange2d()

    // Property of the inputImage parameter.
    CorrelationBySignChange2d.inputImage
    // Property of the inputKernelImage parameter.
    CorrelationBySignChange2d.inputKernelImage
    // Property of the offsetMode parameter.
    CorrelationBySignChange2d.offsetMode
    // Property of the correlationMode parameter.
    CorrelationBySignChange2d.correlationMode
    // Property of the outputImage parameter.
    CorrelationBySignChange2d.outputImage
    // Property of the outputMeasurement parameter.
    CorrelationBySignChange2d.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" );

    CorrelationBySignChange2d correlationBySignChange2dAlgo;
    correlationBySignChange2dAlgo.setInputImage( polystyrene );
    correlationBySignChange2dAlgo.setInputKernelImage( polystyrene );
    correlationBySignChange2dAlgo.setOffsetMode( CorrelationBySignChange2d::OffsetMode::OFFSET_1 );
    correlationBySignChange2dAlgo.setCorrelationMode( CorrelationBySignChange2d::CorrelationMode::DIRECT );
    correlationBySignChange2dAlgo.execute();

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

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

    correlation_by_sign_change_2d_algo = imagedev.CorrelationBySignChange2d()
    correlation_by_sign_change_2d_algo.input_image = polystyrene
    correlation_by_sign_change_2d_algo.input_kernel_image = polystyrene
    correlation_by_sign_change_2d_algo.offset_mode = imagedev.CorrelationBySignChange2d.OFFSET_1
    correlation_by_sign_change_2d_algo.correlation_mode = imagedev.CorrelationBySignChange2d.DIRECT
    correlation_by_sign_change_2d_algo.execute()

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

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

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

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

## Function Examples

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

    auto result = correlationBySignChange2d( polystyrene, polystyrene, CorrelationBySignChange2d::OffsetMode::OFFSET_1, CorrelationBySignChange2d::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_sign_change_2d(polystyrene, polystyrene, imagedev.CorrelationBySignChange2d.OFFSET_1, imagedev.CorrelationBySignChange2d.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.CorrelationBySignChange2dOutput result = Processing.CorrelationBySignChange2d( polystyrene, polystyrene, CorrelationBySignChange2d.OffsetMode.OFFSET_1, CorrelationBySignChange2d.CorrelationMode.DIRECT );

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

© 2025 Thermo Fisher Scientific Inc. All rights reserved.