FragmentationIndex

Computes an index of relative convexity or concavity of the surface of objects from a binary image.

Access to parameter description

For an introduction:

• section Image Analysis
• section Morphometry

This algorithm computes an indicator of connectivity. It calculates an index of relative convexity or concavity of the surface.
This index can be interpreted in mater of connectivity taken into account that concavity indicates connectivity, and that convexity indicates isolated disconnected structures.

The fragmentation index is calculated by comparing:

• Area $Ar$ and perimeter $P$ for a 2D image
• Volume $V$ and surface $S$ for a 3D image

The fragmentation $FI$ is computed on a binarized image before and after an image dilation.

• In 2D, it defined as: $$ FI = \frac{P_d-P}{Ar_d-Ar} $$
• In 3D, it defined as: $$ FI = \frac{S_d-S}{V_d-V} $$

where

• $P$ and $Ar$ are respectively the object perimeter and area.
• $S$ and $V$ are respectively the object surface and volume.
• The subscript $d$ means 'after dilation'.

Dilation of an highly connected area narrows spaces and then produces a smaller perimeter. On the other hand, it expands the perimeter of open ends or nodes. Consequently, a low fragmentation index signifies better connected area while a high fragmentation index means a more disconnected structure. In some cases, a high ratio of enclosed cavities and concave surfaces can result in a negative fragmentation index.

See also

• StructureModelIndex3d
• AverageObjectThickness3d
• ObjectLinearDensity3d

// Function prototype.
FragmentationMsr::Ptr
fragmentationIndex( std::shared_ptr< iolink::ImageView > inputBinaryImage,
                    int32_t kernelRadius,
                    FragmentationMsr::Ptr outputMeasurement = NULL );

// Function prototype.
fragmentation_index( input_binary_image, kernel_radius = 3, output_measurement = None )

// Function prototype.
public static FragmentationMsr
FragmentationIndex( IOLink.ImageView inputBinaryImage,
                    Int32 kernelRadius = 3,
                    FragmentationMsr outputMeasurement = null );

// Command constructor.
FragmentationIndex();

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

// Get method of the kernelRadius parameter.
int32_t kernelRadius() const;
// Set method of the kernelRadius parameter.
void setKernelRadius( const int32_t& kernelRadius );

// Get method of the outputMeasurement parameter.
FragmentationMsr::Ptr outputMeasurement() const;

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

// Property of the inputBinaryImage parameter.
FragmentationIndex.input_binary_image
// Property of the kernelRadius parameter.
FragmentationIndex.kernel_radius
// Property of the outputMeasurement parameter.
FragmentationIndex.output_measurement

// Method to launch the command.
execute()

// Command constructor.
FragmentationIndex()

// Property of the inputBinaryImage parameter.
FragmentationIndex.inputBinaryImage
// Property of the kernelRadius parameter.
FragmentationIndex.kernelRadius
// Property of the outputMeasurement parameter.
FragmentationIndex.outputMeasurement

// Method to launch the command.
Execute()

auto polystyrene_sep = readVipImage( std::string( IMAGEDEVDATA_IMAGES_FOLDER ) + "polystyrene_sep.vip" );

FragmentationIndex fragmentationIndexAlgo;
fragmentationIndexAlgo.setInputBinaryImage( polystyrene_sep );
fragmentationIndexAlgo.setKernelRadius( 3 );
fragmentationIndexAlgo.execute();

std::cout << "index: " << fragmentationIndexAlgo.outputMeasurement()->index( 0 ) ;

polystyrene_sep = imagedev.read_vip_image(imagedev_data.get_image_path("polystyrene_sep.vip"))

fragmentation_index_algo = imagedev.FragmentationIndex()
fragmentation_index_algo.input_binary_image = polystyrene_sep
fragmentation_index_algo.kernel_radius = 3
fragmentation_index_algo.execute()

print( 
print("index: ", fragmentation_index_algo.output_measurement.index( 0 ) ) );

ImageView polystyrene_sep = Data.ReadVipImage( @"Data/images/polystyrene_sep.vip" );

FragmentationIndex fragmentationIndexAlgo = new FragmentationIndex
{
    inputBinaryImage = polystyrene_sep,
    kernelRadius = 3
};
fragmentationIndexAlgo.Execute();

Console.WriteLine( "index: " + fragmentationIndexAlgo.outputMeasurement.index( 0 ) );

auto polystyrene_sep = readVipImage( std::string( IMAGEDEVDATA_IMAGES_FOLDER ) + "polystyrene_sep.vip" );

auto result = fragmentationIndex( polystyrene_sep, 3 );

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

polystyrene_sep = imagedev.read_vip_image(imagedev_data.get_image_path("polystyrene_sep.vip"))

result = imagedev.fragmentation_index( polystyrene_sep, 3 )

print( "index: ", result.index( 0 ) );

ImageView polystyrene_sep = Data.ReadVipImage( @"Data/images/polystyrene_sep.vip" );

FragmentationMsr result = Processing.FragmentationIndex( polystyrene_sep, 3 );

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