algorithm allowing to generate a 2d image using a formula string More...

IPSDKIPLARITHMETIC_API image::ImagePtr	ipsdk::imaproc::arithm::formula2dImg (const std::string &inImageFormula2d, const ipsdk::imaproc::arithm::FormulaInOptImages &formulaInOptImages)
	wrapper function for algorithm allowing to generate a 2d image using a formula string More...

IPSDKIPLARITHMETIC_API void	ipsdk::imaproc::arithm::formula2dImg (const std::string &inImageFormula2d, const ipsdk::imaproc::arithm::FormulaInOptImages &formulaInOptImages, const image::ImagePtr &pOutImg)
	wrapper function for algorithm allowing to generate a 2d image using a formula string More...

IPSDKIPLARITHMETIC_API void	ipsdk::imaproc::arithm::formula2dImg (const std::string &inImageFormula2d, const ipsdk::imaproc::arithm::FormulaInOptImages &formulaInOptImages, const image::Border2dPolicyConstPtr &pInOptConvolBorder2d, const image::ImagePtr &pOutImg)
	wrapper function for algorithm allowing to generate a 2d image using a formula string More...

Detailed Description

algorithm allowing to generate a 2d image using a formula string

This algorithm allows to generate an image from a formula string. It can be used into several cases such as:

gather a multi step processing in a single function call
image custom masking
image filtering with custom kernel
image complex arithmetic formula application

A detailled description of image formula framework can be found at Image Formula.

The used image border policy during processing is controlled by parameter $InOptConvolBorder2d$ (see Border policy for more details).

Input images management

All input are optional for this algorithm, each input is associated to a string image identifier (see ipsdk::image::tools::eFormulaImageId):

$InOptImg1 \Leftrightarrow I1$
$InOptImg2 \Leftrightarrow I2$
$InOptImg3 \Leftrightarrow I3$
$InOptBinImg1 \Leftrightarrow B1$
$InOptBinImg2 \Leftrightarrow B2$
$InOptBinImg3 \Leftrightarrow B3$
$InOptLabImg1 \Leftrightarrow L1$
$InOptLabImg2 \Leftrightarrow L2$
$InOptLabImg3 \Leftrightarrow L3$

Shape of all provided images must be the same.

All referenced input images must be provided for processing (if for example $L2$ appears in formula string, the user should provide $InOptLabImg2$ input image).

Input images $InOptImg1$ , $InOptImg2$ and $InOptImg3$ are generic input images associated to an arithmetic (eImageFormulaResultType::eMFRT_Arithmetic) result type. These images must share same image buffer type.

Input images $InOptBinImg1$ , $InOptBinImg2$ and $InOptBinImg3$ are binary input images associated to a logical (eImageFormulaResultType::eMFRT_Logic) result type. These images must be associated to a binary image buffer type (eImageBufferType::eIBT_Binary).

Input images $InOptLabImg1$ , $InOptLabImg2$ and $InOptLabImg3$ are label input images associated to an arithmetic (eImageFormulaResultType::eMFRT_Arithmetic) result type. These images must share same image buffer type (eImageBufferType::eIBT_Label16 or eImageBufferType::eIBT_Label32).

Input images management

If the output image is provided, its shape must be the same as input optional images (if any) and its image buffer type must complies with formula result type (see Result type):

the output image buffer type is free if formula result type is arithmetic,
the output image buffer type must be binary if formula result type is logic.

If the output image is not provided, its shape is determined using the input optional images shape. If no input optional images are requested for formula processing, the user can provide $InOptImg1$ image as a model for output shape. In case where the output image is not provided, the output image will be set to floating point in case of arithmetic formula result type and to binary in case of logical formula result type.

Processing samples

Mask operations

Following codes allow to use an image formula to generate a circular centered mask image:

Python code :
outBinImg = arithm.formula2dImg("if(sqrt((x-cx)*(x-cx)+(y-cy)*(y-cy))<=10, True, False)", InOptImg1=inImg)
C++ code :
FormulaInOptImages inOptImages;
inOptImages._pInOptImg1 = pInImg;
ImagePtr pOutBinImg = arithm::formula2dImg("if(sqrt((x-cx)*(x-cx)+(y-cy)*(y-cy))<=10, True, False)", inOptImages);
In this case, the input image is only used as a model for output image shape. The output image buffer type is set to binary since this formula string is associated to a logical result type.

Following codes allow to use image formula to merge two images data without using an intermediate mask image :

