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_i)(i-\mu_j)}{\sqrt{\sigma_i^2\sigma_j^2}} $$
where: $$ \mu_i=\mu_j=\sum_{i,j=1}^{N}i\times M(i,j) ~\mbox{and}~ \sigma_i^2=\sigma_j^2=\sum_{i,j=1}^{N}M(i,j)\times(i-\mu_i)^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_i^2=\sigma_j^2=\sum_{i,j=1}^{N}M(i,j)\times(i-\mu_i)^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}p_{x+y}(k)\times log(p_{x+y}(k)) ~\mbox{where}~ p_{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(p_{x-y}) ~\mbox{where}~ p_{x-y}(k)=\sum_{|i-j|=k}M(i,j) $$
• A difference entropy indicator (DEn) $$ DEn=-\sum_{k=0}^{N-1}p_{x-y}(k)\times log(p_{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 px and py such as $$ p_x(i)=\sum_{j=1}^{N}M(i,j) ~\mbox{and}~ p_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(p_x(i)\times p_y(j)) $$ $$ HXY2=-\sum_{i,j=1}^{N}p_x(i)\times p_y(j)\times log(p_x(i)\times p_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 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 = NULL );

// Function prototype.
cooccurrence_2d( input_image,
                 input_mask_image,
                 offset_x = 1,
                 offset_y = 0,
                 output_measurement = None )

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

// Command constructor.
Cooccurrence2d();

// Get method of the inputImage parameter.
std::shared_ptr< iolink::ImageView > inputImage() const;
// Set method of the inputImage parameter.
void setInputImage( std::shared_ptr< iolink::ImageView > inputImage );

// Get method of the inputMaskImage parameter.
std::shared_ptr< iolink::ImageView > inputMaskImage() const;
// Set method of the inputMaskImage parameter.
void setInputMaskImage( std::shared_ptr< iolink::ImageView > inputMaskImage );

// Get method of the offsetX parameter.
int32_t offsetX() const;
// Set method of the offsetX parameter.
void setOffsetX( const int32_t& offsetX );

// Get method of the offsetY parameter.
int32_t offsetY() const;
// Set method of the offsetY parameter.
void setOffsetY( const int32_t& offsetY );

// Get method of the outputMeasurement parameter.
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()

std::shared_ptr< iolink::ImageView > 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( 
print("pixelCount: ", 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 ) );

std::shared_ptr< iolink::ImageView > 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: ", 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 )  );