ImageDev

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>
#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 ( 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, "T04_01_output.png" );

        std::cout << "This example ran successfully." << std::endl;
    }
    catch ( const imagedev::Exception& error )
    {
        // Print potential exception in the standard output
        std::cerr << "ImageDev 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_01_GlobalAnalysis
{
    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 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();

            }
            catch (Exception error)
            {
                // Print potential exception in the standard output
                System.Console.WriteLine("HelloImageDev 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

# 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")


See also