ArithmeticOperationWithValue

Performs a pointwise arithmetic operation between an image and a value.

Access to parameter description

The arithmetic operator to apply between the input image

$I$ and the constant value

$C$ can be selected from:

Addition
Subtraction
Multiply
Division
Minimum or maximum

The type of the output image

$O$ is deduced from the Rules for Arithmetic Image Type.

See also

Function Syntax

This function returns outputImage.

// Function prototype
std::shared_ptr< iolink::ImageView >
arithmeticOperationWithValue( std::shared_ptr< iolink::ImageView > inputImage,
                              double value,
                              ArithmeticOperationWithValue::ArithmeticOperator arithmeticOperator,
                              std::shared_ptr< iolink::ImageView > outputImage = NULL );

This function returns outputImage.

// Function prototype.
arithmetic_operation_with_value( input_image,
                                 value = 0,
                                 arithmetic_operator = ArithmeticOperationWithValue.ArithmeticOperator.ADD,
                                 output_image = None )

This function returns outputImage.

// Function prototype.
public static IOLink.ImageView
ArithmeticOperationWithValue( IOLink.ImageView inputImage,
                              double value = 0,
                              ArithmeticOperationWithValue.ArithmeticOperator arithmeticOperator = ImageDev.ArithmeticOperationWithValue.ArithmeticOperator.ADD,
                              IOLink.ImageView outputImage = null );

Class Syntax

// Command constructor.
ArithmeticOperationWithValue();

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

/// Gets the value parameter.
/// The value to apply.
double value() const;
/// Sets the value parameter.
/// The value to apply.
void setValue( const double& value );

/// Gets the arithmeticOperator parameter.
/// The arithmetic operator to apply.
ArithmeticOperationWithValue::ArithmeticOperator arithmeticOperator() const;
/// Sets the arithmeticOperator parameter.
/// The arithmetic operator to apply.
void setArithmeticOperator( const ArithmeticOperationWithValue::ArithmeticOperator& arithmeticOperator );

/// Gets the outputImage parameter.
/// The output image.
std::shared_ptr< iolink::ImageView > outputImage() const;
/// Sets the outputImage parameter.
/// The output image.
void setOutputImage( std::shared_ptr< iolink::ImageView > outputImage );


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

# Property of the inputImage parameter.
ArithmeticOperationWithValue.input_image
# Property of the value parameter.
ArithmeticOperationWithValue.value
# Property of the arithmeticOperator parameter.
ArithmeticOperationWithValue.arithmetic_operator
# Property of the outputImage parameter.
ArithmeticOperationWithValue.output_image

// Method to launch the command.
execute()

// Command constructor.
ArithmeticOperationWithValue()

// Property of the inputImage parameter.
ArithmeticOperationWithValue.inputImage
// Property of the value parameter.
ArithmeticOperationWithValue.value
// Property of the arithmeticOperator parameter.
ArithmeticOperationWithValue.arithmeticOperator
// Property of the outputImage parameter.
ArithmeticOperationWithValue.outputImage

// Method to launch the command.
Execute()

Parameters

Parameter Name

Description

Type

Supported Values

Default Value

inputImage

The input image.
The image type can be grayscale, binary, label, and color.

Image

Binary, Label, Grayscale or Multispectral

nullptr

value

The value to apply.
The value is cast into the smallest type with no loss of precision.

Float64

Any value

arithmeticOperator

The arithmetic operator to apply.

