Global Analysis

This example shows how to extract global measurements from an image.

First, this example applies the IntensityStatistics algorithm on a color input image. It computes several statistics from the input image intensities. Each color channel is processed as a separate image and the example shows how to access to the result of each channel. Results are printed in the standard output.

Computing color intensity statistics...
- Average intensity [R, G, B] = [197.06, 186.25, 181.10]
- Standard Deviation = [R, G, B] = [10.05, 16.00, 7.79]
- Red intensity range = [151, 212]
- Green intensity range = [0, 207]
- Blue intensity range = [124, 197]

Note: Two indexes must be provided to access to each statistics result. The first index refers to the channel in case of a color or multi-channel input, like in this example. The second is unused here and refers to the time step in case of a time series input.

Then, the color image is binarized with the ColorThresholding algorithm. The total area occupied by the phase between thresholds is given by the Area2d algorithm. The number of detected objects is computed with the ObjectCount algorithm.

Color thresholding and binary analysis...
- Total area of detected objects = 46256
- Phase fraction of detected objects = 17.71 %
- Number of detected objects = 65

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

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

int
main()
{
    // ImageDev library initialization
    if ( isInitialized() == false )
        imagedev::init();

    // Open a tif file to analyze
    auto imageInput = ioformat::readImage( std::string( IMAGEDEVDATA_IMAGES_FOLDER ) + "micro_nucleus.tif" );

    // Extract intensity statistics from an RGB image
    std::cout << "Computing color intensity statistics... " << std::endl;
    auto statistics = intensityStatistics( imageInput, IntensityStatistics::RangeMode::MIN_MAX, { 0, 255 } );
    std::cout << "  - Average intensity [R, G, B] = [" << statistics->mean( 0, 0 ) << ", " << statistics->mean( 1, 0 )
              << ", " << statistics->mean( 2, 0 ) << "]" << std::endl;
    std::cout << "  - Standard Deviation = [R, G, B] = [" << statistics->standardDeviation( 0, 0 ) << ", "
              << statistics->standardDeviation( 1, 0 ) << ", " << statistics->standardDeviation( 2, 0 ) << "]"
              << std::endl;
    std::cout << "  - Red intensity range = [" << statistics->minimum( 0, 0 ) << ", " << statistics->maximum( 0, 0 )
              << "]" << std::endl;
    std::cout << "  - Green intensity range = [" << statistics->minimum( 1, 0 ) << ", " << statistics->maximum( 1, 0 )
              << "]" << std::endl;
    std::cout << "  - Blue intensity range = [" << statistics->minimum( 2, 0 ) << ", " << statistics->maximum( 2, 0 )
              << "]" << std::endl;

    // Threshold image pixels having an intensity lower than 190 in each RGB channel
    std::cout << "Color thresholding and binary analysis... " << std::endl;
    auto imageOutput = colorThresholding( imageInput, { 0, 190 }, { 0, 190 }, { 0, 190 } );

    // Measure the object area
    auto area = area2d( imageOutput );
    std::cout << "  - Total area of detected objects = " << area->area( 0 ) << std::endl;
    std::cout << "  - Phase fraction of detected objects = " << ( 100.0 * area->areaFraction( 0 ) ) << " %"
              << std::endl;

    // Count the number of detected objects
    auto count = objectCount( imageOutput );
    std::cout << "  - Number of detected objects = " << count.outputMeasurement->count( 0 ) << std::endl;
    // Rescale binary the image intensities between 0 and 255 for visualization
    // and save it
    imageOutput = rescaleIntensity( imageOutput,
                                    RescaleIntensity::OutputType::UNSIGNED_INTEGER_8_BIT,
                                    RescaleIntensity::RangeMode::MIN_MAX,
                                    { 2, 98 },
                                    { 0, 255 },
                                    { 0, 255 } );
    ioformat::writeView( imageInput, R"(T04_01_output.png)" );

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

    return 0;
}

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