Python code :
outImg = arithm.formula2dImg("if(sqrt((x-cx)*(x-cx)+(y-cy)*(y-cy))<=50, I1, I2)", InOptImg1=inImg1, InOptImg2=inImg2)
C++ code :
FormulaInOptImages inOptImages;
inOptImages._pInOptImg1 = pInImg1;
inOptImages._pInOptImg2 = pInImg2;
ImagePtr pOutImg = arithm::formula2dImg("if(sqrt((x-cx)*(x-cx)+(y-cy)*(y-cy))<=50, I1, I2)", inOptImages);
In this case, the input images are used as model for the output image shape. The output image buffer type is set to floating point since this formula string is associated to an arithmetic result type.

Filtering operations

Following codes allow to use an image formula to apply a mean filter with a rectangular structuring element on an input image

Python code :
outImg = arithm.formula2dImg("mean(rect(I1, 3, 2))", InOptImg1=inImg)
C++ code :
FormulaInOptImages inOptImages;
inOptImages._pInOptImg1 = pInImg;
ImagePtr pOutImg = arithm::formula2dImg("mean(rect(I1, 3, 2))", inOptImages);

Following codes allow to use image formula to apply a median filter with a circular structuring element on an input image.

Python code :
outImg = arithm.formula2dImg("median(circle(I1, 4))", InOptImg1=inImg)
C++ code :
FormulaInOptImages inOptImages;
inOptImages._pInOptImg1 = pInImg;
ImagePtr pOutImg = arithm::formula2dImg("median(circle(I1, 4))", inOptImages);

Using image statistics

Following codes allow to use image statistics to bound the grey level image in a given range:

Python code :
outImg = arithm.formula2dImg("lut(I1<GLMean(I2)-1.2*GLStdDev(I2):GLMean(I2)-1.2*GLStdDev(I2), I1>GLMean(I2)+1.2*GLStdDev(I2):GLMean(I2)+1.2*GLStdDev(I2), I1)", InOptImg1=inImg)
C++ code :
FormulaInOptImages inOptImages;
inOptImages._pInOptImg1 = pInImg;
ImagePtr pOutImg = arithm::formula2dImg("lut(I1<GLMean(I2)-1.2*GLStdDev(I2):GLMean(I2)-1.2*GLStdDev(I2), I1>GLMean(I2)+1.2*GLStdDev(I2):GLMean(I2)+1.2*GLStdDev(I2), I1)", inOptImages);

In this case, we bound input image grey level in range:
$OutImg = \begin{cases} mean(I_1)-1.2 \times StdDev(I_1) & \text{if } I_1<mean(I_1)-1.2 \times StdDev(I_1)\\ mean(I_1)+1.2 \times StdDev(I_1) & \text{if } I_1>mean(I_1)+1.2 \times StdDev(I_1)\\ I1 & otherwise \end{cases}$

Attributes description

Attribute description for algorithm :

Name	ToolTip	Default Initializer
ipsdk::imaproc::attr::InImageFormula2d	[Input] Image formula 2d used for image generation	X
ipsdk::imaproc::attr::InOptImg1	[Input Optional] first input image for operation	X
ipsdk::imaproc::attr::InOptImg2	[Input Optional] second input image for operation	X
ipsdk::imaproc::attr::InOptImg3	[Input Optional] third input image for operation	X
ipsdk::imaproc::attr::InOptBinImg1	[Input Optional] first binary image for operation	X
ipsdk::imaproc::attr::InOptBinImg2	[Input Optional] second binary image for operation	X
ipsdk::imaproc::attr::InOptBinImg3	[Input Optional] third binary image for operation	X
ipsdk::imaproc::attr::InOptLabImg1	[Input Optional] first label image for operation	X
ipsdk::imaproc::attr::InOptLabImg2	[Input Optional] second label image for operation	X
ipsdk::imaproc::attr::InOptLabImg3	[Input Optional] third label image for operation	X
ipsdk::imaproc::attr::InOptConvolBorder2d	[Input Optional] Border preparation policy for 2d convolution algorithm	X
ipsdk::imaproc::attr::OutImg	[Output] image for processing operation	customOutput (_pOutImg, outputFormula(_pInImageFormula2d,_pInOptImg1,_pInOptImg2,_pInOptImg3,_pInOptBinImg1,_pInOptBinImg2,_pInOptBinImg3,_pInOptLabImg1,_pInOptLabImg2,_pInOptLabImg3))

Global Rule description