ADD	The ADD arithmetic operator adds an image I with a constant C. The formula applied between the input image $I$ and the operand $C$ is: $O(n,m)=I(n,m)+C$ Remarks: Overflows may occur. Be careful with negative values and the way they are visualized.
SUBTRACT	The SUBTRACT arithmetic operator subtract a constant C from an image I. The formula applied between the input image $I$ and the operand $C$ is: $O(n,m)=I(n,m)-C$ Remarks: Overflows may occur. The result of a subtraction between a binary image and a constant is a short integer image. This operation is not equivalent to a logical difference. Be careful with negative values and the way they are visualized.
MULTIPLY	The MULTIPLY arithmetic operator multiplies an image I by a constant C. The formula applied between the input image $I$ and the operand $C$ is: $O(n,m)=I(n,m) \times C$ Remarks: Overflows may occur. Be careful with negative values and the way they are visualized.
DIVIDE	The DIVIDE arithmetic operator divides an image I by a constant C. The formula applied between the input image $I$ and the operand $C$ is: $O(n,m)=I(n,m)\div C$ Remarks: Overflows may occur. Be careful with negative values and the way they are visualized. If $C=0$ then $O(n,m)=I(n,m)$
MINIMUM	The MINIMUM arithmetic operator computes the minimum value between an image I and a constant C. The formula applied between the input image $I$ and the operand $C$ is: $O(n,m)=\min\left\{I(n,m),C\right\}$ For binary image, the MINIMUM operator is equivalent to a logical AND. $\begin{array}{\|c\|c\|c\|} \hline I_1 & C & I_1 \Lambda C\\ \hline 1 & 1 & 1 \\ 1 & 0 & 0 \\ 0 & 1 & 0 \\ 0 & 0 & 0 \\ \hline \end{array}$
MAXIMUM	The MAXIMUM arithmetic operator computes the maximum value between an image I and a constant C. The formula applied between the input image $I$ and the operand $C$ is: $O(n,m)=\max\left\{I(n,m),C\right\}$ For binary image, the MAXIMUM operator is equivalent to a logical OR. $\begin{array}{\|c\|c\|c\|} \hline I_1 & C & I_1 \Delta C\\ \hline 1 & 1 & 1 \\ 1 & 0 & 1 \\ 0 & 1 & 1 \\ 0 & 0 & 0 \\ \hline \end{array}$

Enumeration

ADD

outputImage

The output image.
The output image dimensions are forced to the same values as the input. The output image type is deduced from the input.

Image

nullptr

Parameter Name

Description

Type

Supported Values

Default Value

input_image

The input image.
The image type can be grayscale, binary, label, and color.

image

Binary, Label, Grayscale or Multispectral

None

value

The value to apply.
The value is cast into the smallest type with no loss of precision.

float64

Any value

arithmetic_operator

The arithmetic operator to apply.

ADD	The ADD arithmetic operator adds an image I with a constant C. The formula applied between the input image $I$ and the operand $C$ is: $O(n,m)=I(n,m)+C$ Remarks: Overflows may occur. Be careful with negative values and the way they are visualized.
SUBTRACT	The SUBTRACT arithmetic operator subtract a constant C from an image I. The formula applied between the input image $I$ and the operand $C$ is: $O(n,m)=I(n,m)-C$ Remarks: Overflows may occur. The result of a subtraction between a binary image and a constant is a short integer image. This operation is not equivalent to a logical difference. Be careful with negative values and the way they are visualized.
MULTIPLY	The MULTIPLY arithmetic operator multiplies an image I by a constant C. The formula applied between the input image $I$ and the operand $C$ is: $O(n,m)=I(n,m) \times C$ Remarks: Overflows may occur. Be careful with negative values and the way they are visualized.
DIVIDE	The DIVIDE arithmetic operator divides an image I by a constant C. The formula applied between the input image $I$ and the operand $C$ is: $O(n,m)=I(n,m)\div C$ Remarks: Overflows may occur. Be careful with negative values and the way they are visualized. If $C=0$ then $O(n,m)=I(n,m)$
MINIMUM	The MINIMUM arithmetic operator computes the minimum value between an image I and a constant C. The formula applied between the input image $I$ and the operand $C$ is: $O(n,m)=\min\left\{I(n,m),C\right\}$ For binary image, the MINIMUM operator is equivalent to a logical AND. $\begin{array}{\|c\|c\|c\|} \hline I_1 & C & I_1 \Lambda C\\ \hline 1 & 1 & 1 \\ 1 & 0 & 0 \\ 0 & 1 & 0 \\ 0 & 0 & 0 \\ \hline \end{array}$
MAXIMUM	The MAXIMUM arithmetic operator computes the maximum value between an image I and a constant C. The formula applied between the input image $I$ and the operand $C$ is: $O(n,m)=\max\left\{I(n,m),C\right\}$ For binary image, the MAXIMUM operator is equivalent to a logical OR. $\begin{array}{\|c\|c\|c\|} \hline I_1 & C & I_1 \Delta C\\ \hline 1 & 1 & 1 \\ 1 & 0 & 1 \\ 0 & 1 & 1 \\ 0 & 0 & 0 \\ \hline \end{array}$

enumeration

ADD

output_image

The output image.
The output image dimensions are forced to the same values as the input. The output image type is deduced from the input.

image

None

Parameter Name

Description

Type

Supported Values

Default Value

inputImage

The input image.
The image type can be grayscale, binary, label, and color.

Image

Binary, Label, Grayscale or Multispectral

