ImageDev

Measurement Group

This example shows how to save a set of measurements in a file and reload it afterwards.
It may be useful to let a user of your application select a subset of measurements from all ImageDev measurements and allow him to recall this list each time the application is restarted.

In this case, you must store this list of measurements in a file and reload it when your application restarts.

This example simulates this situation and demonstrates that an analysis can be calculated from a saved list of measurements. 

#include <ImageDev/ImageDev.h>
#include <ioformat/IOFormat.h>
#include <string.h>

using namespace imagedev;
using namespace ioformat;
using namespace iolink;

int
main( int argc, char* argv[] )
{
    int status = 0;

    try
    {
        // ImageDev library initialization if not done
        if ( isInitialized() == false )
            imagedev::init();

        // Open a grayscale image from a tif file
        auto imageInput = readImage( std::string( IMAGEDEVDATA_IMAGES_FOLDER ) + "objects.tif" );

        // Threshold and label the binary input
        auto imageBin = thresholdingByCriterion( imageInput,
                                                 ThresholdingByCriterion::ComparisonCriterion::GREATER_THAN_OR_EQUAL_TO,
                                                 40 );
        auto imageLab = labeling2d( imageBin, Labeling2d::LABEL_8_BIT, Labeling2d::CONNECTIVITY_8 );

        // Create a group of measurements
        MeasurementGroup::Ptr group = std::make_shared< MeasurementGroup >();
        group->add( NativeMeasurements::inverseCircularity2d );
        group->add( NativeMeasurements::feretDiameter2d );

        // Save this group and reload it
        group->write( "T04_04_group.xml" );
        MeasurementGroup::Ptr saved_group = std::make_shared< MeasurementGroup >();
        saved_group->read( "T04_04_group.xml" );

        // Define the analysis features to be computed
        AnalysisMsr::Ptr analysis = std::make_shared< AnalysisMsr >();
        analysis->select( saved_group->getMeasurements() );

        // Launch the feature extraction on the segmented image
        labelAnalysis( imageLab, imageInput, analysis );

        // Export the analysis in a dataframe and save it in a csv file
        auto dataframe = analysis->toDataFrame();
        writeView( dataframe, "T04_04_analysis.csv" );

        std::cout << "This example ran successfully." << std::endl;
    }
    catch ( const imagedev::Exception& error )
    {
        // Print potential exception in the standard output
        std::cerr << "T04_04_MeasurementGroup exception: " << error.what() << std::endl;
        status = -1;
    }

    // ImageDev library finalization
    imagedev::finish();

    // Check if we must ask for an enter key to close the program
    if ( !( ( argc == 2 ) && strcmp( argv[1], "--no-stop-at-end" ) == 0 ) )
        std::cout << "Press Enter key to close this window." << std::endl, getchar();

    return status;
}

using System;
using ImageDev;
using IOLink;
using IOFormat;

namespace T04_04_MeasurementGroup
{
    class Program
    {
        static void Main( string[] args )
        {
            int status = 0;

            try
            {
                // Initialize the ImageDev library if not done
                if ( Initialization.IsInitialized() == false )
                    Initialization.Init();

                // Open a grayscale image from a tif file
                ImageView imageInput = ViewIO.ReadImage( "Data/images/objects.tif" );

                // Threshold and label the binary input
                var imageBin = Processing.ThresholdingByCriterion(
                    imageInput, ThresholdingByCriterion.ComparisonCriterion.GREATER_THAN_OR_EQUAL_TO, 40 );
                var imageLab = Processing.Labeling2d( imageBin );

                // Create a group of measurements
                MeasurementGroup group = new MeasurementGroup();
                group.Add( NativeMeasurements.InverseCircularity2d );
                group.Add( NativeMeasurements.FeretDiameter2d );

                // Save this group and reload it
                group.Write( "T04_04_group.xml" );
                MeasurementGroup saved_group = new MeasurementGroup();
                saved_group.Read( "T04_04_group.xml" );

                // Define the analysis features to be computed
                AnalysisMsr analysis = new AnalysisMsr();
                analysis.Select( saved_group.GetMeasurements() );

                // Launch the feature extraction on the segmented image
                Processing.LabelAnalysis( imageLab, imageInput, analysis );

                // Export the analysis in a dataframe and save it in a csv file
                DataFrameView dataframe = analysis.ToDataFrame();
                ViewIO.WriteView( dataframe, "T04_04_analysis.csv" );

                // Notify the garbage collector that the created images can be freed
                imageInput.Dispose();
                imageBin.Dispose();
                imageLab.Dispose();

                Console.WriteLine( "This example ran successfully." );
            }
            catch ( Exception error )
            {
                // Print potential exception in the standard output
                System.Console.WriteLine( "T04_04_MeasurementGroup exception: " + error.ToString() );
                status = -1;
            }

            // ImageDev library finalization
            Initialization.Finish();

            // Check if we must ask for an enter key to close the program
            if ( !( ( args.Length >= 1 ) && ( args[0] == "--no-stop-at-end" ) ) )
            {
                System.Console.WriteLine( "Press Enter key to close this window." );
                System.Console.ReadKey();
            }

            System.Environment.Exit( status );
        }
    }
}

import imagedev
import imagedev_data
import ioformat

try:
    # Open a grayscale image from a tif file
    image_input = ioformat.read_image(imagedev_data.get_image_path('objects.tif'))

    # Threshold and label the binary input
    image_bin = imagedev.thresholding_by_criterion(image_input, comparison_value=40)
    image_lab = imagedev.labeling_2d(image_bin, imagedev.Labeling2d.LabelType.LABEL_8_BIT)

    # Create a group of measurements
    group = imagedev.MeasurementGroup()
    group.add(imagedev.native_measurements.InverseCircularity2d)
    group.add(imagedev.native_measurements.FeretDiameter2d)

    # Save this group and reload it
    group.write('T04_04_group.xml')
    saved_group = imagedev.MeasurementGroup()
    saved_group.read('T04_04_group.xml')

    # Define an analysis with the features of the group
    analysis = imagedev.AnalysisMsr()
    analysis.select(saved_group)

    # Launch the feature extraction on the segmented image
    imagedev.label_analysis(image_lab, image_input, analysis)

    # Print the analysis in the standard output
    print(analysis.to_data_frame())

    print("This example ran successfully.")
except Exception as error:
    # Print potential exception in the standard output
    print("T04_04_MeasurementGroup exception: " + str(error))


See also