Global rule description for algorithm :
validateFormulaAndImages (_pInImageFormula2d,_pInOptImg1,_pInOptImg2,_pInOptImg3,_pInOptBinImg1,_pInOptBinImg2,_pInOptBinImg3,_pInOptLabImg1,_pInOptLabImg2,_pInOptLabImg3,_pOutImg)

Example of Python code :

Example imports

import PyIPSDK
import PyIPSDK.IPSDKIPLArithmetic as arithm
import PyIPSDK.IPSDKIPLAdvancedMorphology as advmorpho
import PyIPSDK.IPSDKIPLUtility as util

Code Example

    # opening input images
    inImg1 = PyIPSDK.loadTiffImageFile(inImg1Path)
    inImg2 = PyIPSDK.loadTiffImageFile(inImg2Path)
    inImg3 = PyIPSDK.loadTiffImageFile(inImg3Path)
    inImg4 = PyIPSDK.loadTiffImageFile(inImg4Path)
    inBinImg1 = PyIPSDK.loadTiffImageFile(inBinImg1Path)
    inLabImg1 = advmorpho.connectedComponent2dImg(inBinImg1)
    
    # we draw a binary circle, its inverse and a grey circle
    outBinImg1_1 = arithm.formula2dImg("if((x-cx)*(x-cx)+(y-cy)*(y-cy)<=100, True, False)", InOptImg1=inImg1)
    outBinImg1_2 = arithm.formula2dImg("if((x-cx)*(x-cx)+(y-cy)*(y-cy)<=100, False, True)", InOptImg1=inImg1)
    outGreyImg1_1 = arithm.formula2dImg("if((x-cx)*(x-cx)+(y-cy)*(y-cy)<=100, 200, 100)", InOptImg1=inImg1)
    # we smooth input image using a mean filter with a rectangular kernel
    # and a median filter with a circular kernel
    # Default output type for arithmetical results is floating point
    # In second case we repeate this operation with a custom border policy
    # In third case we force output image and so its type to unsigned char
    outGreyImg2_1 = arithm.formula2dImg("mean(rect(I1, 3, 2))", InOptImg1=inImg1)
    outGreyImg2_2 = util.copyImg(inImg1)
    arithm.formula2dImg("mean(rect(I1, 3, 2))", InOptImg1=inImg1,
                        InOptConvolBorder2d=PyIPSDK.mirorBorder2d(), OutImg=outGreyImg2_2)
    outGreyImg2_3 = util.copyImg(inImg1)
    arithm.formula2dImg("median(circle(I1, 4))", InOptImg1=inImg1, OutImg=outGreyImg2_3)
    # we use statistics on an image to filter values on an other one
    outGreyImg3_1 = arithm.formula2dImg("if(I1<GLMean(I2)-1.5*GLStdDev(I2), GLMean(I2)-1.5*GLStdDev(I2), if(I1>GLMean(I2)+1.5*GLStdDev(I2), GLMean(I2)+1.5*GLStdDev(I2), I1))",
                                        InOptImg1=inImg2, InOptImg2=inImg3)
    outGreyImg3_2 = arithm.formula2dImg("lut(I1<GLMean(I2)-1.5*GLStdDev(I2):GLMean(I2)-1.5*GLStdDev(I2), I1>GLMean(I2)+1.5*GLStdDev(I2):GLMean(I2)+1.5*GLStdDev(I2); I1)",
                                        InOptImg1=inImg2, InOptImg2=inImg3)
    # we use a label image to mask an input image and retrieve only grey levels
    # associated to given particules label
    outGreyImg4_1 = arithm.formula2dImg("if(L1>50 && L1<100, I1, 0)",
                                        InOptImg1=inImg4,
                                        InOptLabImg1=inLabImg1)
                                        
    # we use image offsets to compute a "cross like" mean smoothing operation
    outGreyImg5_1 = arithm.formula2dImg("mean(I1, I1(-1, 0), I1(0, 1), I1(0, -1), I1(0, 1))", InOptImg1=inImg1)

Example of C++ code :

Example informations

Associated library

IPSDKIPLArithmetic

Header file

#include <IPSDKIPL/IPSDKIPLArithmetic/Processor/Formula2dImg/Formula2dImg.h>

