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

# Cooccurrence2d

Provides texture indicators, also known as Haralick features, based on the computation of co-occurrence matrix.
Access to parameter description
This algorithm provides some information regarding the texture by performing the computation of a co-occurrence matrix. It allows the classification of pairs of pixels by their gray level, along a directional offset $(dx,dy)$.
The co-occurrence matrix components are given by $$ M(i,j)=number\left(\{x,y\}/(I(x,y)=i)\cap(I(x+dx,y+dy)=j)\right) $$ where $I(x,y)$ is the image gray level for $(x,y)$ coordinates.
This formulation means that for a given pair $(i,j)$, $M(i,j)$ contains the number of pixels verifying $I(x,y)=i$ and $I(x+dx,y+dy)=j$.
This matrix is made symmetric and normalized such as $$ \forall(i,j),M(i,j)=M(j,i) ~\mbox{and} \sum_{i,j=1}^{N}M(i,j)=1 $$ These operations are independent of the image size and reveal some properties on a direction and its symmetry.
Thirteen indicators are computed from this matrix:

- An angular second moment indicator (ASM), also called uniformity. This indicator takes high values when image pixels present strong local uniformity. $$ ASM= \sum_{i,j=1}^{N}{M(i,j)}^2 $$
- A contrast indicator (Con). This indicator takes high values for great gray level variations. $$ Con= \sum_{i,j=1}^{N}M(i,j)\times(i-j)^2 $$
- A correlation indicator (Cor) which measures the dependency between gray levels and those of neighbouring pixels.
  $$ Cor= \sum_{i,j=1}^{N}M(i,j)\times\frac{(i-\mu)(j-\mu)}{\sigma^2} $$

where: $$ \mu=\sum_{i,j=1}^{N}i\times M(i,j) ~\mbox{and}~ \sigma^2=\sum_{i,j=1}^{N}M(i,j)\times(i-\mu)^2 $$

- A variance indicator (SSV) also called sum of squares. This indicator measures the dispersion of the combination of gray levels and their neighbor pixels around the mean. $$ SSV=\sigma=\sum_{i,j=1}^{N}M(i,j)\times(i-\mu)^2 $$
- An inverse difference moment (IDM) also called homogeneity $$ IDM= \sum_{i,j=1}^{N}\frac{M(i,j)}{1+(i-j)^2} $$
- A sum average indicator (SAv) $$ SAv=\sum_{i,j=1}^{N}M(i,j)\times(i+j) $$
- A sum variance indicator (SVa) $$ SVa=\sum_{i,j=1}^{N}M(i,j)\times(i+j-SAv)^2 $$
- A sum entropy indicator (SEn) $$ SEn=-\sum_{k=2}^{2N}M_{x+y}(k)\times log(M_{x+y}(k)) ~\mbox{where}~ M_{x+y}(k)=\sum_{i+j=k}M(i,j) $$
- An entropy indicator (Ent) $$ Ent=-\sum_{i,j=1}^{N}M(i,j)\times log(M(i,j)) $$
- A difference variance indicator (DVa) $$ DVa=variance(M_{x-y}) ~\mbox{where}~ M_{x-y}(k)=\sum_{|i-j|=k}M(i,j) $$
- A difference entropy indicator (DEn) $$ DEn=-\sum_{k=0}^{N-1}M_{x-y}(k)\times log(M_{x-y}(k)) $$
- Two information measurements of correlation (IC1 and IC2) $$ IC1=\frac{HXY-HXY1}{max(HX,HY)} ~\mbox{where}~ IC2=\sqrt{1-e^{-2\times|HXY2-HXY|}} $$

where HX and HY are entropies of $M_x$ and $M_y$ such as $$ M_x(i)=\sum_{j=1}^{N}M(i,j) ~\mbox{and}~ M_y(j)=\sum_{i=1}^{N}M(i,j) $$ and $$ HXY=-\sum_{i,j=1}^{N}M(i,j)\times log(M(i,j)) $$ $$ HXY1=-\sum_{i,j=1}^{N}M(i,j)\times log(M_x(i)\times M_y(j)) $$ $$ HXY2=-\sum_{i,j=1}^{N}M_x(i)\times M_y(j)\times log(M_x(i)\times M_y(j)) $$