null

value

The value to apply.
The value is cast into the smallest type with no loss of precision.

Float64

Any value

arithmeticOperator

The arithmetic operator to apply.

ADD	The ADD arithmetic operator adds an image I with a constant C. The formula applied between the input image $I$ and the operand $C$ is: $O(n,m)=I(n,m)+C$ Remarks: Overflows may occur. Be careful with negative values and the way they are visualized.
SUBTRACT	The SUBTRACT arithmetic operator subtract a constant C from an image I. The formula applied between the input image $I$ and the operand $C$ is: $O(n,m)=I(n,m)-C$ Remarks: Overflows may occur. The result of a subtraction between a binary image and a constant is a short integer image. This operation is not equivalent to a logical difference. Be careful with negative values and the way they are visualized.
MULTIPLY	The MULTIPLY arithmetic operator multiplies an image I by a constant C. The formula applied between the input image $I$ and the operand $C$ is: $O(n,m)=I(n,m) \times C$ Remarks: Overflows may occur. Be careful with negative values and the way they are visualized.
DIVIDE	The DIVIDE arithmetic operator divides an image I by a constant C. The formula applied between the input image $I$ and the operand $C$ is: $O(n,m)=I(n,m)\div C$ Remarks: Overflows may occur. Be careful with negative values and the way they are visualized. If $C=0$ then $O(n,m)=I(n,m)$
MINIMUM	The MINIMUM arithmetic operator computes the minimum value between an image I and a constant C. The formula applied between the input image $I$ and the operand $C$ is: $O(n,m)=\min\left\{I(n,m),C\right\}$ For binary image, the MINIMUM operator is equivalent to a logical AND. $\begin{array}{\|c\|c\|c\|} \hline I_1 & C & I_1 \Lambda C\\ \hline 1 & 1 & 1 \\ 1 & 0 & 0 \\ 0 & 1 & 0 \\ 0 & 0 & 0 \\ \hline \end{array}$
MAXIMUM	The MAXIMUM arithmetic operator computes the maximum value between an image I and a constant C. The formula applied between the input image $I$ and the operand $C$ is: $O(n,m)=\max\left\{I(n,m),C\right\}$ For binary image, the MAXIMUM operator is equivalent to a logical OR. $\begin{array}{\|c\|c\|c\|} \hline I_1 & C & I_1 \Delta C\\ \hline 1 & 1 & 1 \\ 1 & 0 & 1 \\ 0 & 1 & 1 \\ 0 & 0 & 0 \\ \hline \end{array}$

Enumeration

ADD

outputImage

The output image.
The output image dimensions are forced to the same values as the input. The output image type is deduced from the input.

Image

null

Object Examples

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

ArithmeticOperationWithValue arithmeticOperationWithValueAlgo;
arithmeticOperationWithValueAlgo.setInputImage( polystyrene );
arithmeticOperationWithValueAlgo.setValue( 10 );
arithmeticOperationWithValueAlgo.setArithmeticOperator( ArithmeticOperationWithValue::ArithmeticOperator::ADD );
arithmeticOperationWithValueAlgo.execute();

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

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

arithmetic_operation_with_value_algo = imagedev.ArithmeticOperationWithValue()
arithmetic_operation_with_value_algo.input_image = polystyrene
arithmetic_operation_with_value_algo.value = 10
arithmetic_operation_with_value_algo.arithmetic_operator = imagedev.ArithmeticOperationWithValue.ADD
arithmetic_operation_with_value_algo.execute()

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

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

ArithmeticOperationWithValue arithmeticOperationWithValueAlgo = new ArithmeticOperationWithValue
{
    inputImage = polystyrene,
    value = 10,
    arithmeticOperator = ArithmeticOperationWithValue.ArithmeticOperator.ADD
};
arithmeticOperationWithValueAlgo.Execute();

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

Function Examples

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

auto result = arithmeticOperationWithValue( polystyrene, 10, ArithmeticOperationWithValue::ArithmeticOperator::ADD );

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

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

result = imagedev.arithmetic_operation_with_value( polystyrene, 10, imagedev.ArithmeticOperationWithValue.ADD )

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

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

IOLink.ImageView result = Processing.ArithmeticOperationWithValue( polystyrene, 10, ArithmeticOperationWithValue.ArithmeticOperator.ADD );

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

ArithmeticOperationWithValue

- Function Syntax

+ Class Syntax

Parameters

Object Examples

Function Examples

Function Syntax

Class Syntax