ImageDev

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: 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 = nullptr );
This function returns outputImage. 
// Function prototype.
arithmetic_operation_with_value(input_image: idt.ImageType,
                                value: float = 0,
                                arithmetic_operator: ArithmeticOperationWithValue.ArithmeticOperator = ArithmeticOperationWithValue.ArithmeticOperator.ADD,
                                output_image: idt.ImageType = None) -> idt.ImageType
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

Parameters

Parameter Name Description Type Supported Values Default Value
input
inputImage
The input image.
The image type can be grayscale, binary, label, and color. 		Image Binary, Label, Grayscale or Multispectral nullptr
input
value
The value to apply.
The value is cast into the smallest type with no loss of precision. 		Float64 Any value 0
input
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
    output
    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
    input_image
    		The input image.
    The image type can be grayscale, binary, label, and color.     		image Binary, Label, Grayscale or Multispectral None
    input
    value
    		The value to apply.
    The value is cast into the smallest type with no loss of precision.     		float64 Any value 0
    input
    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
    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
    input
    inputImage
    		The input image.
    The image type can be grayscale, binary, label, and color.     		Image Binary, Label, Grayscale or Multispectral null
    input
    value
    		The value to apply.
    The value is cast into the smallest type with no loss of precision.     		Float64 Any value 0
    input
    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
    output
    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

    auto 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

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