In addition, this algorithm returns the number of image pixels used for computation in the result object.
References
R.Haralick , K.Shanmugam & I.Dinstein "Textural features for image classification". IEEE Transactions on Systems, Man, and Cybernetics. vol. 3, no. 6, pp 610-621, Oct. 1973.
See also

- IntensityStatistics
- SupervisedTextureClassification2d

##
Function Syntax

This function returns outputMeasurement.

    // Function prototype
    CoocurrrenceMsr::Ptr
    cooccurrence2d( std::shared_ptr< iolink::ImageView > inputImage,
                    std::shared_ptr< iolink::ImageView > inputMaskImage,
                    int32_t offsetX,
                    int32_t offsetY,
                    CoocurrrenceMsr::Ptr outputMeasurement = nullptr );

This function returns outputMeasurement.

    // Function prototype.
    cooccurrence_2d(input_image: idt.ImageType,
                    input_mask_image: idt.ImageType,
                    offset_x: int = 1,
                    offset_y: int = 0,
                    output_measurement: Union[Any, None] = None) -> CoocurrrenceMsr

This function returns outputMeasurement.

    // Function prototype.
    public static CoocurrrenceMsr
    Cooccurrence2d( IOLink.ImageView inputImage,
                    IOLink.ImageView inputMaskImage,
                    Int32 offsetX = 1,
                    Int32 offsetY = 0,
                    CoocurrrenceMsr outputMeasurement = null );

##
Class Syntax

    // Command constructor.
    Cooccurrence2d();

    /// 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 inputMaskImage parameter.
    /// The binary mask image where co-occurrence is computed. If it equals null, computations are performed on all pixels of the input image. This image must have the same dimensions as the input image.
    std::shared_ptr< iolink::ImageView > inputMaskImage() const;
    /// Sets the inputMaskImage parameter.
    /// The binary mask image where co-occurrence is computed. If it equals null, computations are performed on all pixels of the input image. This image must have the same dimensions as the input image.
    void setInputMaskImage( std::shared_ptr< iolink::ImageView > inputMaskImage );

    /// Gets the offsetX parameter.
    /// The X offset defining the co-occurrence vector.
    int32_t offsetX() const;
    /// Sets the offsetX parameter.
    /// The X offset defining the co-occurrence vector.
    void setOffsetX( const int32_t& offsetX );

    /// Gets the offsetY parameter.
    /// The Y offset defining the co-occurrence vector.
    int32_t offsetY() const;
    /// Sets the offsetY parameter.
    /// The Y offset defining the co-occurrence vector.
    void setOffsetY( const int32_t& offsetY );

    /// Gets the outputMeasurement parameter.
    /// The output measurement result object containing the haralick features.
    CoocurrrenceMsr::Ptr outputMeasurement() const;

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

    # Property of the inputImage parameter.
    Cooccurrence2d.input_image
    # Property of the inputMaskImage parameter.
    Cooccurrence2d.input_mask_image
    # Property of the offsetX parameter.
    Cooccurrence2d.offset_x
    # Property of the offsetY parameter.
    Cooccurrence2d.offset_y
    # Property of the outputMeasurement parameter.
    Cooccurrence2d.output_measurement

    // Method to launch the command.
    execute()

    // Command constructor.
    Cooccurrence2d()

    // Property of the inputImage parameter.
    Cooccurrence2d.inputImage
    // Property of the inputMaskImage parameter.
    Cooccurrence2d.inputMaskImage
    // Property of the offsetX parameter.
    Cooccurrence2d.offsetX
    // Property of the offsetY parameter.
    Cooccurrence2d.offsetY
    // Property of the outputMeasurement parameter.
    Cooccurrence2d.outputMeasurement

    // Method to launch the command.
    Execute()