namespace T04_01_GlobalAnalysis
{
    class Program
    {
        static void Main( string[] args )
        {
            // Initialize the ImageDev library if not done
            if ( Initialization.IsInitialized() == false )
                Initialization.Init();

            // Open a tif file to analyze
            ImageView imageInput = ViewIO.ReadImage( @"Data/images/micro_nucleus.tif" ) as ImageView;

            // Extract intensity statistics from an RGB image
            Console.WriteLine( "Computing color intensity statistics... " );
            var statistics = Processing.IntensityStatistics( imageInput );
            Console.WriteLine( "  - Average intensity [R, G, B] = [" + statistics.mean( 0, 0 ).ToString( "0.00" ) +
                               ", " + statistics.mean( 1, 0 ).ToString( "0.00" ) + ", " +
                               statistics.mean( 2, 0 ).ToString( "0.00" ) + "]" );
            Console.WriteLine( "  - Standard Deviation = [R, G, B] = [" +
                               statistics.standardDeviation( 0, 0 ).ToString( "0.00" ) + ", " +
                               statistics.standardDeviation( 1, 0 ).ToString( "0.00" ) + ", " +
                               statistics.standardDeviation( 2, 0 ).ToString( "0.00" ) + "]" );
            Console.WriteLine( "  - Red intensity range = [" + statistics.minimum( 0, 0 ) + ", " +
                               statistics.maximum( 0, 0 ) + "]" );
            Console.WriteLine( "  - Green intensity range = [" + statistics.minimum( 1, 0 ) + ", " +
                               statistics.maximum( 1, 0 ) + "]" );
            Console.WriteLine( "  - Blue intensity range = [" + statistics.minimum( 2, 0 ) + ", " +
                               statistics.maximum( 2, 0 ) + "]" );

            // Threshold image pixels having an intensity lower than 190 in each RGB channel
            Console.WriteLine( "Color thresholding and binary analysis... " );
            var imageOutput = Processing.ColorThresholding(
                imageInput, new double[] { 0, 190 }, new double[] { 0, 190 }, new double[] { 0, 190 } );

            // Measure the object area
            var area = Processing.Area2d( imageOutput );
            Console.WriteLine( "  - Total area of detected objects = " + area.area( 0 ) );
            Console.WriteLine( "  - Phase fraction of detected objects = " +
                               ( 100.0 * area.areaFraction( 0 ) ).ToString( "0.00" ) + " %" );

            // Count the number of detected objects
            var count = Processing.ObjectCount( imageOutput );
            Console.WriteLine( "  - Number of detected objects = " + count.outputMeasurement.count( 0 ) );
            // Rescale binary the image intensities between 0 and 255 for visualization and save it
            imageOutput =
                Processing.RescaleIntensity( imageOutput, RescaleIntensity.OutputType.UNSIGNED_INTEGER_8_BIT );
            ViewIO.WriteView( imageOutput, @"T04_01_output.png" );

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

            // ImageDev library finalization
            Initialization.Finish();
        }
    }
}

import imagedev
import imagedev_data
import ioformat

# Initialize the ImageDev library if not done
if (imagedev.is_initialized() == False): imagedev.init()

# Open a tif file to analyze
image_input = ioformat.read_image(imagedev_data.get_image_path("micro_nucleus.tif"))

# Extract intensity statistics from an RGB image
print("Computing color intensity statistics... ")
statistics = imagedev.intensity_statistics(image_input)
print("  - Average intensity [R, G, B] = [" + "{:.2f}".format(statistics.mean(0, 0)) + ", " +
			"{:.2f}".format(statistics.mean(1, 0)) + ", " +
			"{:.2f}".format(statistics.mean(2, 0))  + "]")
print("  - Standard Deviation = [R, G, B] = [" +
			"{:.2f}".format(statistics.standard_deviation(0, 0)) + ", " +
			"{:.2f}".format(statistics.standard_deviation(1, 0)) + ", " +
			"{:.2f}".format(statistics.standard_deviation(2, 0)) + "]")
print("  - Red intensity range = [" + str(statistics.minimum(0, 0)) + ", " + str(statistics.maximum(0, 0)) + "]")
print("  - Green intensity range = [" + str(statistics.minimum(1, 0)) + ", " + str(statistics.maximum(1, 0)) + "]")
print("  - Blue intensity range = [" + str(statistics.minimum(2, 0)) + ", " + str(statistics.maximum(2, 0)) + "]")

# Threshold image pixels having an intensity lower than 190 in each RGB channel
print("Color thresholding and binary analysis... ")
image_output = imagedev.color_thresholding( image_input, [0, 190], [0, 190], [0, 190])

# Measure the object area
area = imagedev.area_2d(image_output)
print("  - Total area of detected objects = " + str(area.area(0)))
print("  - Phase fraction of detected objects = " + "{:.2f}".format(100.0 * area.area_fraction(0)) + " %")

# Count the number of detected objects
count = imagedev.object_count(image_output)
print("  - Number of detected objects = " + str(count[1].count(0)))
# Rescale binary the image intensities between 0 and 255 for visualization and save it
image_output = imagedev.rescale_intensity(image_output, imagedev.RescaleIntensity.UNSIGNED_INTEGER_8_BIT)
ioformat.write_view(image_output, "T04_01_output.png")

# ImageDev library finalization
imagedev.finish()

See also