Code Example

    // we draw a binary circle, its inverse and a grey circle
    FormulaInOptImages inOptImages1;
    inOptImages1._pInOptImg1 = pInImg1;
    ImagePtr pOutBinImg1_1 = formula2dImg("if((x-cx)*(x-cx)+(y-cy)*(y-cy)<=100, True, False)", inOptImages1);
    ImagePtr pOutBinImg1_2 = formula2dImg("if((x-cx)*(x-cx)+(y-cy)*(y-cy)<=100, False, True)", inOptImages1);
    ImagePtr pOutGreyImg1_1 = formula2dImg("if((x-cx)*(x-cx)+(y-cy)*(y-cy)<=100, 200, 100)", inOptImages1);
    // we smooth input image using a mean filter with a rectangular kernel
    // and a median filter with a circular kernel
    // Default output type for arithmetical results is floating point
    // In second case we force output image and so its type to unsigned char
    FormulaInOptImages inOptImages2;
    inOptImages2._pInOptImg1 = pInImg1;
    ImagePtr pOutGreyImg2_1 = formula2dImg("mean(rect(I1, 3, 2))", inOptImages2);
    ImagePtr pOutGreyImg2_2 = copyImg(pInImg1);
    formula2dImg("mean(rect(I1, 3, 2))", inOptImages2, mirorBorder2d(), pOutGreyImg2_2);
    ImagePtr pOutGreyImg2_3 = copyImg(pInImg1);
    formula2dImg("median(circle(I1, 4))", inOptImages2, pOutGreyImg2_3);
    // we use statistics on an image to filter values on an other one
    FormulaInOptImages inOptImages3;
    inOptImages3._pInOptImg1 = pInImg2;
    inOptImages3._pInOptImg2 = pInImg3;
    ImagePtr pOutGreyImg3_1 = formula2dImg("if(I1<GLMean(I2)-1.5*GLStdDev(I2), GLMean(I2)-1.5*GLStdDev(I2), if(I1>GLMean(I2)+1.5*GLStdDev(I2), GLMean(I2)+1.5*GLStdDev(I2), I1))", inOptImages3);
    ImagePtr pOutGreyImg3_2 = formula2dImg("lut(I1<GLMean(I2)-1.5*GLStdDev(I2):GLMean(I2)-1.5*GLStdDev(I2), I1>GLMean(I2)+1.5*GLStdDev(I2):GLMean(I2)+1.5*GLStdDev(I2); I1)", inOptImages3);
    // we use a label image to mask an input image and retrieve only grey levels
    // associated to given particules label
    FormulaInOptImages inOptImages4;
    inOptImages4._pInOptImg1 = pInImg4;
    inOptImages4._pInOptLabImg1 = pInLabImg1;
    ImagePtr pOutGreyImg4_1 = formula2dImg("if(L1>50 && L1<100, I1, 0)", inOptImages4);
    // we use image offsets to compute a "cross like" mean smoothing operation
    FormulaInOptImages inOptImages5;
    inOptImages5._pInOptImg1 = pInImg1;
    ImagePtr pOutGreyImg5_1 = formula2dImg("mean(I1, I1(-1, 0), I1(0, 1), I1(0, -1), I1(0, 1))", inOptImages5);

See also: Formula2dImgLvl1; Formula2dImgLvl2

Function Documentation

◆ formula2dImg() [1/3]

IPSDKIPLARITHMETIC_API image::ImagePtr ipsdk::imaproc::arithm::formula2dImg	(	const std::string &	inImageFormula2d,
		const ipsdk::imaproc::arithm::FormulaInOptImages &	formulaInOptImages
	)

wrapper function for algorithm allowing to generate a 2d image using a formula string

Exceptions

ipsdk::processor::IPSDKBaseProcessingException on failure

◆ formula2dImg() [2/3]

IPSDKIPLARITHMETIC_API void ipsdk::imaproc::arithm::formula2dImg	(	const std::string &	inImageFormula2d,
		const ipsdk::imaproc::arithm::FormulaInOptImages &	formulaInOptImages,
		const image::ImagePtr &	pOutImg
	)

wrapper function for algorithm allowing to generate a 2d image using a formula string

Exceptions

ipsdk::processor::IPSDKBaseProcessingException on failure

◆ formula2dImg() [3/3]

IPSDKIPLARITHMETIC_API void ipsdk::imaproc::arithm::formula2dImg	(	const std::string &	inImageFormula2d,
		const ipsdk::imaproc::arithm::FormulaInOptImages &	formulaInOptImages,
		const image::Border2dPolicyConstPtr &	pInOptConvolBorder2d,
		const image::ImagePtr &	pOutImg
	)

wrapper function for algorithm allowing to generate a 2d image using a formula string

Exceptions

ipsdk::processor::IPSDKBaseProcessingException on failure