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 = nullptr );

// Function prototype.
image_formula(input_image1: idt.ImageType,
              input_image2: idt.ImageType,
              input_image3: idt.ImageType,
              formula: str = "",
              output_type: ImageFormula.OutputType = ImageFormula.OutputType.UNSIGNED_INTEGER_8_BIT,
              output_image: idt.ImageType = None) -> idt.ImageType

// 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();

/// Gets the inputImage1 parameter.
/// The first input image.
std::shared_ptr< iolink::ImageView > inputImage1() const;
/// Sets the inputImage1 parameter.
/// The first input image.
void setInputImage1( std::shared_ptr< iolink::ImageView > inputImage1 );

/// Gets the inputImage2 parameter.
/// The second input image (optional).
std::shared_ptr< iolink::ImageView > inputImage2() const;
/// Sets the inputImage2 parameter.
/// The second input image (optional).
void setInputImage2( std::shared_ptr< iolink::ImageView > inputImage2 );

/// Gets the inputImage3 parameter.
/// The third input image (optional).
std::shared_ptr< iolink::ImageView > inputImage3() const;
/// Sets the inputImage3 parameter.
/// The third input image (optional).
void setInputImage3( std::shared_ptr< iolink::ImageView > inputImage3 );

/// Gets the formula parameter.
/// The formula to apply on image(s).
std::string formula() const;
/// Sets the formula parameter.
/// The formula to apply on image(s).
void setFormula( const std::string& formula );

/// Gets the outputType parameter.
/// The output image data type.
ImageFormula::OutputType outputType() const;
/// Sets the outputType parameter.
/// The output image data type.
void setOutputType( const ImageFormula::OutputType& outputType );

/// Gets the outputImage parameter.
/// The output image. Its dimensions are forced to the same values as the input.Its data type is user-defined.
std::shared_ptr< iolink::ImageView > outputImage() const;
/// Sets the outputImage parameter.
/// The output image. Its dimensions are forced to the same values as the input.Its data type is user-defined.
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()

auto 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() );

auto 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() );