ImageFormula

Computes a new image by applying a user-defined formula on one, two, or three input images.

Access to parameter description

The formula used by this algorithm must be written in accordance with the custom formula syntax. The validity of the formula can be verified with the checkImageFormula method.
Some of the examples below can be implemented with an existing algorithm. In these cases, using the appropriate native algorithm will be more efficient in terms of performance.

Basic usage

This algorithm accepts three input images that are referenced as I1, I2 and I3 in the formula. Images two and three are optional and must be provided only if referenced in the formula.

For instance, the formula "if(I2==25, I1, 0)" masks an input gray level image I1 with the blob of intensity 25 in a label image I2, as shown in Figure 1.

Usage with kernels

Functions with a variable number of arguments such as min, max, avg, median, sum and product can be used in two ways :

• To combine images, for instance "min(I1, I2)"
• To compute kernel operations : "min(I1[7, 7])"

Kernels can be defined for these functions with the following syntax: IN[x,y] in the 2D case and IN[x,y,z] in the 3D case.
Where:

• N is the index of the related image (N $\in$ [1 .. 3]).
• x,y and z correspond to the expected kernel size.

Thus, f(IN[x,y]) represents a sliding window of size x$\times$y, centered on each pixel of the image IN, on which the operator f is applied.
For instance, the formula "avg(I1[7, 7])" filters an image I1 by a box filter of size 7x7, as shown in Figure 2.

Usage with offsets

Image offset can be defined in formula respecting the following syntax : IN(x,y) in the 2D case and IN(x,y,z) in the 3D case.
Where:

• N is the index of the related image (N $\in$ [1 .. 3]).
• x,y and z correspond to the offsets from the central current pixel.

Remark: Symbols IN and IN(0,0) are strictly equivalent.

These offsets can be used to compute operations depending on pixels surrounding the current pixel to process.

For instance, a basic horizontal gradient operation can be written "I1(1, 0) - I1(-1, 0)", as shown in Figure 3.

Usage of image coordinates

Image coordinates can be used in a formula: x, y and z represent the current pixel coordinates, ox, oy and oz the image origin and gx, gy and gz the image dimensions.

For instance, these coordinates can be used to generate synthetic images. A basic line separation can be written as "if (3x-100 < y, 100, 0)", as shown in Figure 4.


Coordinates also can be used to handle more complex cases such as "if ((x-(ox+gx)/2)*(x-(ox+gx)/2)+(y-(oy+gy)/2)*(y-(oy+gy)/2) < 5050, I1, I2)", as shown in Figure 5.



See also

• ArithmeticOperationWithImage

// Function prototype.
std::shared_ptr< iolink::ImageView >
imageFormula( std::shared_ptr< iolink::ImageView > inputImage1,
              std::shared_ptr< iolink::ImageView > inputImage2,
              std::shared_ptr< iolink::ImageView > inputImage3,
              std::string formula,
              ImageFormula::OutputType outputType,
              std::shared_ptr< iolink::ImageView > outputImage = NULL );

// Function prototype.
image_formula( input_image1,
               input_image2,
               input_image3,
               formula = "",
               output_type = ImageFormula.OutputType.UNSIGNED_INTEGER_8_BIT,
               output_image = None )

// Function prototype.
public static IOLink.ImageView
ImageFormula( IOLink.ImageView inputImage1,
              IOLink.ImageView inputImage2,
              IOLink.ImageView inputImage3,
              string formula = "",
              ImageFormula.OutputType outputType = ImageDev.ImageFormula.OutputType.UNSIGNED_INTEGER_8_BIT,
              IOLink.ImageView outputImage = null );

// Command constructor.
ImageFormula();

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

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

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

// Get method of the formula parameter.
std::string formula() const;
// Set method of the formula parameter.
void setFormula( const std::string& formula );

// Get method of the outputType parameter.
ImageFormula::OutputType outputType() const;
// Set method of the outputType parameter.
void setOutputType( const ImageFormula::OutputType& outputType );

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

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

// Property of the inputImage1 parameter.
ImageFormula.input_image1
// Property of the inputImage2 parameter.
ImageFormula.input_image2
// Property of the inputImage3 parameter.
ImageFormula.input_image3
// Property of the formula parameter.
ImageFormula.formula
// Property of the outputType parameter.
ImageFormula.output_type
// Property of the outputImage parameter.
ImageFormula.output_image

// Method to launch the command.
execute()

// Command constructor.
ImageFormula()

// Property of the inputImage1 parameter.
ImageFormula.inputImage1
// Property of the inputImage2 parameter.
ImageFormula.inputImage2
// Property of the inputImage3 parameter.
ImageFormula.inputImage3
// Property of the formula parameter.
ImageFormula.formula
// Property of the outputType parameter.
ImageFormula.outputType
// Property of the outputImage parameter.
ImageFormula.outputImage

// Method to launch the command.
Execute()

std::shared_ptr< iolink::ImageView > polystyrene = ioformat::readImage( std::string( IMAGEDEVDATA_IMAGES_FOLDER ) + "polystyrene.tif" );

ImageFormula imageFormulaAlgo;
imageFormulaAlgo.setInputImage1( polystyrene );
imageFormulaAlgo.setInputImage2( polystyrene );
imageFormulaAlgo.setInputImage3( polystyrene );
imageFormulaAlgo.setFormula( "I1+I2+I3" );
imageFormulaAlgo.setOutputType( ImageFormula::OutputType::FLOAT_32_BIT );
imageFormulaAlgo.execute();

std::cout << "outputImage:" << imageFormulaAlgo.outputImage()->toString();

polystyrene = ioformat.read_image(imagedev_data.get_image_path("polystyrene.tif"))

image_formula_algo = imagedev.ImageFormula()
image_formula_algo.input_image1 = polystyrene
image_formula_algo.input_image2 = polystyrene
image_formula_algo.input_image3 = polystyrene
image_formula_algo.formula = "I1+I2+I3"
image_formula_algo.output_type = imagedev.ImageFormula.FLOAT_32_BIT
image_formula_algo.execute()

print( "output_image:", str( image_formula_algo.output_image ) )

ImageView polystyrene = ViewIO.ReadImage( @"Data/images/polystyrene.tif" );

ImageFormula imageFormulaAlgo = new ImageFormula
{
    inputImage1 = polystyrene,
    inputImage2 = polystyrene,
    inputImage3 = polystyrene,
    formula = "I1+I2+I3",
    outputType = ImageFormula.OutputType.FLOAT_32_BIT
};
imageFormulaAlgo.Execute();

Console.WriteLine( "outputImage:" + imageFormulaAlgo.outputImage.ToString() );

std::shared_ptr< iolink::ImageView > polystyrene = ioformat::readImage( std::string( IMAGEDEVDATA_IMAGES_FOLDER ) + "polystyrene.tif" );

auto result = imageFormula( polystyrene, polystyrene, polystyrene, "I1+I2+I3", ImageFormula::OutputType::FLOAT_32_BIT );

std::cout << "outputImage:" << result->toString();

polystyrene = ioformat.read_image(imagedev_data.get_image_path("polystyrene.tif"))

result = imagedev.image_formula( polystyrene, polystyrene, polystyrene, "I1+I2+I3", imagedev.ImageFormula.FLOAT_32_BIT )

print( "output_image:", str( result ) )

ImageView polystyrene = ViewIO.ReadImage( @"Data/images/polystyrene.tif" );

IOLink.ImageView result = Processing.ImageFormula( polystyrene, polystyrene, polystyrene, "I1+I2+I3", ImageFormula.OutputType.FLOAT_32_BIT );

Console.WriteLine( "outputImage:" + result.ToString() );