## Parameters

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| inputImage | The input image. | Image | Binary, Label, Grayscale or Multispectral | nullptr
| inputMaskImage | The binary mask image where co-occurrence is computed. If it equals null, computations are performed on all pixels of the input image. This image must have the same dimensions as the input image. | Image | Binary | nullptr
| offsetX | The X offset defining the co-occurrence vector. | Int32 | Any value | 1
| offsetY | The Y offset defining the co-occurrence vector. | Int32 | Any value | 0
| outputMeasurement | The output measurement result object containing the haralick features. | CoocurrrenceMsr |  | nullptr

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| input_image | The input image. | image | Binary, Label, Grayscale or Multispectral | None
| input_mask_image | The binary mask image where co-occurrence is computed. If it equals null, computations are performed on all pixels of the input image. This image must have the same dimensions as the input image. | image | Binary | None
| offset_x | The X offset defining the co-occurrence vector. | int32 | Any value | 1
| offset_y | The Y offset defining the co-occurrence vector. | int32 | Any value | 0
| output_measurement | The output measurement result object containing the haralick features. | CoocurrrenceMsr |  | None

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| inputImage | The input image. | Image | Binary, Label, Grayscale or Multispectral | null
| inputMaskImage | The binary mask image where co-occurrence is computed. If it equals null, computations are performed on all pixels of the input image. This image must have the same dimensions as the input image. | Image | Binary | null
| offsetX | The X offset defining the co-occurrence vector. | Int32 | Any value | 1
| offsetY | The Y offset defining the co-occurrence vector. | Int32 | Any value | 0
| outputMeasurement | The output measurement result object containing the haralick features. | CoocurrrenceMsr |  | null

## Object Examples

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

    Cooccurrence2d cooccurrence2dAlgo;
    cooccurrence2dAlgo.setInputImage( polystyrene );
    cooccurrence2dAlgo.setInputMaskImage( polystyrene_mask );
    cooccurrence2dAlgo.setOffsetX( 1 );
    cooccurrence2dAlgo.setOffsetY( 0 );
    cooccurrence2dAlgo.execute();

    std::cout << "pixelCount: " << cooccurrence2dAlgo.outputMeasurement()->pixelCount( 0 ) ;

    polystyrene = ioformat.read_image(imagedev_data.get_image_path("polystyrene.tif"))
    polystyrene_mask = imagedev.read_vip_image(imagedev_data.get_image_path("polystyrene_mask.vip"))

    cooccurrence_2d_algo = imagedev.Cooccurrence2d()
    cooccurrence_2d_algo.input_image = polystyrene
    cooccurrence_2d_algo.input_mask_image = polystyrene_mask
    cooccurrence_2d_algo.offset_x = 1
    cooccurrence_2d_algo.offset_y = 0
    cooccurrence_2d_algo.execute()

    print("pixelCount: ", str(cooccurrence_2d_algo.output_measurement.pixel_count(0)))

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

    Cooccurrence2d cooccurrence2dAlgo = new Cooccurrence2d
    {
        inputImage = polystyrene,
        inputMaskImage = polystyrene_mask,
        offsetX = 1,
        offsetY = 0
    };
    cooccurrence2dAlgo.Execute();

    Console.WriteLine( "pixelCount: " + cooccurrence2dAlgo.outputMeasurement.pixelCount( 0 ) );

## Function Examples

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

    auto result = cooccurrence2d( polystyrene, polystyrene_mask, 1, 0 );

    std::cout << "pixelCount: " << result->pixelCount( 0 ) ;

    polystyrene = ioformat.read_image(imagedev_data.get_image_path("polystyrene.tif"))
    polystyrene_mask = imagedev.read_vip_image(imagedev_data.get_image_path("polystyrene_mask.vip"))

    result = imagedev.cooccurrence_2d(polystyrene, polystyrene_mask, 1, 0)

    print("pixelCount: ", str(result.pixel_count(0)))

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

    CoocurrrenceMsr result = Processing.Cooccurrence2d( polystyrene, polystyrene_mask, 1, 0 );

    Console.WriteLine(  "pixelCount: " + result.pixelCount( 0 )  );

© 2025 Thermo Fisher Scientific Inc. All rights reserved.