PixelMath (ip 0.21 API)

java.lang.Object
- boofcv.alg.misc.PixelMath

```
public class PixelMath
extends java.lang.Object
```
Functions which perform basic arithmetic (e.g. addition, subtraction, multiplication, or division) on a pixel by pixel basis.
DO NOT MODIFY: Generated by boofcv.alg.misc.GeneratePixelMath.

Constructor Summary

Constructors
Constructor and Description

PixelMath()

Constructors
Constructor and Description
`PixelMath()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static void`	`abs(ImageFloat32 input, ImageFloat32 output)` Sets each pixel in the output image to be the absolute value of the input image.
`static void`	`abs(ImageFloat64 input, ImageFloat64 output)` Sets each pixel in the output image to be the absolute value of the input image.
`static void`	`abs(ImageSInt16 input, ImageSInt16 output)` Sets each pixel in the output image to be the absolute value of the input image.
`static void`	`abs(ImageSInt32 input, ImageSInt32 output)` Sets each pixel in the output image to be the absolute value of the input image.
`static void`	`abs(ImageSInt64 input, ImageSInt64 output)` Sets each pixel in the output image to be the absolute value of the input image.
`static void`	`abs(ImageSInt8 input, ImageSInt8 output)` Sets each pixel in the output image to be the absolute value of the input image.
`static void`	`add(ImageFloat32 imgA, ImageFloat32 imgB, ImageFloat32 output)` Performs pixel-wise addition output(x,y) = imgA(x,y) + imgB(x,y)
`static void`	`add(ImageFloat64 imgA, ImageFloat64 imgB, ImageFloat64 output)` Performs pixel-wise addition output(x,y) = imgA(x,y) + imgB(x,y)
`static void`	`add(ImageSInt16 imgA, ImageSInt16 imgB, ImageSInt32 output)` Performs pixel-wise addition output(x,y) = imgA(x,y) + imgB(x,y)
`static void`	`add(ImageSInt32 imgA, ImageSInt32 imgB, ImageSInt32 output)` Performs pixel-wise addition output(x,y) = imgA(x,y) + imgB(x,y)
`static void`	`add(ImageSInt64 imgA, ImageSInt64 imgB, ImageSInt64 output)` Performs pixel-wise addition output(x,y) = imgA(x,y) + imgB(x,y)
`static void`	`add(ImageSInt8 imgA, ImageSInt8 imgB, ImageSInt16 output)` Performs pixel-wise addition output(x,y) = imgA(x,y) + imgB(x,y)
`static void`	`add(ImageUInt16 imgA, ImageUInt16 imgB, ImageSInt32 output)` Performs pixel-wise addition output(x,y) = imgA(x,y) + imgB(x,y)
`static void`	`add(ImageUInt8 imgA, ImageUInt8 imgB, ImageUInt16 output)` Performs pixel-wise addition output(x,y) = imgA(x,y) + imgB(x,y)
`static void`	`averageBand(MultiSpectral<ImageFloat32> input, ImageFloat32 output)` Computes the average for each pixel across all bands in the `MultiSpectral` image.
`static void`	`averageBand(MultiSpectral<ImageFloat64> input, ImageFloat64 output)` Computes the average for each pixel across all bands in the `MultiSpectral` image.
`static void`	`averageBand(MultiSpectral<ImageSInt16> input, ImageSInt16 output)` Computes the average for each pixel across all bands in the `MultiSpectral` image.
`static void`	`averageBand(MultiSpectral<ImageSInt32> input, ImageSInt32 output)` Computes the average for each pixel across all bands in the `MultiSpectral` image.
`static void`	`averageBand(MultiSpectral<ImageSInt64> input, ImageSInt64 output)` Computes the average for each pixel across all bands in the `MultiSpectral` image.
`static void`	`averageBand(MultiSpectral<ImageSInt8> input, ImageSInt8 output)` Computes the average for each pixel across all bands in the `MultiSpectral` image.
`static void`	`averageBand(MultiSpectral<ImageUInt16> input, ImageUInt16 output)` Computes the average for each pixel across all bands in the `MultiSpectral` image.
`static void`	`averageBand(MultiSpectral<ImageUInt8> input, ImageUInt8 output)` Computes the average for each pixel across all bands in the `MultiSpectral` image.
`static void`	`boundImage(ImageFloat32 img, float min, float max)` Bounds image pixels to be between these two values
`static void`	`boundImage(ImageFloat64 img, double min, double max)` Bounds image pixels to be between these two values
`static void`	`boundImage(ImageSInt16 img, int min, int max)` Bounds image pixels to be between these two values
`static void`	`boundImage(ImageSInt32 img, int min, int max)` Bounds image pixels to be between these two values
`static void`	`boundImage(ImageSInt64 img, long min, long max)` Bounds image pixels to be between these two values
`static void`	`boundImage(ImageSInt8 img, int min, int max)` Bounds image pixels to be between these two values
`static void`	`boundImage(ImageUInt16 img, int min, int max)` Bounds image pixels to be between these two values
`static void`	`boundImage(ImageUInt8 img, int min, int max)` Bounds image pixels to be between these two values
`static void`	`diffAbs(ImageFloat32 imgA, ImageFloat32 imgB, ImageFloat32 diff)` Computes the absolute value of the difference between each pixel in the two images. d(x,y) = \|img1(x,y) - img2(x,y)\|
`static void`	`diffAbs(ImageFloat64 imgA, ImageFloat64 imgB, ImageFloat64 diff)` Computes the absolute value of the difference between each pixel in the two images. d(x,y) = \|img1(x,y) - img2(x,y)\|
`static void`	`diffAbs(ImageSInt16 imgA, ImageSInt16 imgB, ImageSInt16 diff)` Computes the absolute value of the difference between each pixel in the two images. d(x,y) = \|img1(x,y) - img2(x,y)\|
`static void`	`diffAbs(ImageSInt32 imgA, ImageSInt32 imgB, ImageSInt32 diff)` Computes the absolute value of the difference between each pixel in the two images. d(x,y) = \|img1(x,y) - img2(x,y)\|
`static void`	`diffAbs(ImageSInt64 imgA, ImageSInt64 imgB, ImageSInt64 diff)` Computes the absolute value of the difference between each pixel in the two images. d(x,y) = \|img1(x,y) - img2(x,y)\|
`static void`	`diffAbs(ImageSInt8 imgA, ImageSInt8 imgB, ImageSInt8 diff)` Computes the absolute value of the difference between each pixel in the two images. d(x,y) = \|img1(x,y) - img2(x,y)\|
`static void`	`diffAbs(ImageUInt16 imgA, ImageUInt16 imgB, ImageUInt16 diff)` Computes the absolute value of the difference between each pixel in the two images. d(x,y) = \|img1(x,y) - img2(x,y)\|
`static void`	`diffAbs(ImageUInt8 imgA, ImageUInt8 imgB, ImageUInt8 diff)` Computes the absolute value of the difference between each pixel in the two images. d(x,y) = \|img1(x,y) - img2(x,y)\|
`static void`	`divide(ImageFloat32 input, float denominator, float lower, float upper, ImageFloat32 output)` Divide each element by a scalar value and bounds the result.
`static void`	`divide(ImageFloat32 input, float denominator, ImageFloat32 output)` Divide each element by a scalar value.
`static void`	`divide(ImageFloat32 imgA, ImageFloat32 imgB, ImageFloat32 output)` Performs pixel-wise division output(x,y) = imgA(x,y) / imgB(x,y)
`static void`	`divide(ImageFloat64 input, double denominator, double lower, double upper, ImageFloat64 output)` Divide each element by a scalar value and bounds the result.
`static void`	`divide(ImageFloat64 input, double denominator, ImageFloat64 output)` Divide each element by a scalar value.
`static void`	`divide(ImageFloat64 imgA, ImageFloat64 imgB, ImageFloat64 output)` Performs pixel-wise division output(x,y) = imgA(x,y) / imgB(x,y)
`static void`	`divide(ImageSInt16 input, double denominator, ImageSInt16 output)` Divide each element by a scalar value.
`static void`	`divide(ImageSInt16 input, double denominator, int lower, int upper, ImageSInt16 output)` Divide each element by a scalar value and bounds the result.
`static void`	`divide(ImageSInt32 input, double denominator, ImageSInt32 output)` Divide each element by a scalar value.
`static void`	`divide(ImageSInt32 input, double denominator, int lower, int upper, ImageSInt32 output)` Divide each element by a scalar value and bounds the result.
`static void`	`divide(ImageSInt64 input, double denominator, ImageSInt64 output)` Divide each element by a scalar value.
`static void`	`divide(ImageSInt64 input, double denominator, long lower, long upper, ImageSInt64 output)` Divide each element by a scalar value and bounds the result.
`static void`	`divide(ImageSInt8 input, double denominator, ImageSInt8 output)` Divide each element by a scalar value.
`static void`	`divide(ImageSInt8 input, double denominator, int lower, int upper, ImageSInt8 output)` Divide each element by a scalar value and bounds the result.
`static void`	`divide(ImageUInt16 input, double denominator, ImageUInt16 output)` Divide each element by a scalar value.
`static void`	`divide(ImageUInt16 input, double denominator, int lower, int upper, ImageUInt16 output)` Divide each element by a scalar value and bounds the result.
`static void`	`divide(ImageUInt8 input, double denominator, ImageUInt8 output)` Divide each element by a scalar value.
`static void`	`divide(ImageUInt8 input, double denominator, int lower, int upper, ImageUInt8 output)` Divide each element by a scalar value and bounds the result.
`static void`	`invert(ImageFloat32 input, ImageFloat32 output)` Changes the sign of every pixel in the image: output[x,y] = -input[x,y]
`static void`	`invert(ImageFloat64 input, ImageFloat64 output)` Changes the sign of every pixel in the image: output[x,y] = -input[x,y]
`static void`	`invert(ImageSInt16 input, ImageSInt16 output)` Changes the sign of every pixel in the image: output[x,y] = -input[x,y]
`static void`	`invert(ImageSInt32 input, ImageSInt32 output)` Changes the sign of every pixel in the image: output[x,y] = -input[x,y]
`static void`	`invert(ImageSInt64 input, ImageSInt64 output)` Changes the sign of every pixel in the image: output[x,y] = -input[x,y]
`static void`	`invert(ImageSInt8 input, ImageSInt8 output)` Changes the sign of every pixel in the image: output[x,y] = -input[x,y]
`static void`	`log(ImageFloat32 input, ImageFloat32 output)` Sets each pixel in the output image to log( 1 + input(x,y)) of the input image.
`static void`	`log(ImageFloat64 input, ImageFloat64 output)` Sets each pixel in the output image to log( 1 + input(x,y)) of the input image.
`static void`	`minus(double value, ImageFloat64 input, double lower, double upper, ImageFloat64 output)` Subtracts the value of each element from a scalar value.
`static void`	`minus(double value, ImageFloat64 input, ImageFloat64 output)` Subtracts the value of each element from a scalar value.
`static void`	`minus(float value, ImageFloat32 input, float lower, float upper, ImageFloat32 output)` Subtracts the value of each element from a scalar value.
`static void`	`minus(float value, ImageFloat32 input, ImageFloat32 output)` Subtracts the value of each element from a scalar value.
`static void`	`minus(ImageFloat32 input, float value, float lower, float upper, ImageFloat32 output)` Subtracts a scalar value from each element.
`static void`	`minus(ImageFloat32 input, float value, ImageFloat32 output)` Subtracts a scalar value from each element.
`static void`	`minus(ImageFloat64 input, double value, double lower, double upper, ImageFloat64 output)` Subtracts a scalar value from each element.
`static void`	`minus(ImageFloat64 input, double value, ImageFloat64 output)` Subtracts a scalar value from each element.
`static void`	`minus(ImageSInt16 input, int value, ImageSInt16 output)` Subtracts a scalar value from each element.
`static void`	`minus(ImageSInt16 input, int value, int lower, int upper, ImageSInt16 output)` Subtracts a scalar value from each element.
`static void`	`minus(ImageSInt32 input, int value, ImageSInt32 output)` Subtracts a scalar value from each element.
`static void`	`minus(ImageSInt32 input, int value, int lower, int upper, ImageSInt32 output)` Subtracts a scalar value from each element.
`static void`	`minus(ImageSInt64 input, long value, ImageSInt64 output)` Subtracts a scalar value from each element.
`static void`	`minus(ImageSInt64 input, long value, long lower, long upper, ImageSInt64 output)` Subtracts a scalar value from each element.
`static void`	`minus(ImageSInt8 input, int value, ImageSInt8 output)` Subtracts a scalar value from each element.
`static void`	`minus(ImageSInt8 input, int value, int lower, int upper, ImageSInt8 output)` Subtracts a scalar value from each element.
`static void`	`minus(ImageUInt16 input, int value, ImageUInt16 output)` Subtracts a scalar value from each element.
`static void`	`minus(ImageUInt16 input, int value, int lower, int upper, ImageUInt16 output)` Subtracts a scalar value from each element.
`static void`	`minus(ImageUInt8 input, int value, ImageUInt8 output)` Subtracts a scalar value from each element.
`static void`	`minus(ImageUInt8 input, int value, int lower, int upper, ImageUInt8 output)` Subtracts a scalar value from each element.
`static void`	`minus(int value, ImageSInt16 input, ImageSInt16 output)` Subtracts the value of each element from a scalar value.
`static void`	`minus(int value, ImageSInt16 input, int lower, int upper, ImageSInt16 output)` Subtracts the value of each element from a scalar value.
`static void`	`minus(int value, ImageSInt32 input, ImageSInt32 output)` Subtracts the value of each element from a scalar value.
`static void`	`minus(int value, ImageSInt32 input, int lower, int upper, ImageSInt32 output)` Subtracts the value of each element from a scalar value.
`static void`	`minus(int value, ImageSInt8 input, ImageSInt8 output)` Subtracts the value of each element from a scalar value.
`static void`	`minus(int value, ImageSInt8 input, int lower, int upper, ImageSInt8 output)` Subtracts the value of each element from a scalar value.
`static void`	`minus(int value, ImageUInt16 input, ImageUInt16 output)` Subtracts the value of each element from a scalar value.
`static void`	`minus(int value, ImageUInt16 input, int lower, int upper, ImageUInt16 output)` Subtracts the value of each element from a scalar value.
`static void`	`minus(int value, ImageUInt8 input, ImageUInt8 output)` Subtracts the value of each element from a scalar value.
`static void`	`minus(int value, ImageUInt8 input, int lower, int upper, ImageUInt8 output)` Subtracts the value of each element from a scalar value.
`static void`	`minus(long value, ImageSInt64 input, ImageSInt64 output)` Subtracts the value of each element from a scalar value.
`static void`	`minus(long value, ImageSInt64 input, long lower, long upper, ImageSInt64 output)` Subtracts the value of each element from a scalar value.
`static void`	`multiply(ImageFloat32 input, float value, float lower, float upper, ImageFloat32 output)` Multiply each element by a scalar value and bounds the result.
`static void`	`multiply(ImageFloat32 input, float value, ImageFloat32 output)` Multiply each element by a scalar value.
`static void`	`multiply(ImageFloat32 imgA, ImageFloat32 imgB, ImageFloat32 output)` Performs pixel-wise multiplication output(x,y) = imgA(x,y) * imgB(x,y)
`static void`	`multiply(ImageFloat64 input, double value, double lower, double upper, ImageFloat64 output)` Multiply each element by a scalar value and bounds the result.
`static void`	`multiply(ImageFloat64 input, double value, ImageFloat64 output)` Multiply each element by a scalar value.
`static void`	`multiply(ImageFloat64 imgA, ImageFloat64 imgB, ImageFloat64 output)` Performs pixel-wise multiplication output(x,y) = imgA(x,y) * imgB(x,y)
`static void`	`multiply(ImageSInt16 input, double value, ImageSInt16 output)` Multiply each element by a scalar value.
`static void`	`multiply(ImageSInt16 input, double value, int lower, int upper, ImageSInt16 output)` Multiply each element by a scalar value and bounds the result.
`static void`	`multiply(ImageSInt32 input, double value, ImageSInt32 output)` Multiply each element by a scalar value.
`static void`	`multiply(ImageSInt32 input, double value, int lower, int upper, ImageSInt32 output)` Multiply each element by a scalar value and bounds the result.
`static void`	`multiply(ImageSInt64 input, double value, ImageSInt64 output)` Multiply each element by a scalar value.
`static void`	`multiply(ImageSInt64 input, double value, long lower, long upper, ImageSInt64 output)` Multiply each element by a scalar value and bounds the result.
`static void`	`multiply(ImageSInt8 input, double value, ImageSInt8 output)` Multiply each element by a scalar value.
`static void`	`multiply(ImageSInt8 input, double value, int lower, int upper, ImageSInt8 output)` Multiply each element by a scalar value and bounds the result.
`static void`	`multiply(ImageUInt16 input, double value, ImageUInt16 output)` Multiply each element by a scalar value.
`static void`	`multiply(ImageUInt16 input, double value, int lower, int upper, ImageUInt16 output)` Multiply each element by a scalar value and bounds the result.
`static void`	`multiply(ImageUInt8 input, double value, ImageUInt8 output)` Multiply each element by a scalar value.
`static void`	`multiply(ImageUInt8 input, double value, int lower, int upper, ImageUInt8 output)` Multiply each element by a scalar value and bounds the result.
`static void`	`plus(ImageFloat32 input, float value, float lower, float upper, ImageFloat32 output)` Add a scalar value to each element and bounds the result.
`static void`	`plus(ImageFloat32 input, float value, ImageFloat32 output)` Add a scalar value to each element.
`static void`	`plus(ImageFloat64 input, double value, double lower, double upper, ImageFloat64 output)` Add a scalar value to each element and bounds the result.
`static void`	`plus(ImageFloat64 input, double value, ImageFloat64 output)` Add a scalar value to each element.
`static void`	`plus(ImageSInt16 input, int value, ImageSInt16 output)` Add a scalar value to each element.
`static void`	`plus(ImageSInt16 input, int value, int lower, int upper, ImageSInt16 output)` Add a scalar value to each element and bounds the result.
`static void`	`plus(ImageSInt32 input, int value, ImageSInt32 output)` Add a scalar value to each element.
`static void`	`plus(ImageSInt32 input, int value, int lower, int upper, ImageSInt32 output)` Add a scalar value to each element and bounds the result.
`static void`	`plus(ImageSInt64 input, long value, ImageSInt64 output)` Add a scalar value to each element.
`static void`	`plus(ImageSInt64 input, long value, long lower, long upper, ImageSInt64 output)` Add a scalar value to each element and bounds the result.
`static void`	`plus(ImageSInt8 input, int value, ImageSInt8 output)` Add a scalar value to each element.
`static void`	`plus(ImageSInt8 input, int value, int lower, int upper, ImageSInt8 output)` Add a scalar value to each element and bounds the result.
`static void`	`plus(ImageUInt16 input, int value, ImageUInt16 output)` Add a scalar value to each element.
`static void`	`plus(ImageUInt16 input, int value, int lower, int upper, ImageUInt16 output)` Add a scalar value to each element and bounds the result.
`static void`	`plus(ImageUInt8 input, int value, ImageUInt8 output)` Add a scalar value to each element.
`static void`	`plus(ImageUInt8 input, int value, int lower, int upper, ImageUInt8 output)` Add a scalar value to each element and bounds the result.
`static void`	`pow2(ImageFloat32 input, ImageFloat32 output)` Raises each pixel in the input image to the power of two.
`static void`	`pow2(ImageFloat64 input, ImageFloat64 output)` Raises each pixel in the input image to the power of two.
`static void`	`sqrt(ImageFloat32 input, ImageFloat32 output)` Computes the square root of each pixel in the input image.
`static void`	`sqrt(ImageFloat64 input, ImageFloat64 output)` Computes the square root of each pixel in the input image.
`static void`	`subtract(ImageFloat32 imgA, ImageFloat32 imgB, ImageFloat32 output)` Performs pixel-wise subtraction. output(x,y) = imgA(x,y) - imgB(x,y)
`static void`	`subtract(ImageFloat64 imgA, ImageFloat64 imgB, ImageFloat64 output)` Performs pixel-wise subtraction. output(x,y) = imgA(x,y) - imgB(x,y)
`static void`	`subtract(ImageSInt16 imgA, ImageSInt16 imgB, ImageSInt32 output)` Performs pixel-wise subtraction. output(x,y) = imgA(x,y) - imgB(x,y)
`static void`	`subtract(ImageSInt32 imgA, ImageSInt32 imgB, ImageSInt32 output)` Performs pixel-wise subtraction. output(x,y) = imgA(x,y) - imgB(x,y)
`static void`	`subtract(ImageSInt64 imgA, ImageSInt64 imgB, ImageSInt64 output)` Performs pixel-wise subtraction. output(x,y) = imgA(x,y) - imgB(x,y)
`static void`	`subtract(ImageSInt8 imgA, ImageSInt8 imgB, ImageSInt16 output)` Performs pixel-wise subtraction. output(x,y) = imgA(x,y) - imgB(x,y)
`static void`	`subtract(ImageUInt16 imgA, ImageUInt16 imgB, ImageSInt32 output)` Performs pixel-wise subtraction. output(x,y) = imgA(x,y) - imgB(x,y)
`static void`	`subtract(ImageUInt8 imgA, ImageUInt8 imgB, ImageInt16 output)` Performs pixel-wise subtraction. output(x,y) = imgA(x,y) - imgB(x,y)

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - PixelMath
```
public PixelMath()
```
- Method Detail
  - abs
```
public static void abs(ImageSInt8 input,
                       ImageSInt8 output)
```
    Sets each pixel in the output image to be the absolute value of the input image. Both the input and output image can be the same instance.
    
    Parameters:
    
    input - The input image. Not modified.
    
    output - Where the absolute value image is written to. Modified.
  - invert
```
public static void invert(ImageSInt8 input,
                          ImageSInt8 output)
```
    Changes the sign of every pixel in the image: output[x,y] = -input[x,y]
    
    Parameters:
    
    input - The input image. Not modified.
    
    output - Where the inverted image is written to. Modified.
  - abs
```
public static void abs(ImageSInt16 input,
                       ImageSInt16 output)
```
    Sets each pixel in the output image to be the absolute value of the input image. Both the input and output image can be the same instance.
    
    Parameters:
    
    input - The input image. Not modified.
    
    output - Where the absolute value image is written to. Modified.
  - invert
```
public static void invert(ImageSInt16 input,
                          ImageSInt16 output)
```
    Changes the sign of every pixel in the image: output[x,y] = -input[x,y]
    
    Parameters:
    
    input - The input image. Not modified.
    
    output - Where the inverted image is written to. Modified.
  - abs
```
public static void abs(ImageSInt32 input,
                       ImageSInt32 output)
```
    Sets each pixel in the output image to be the absolute value of the input image. Both the input and output image can be the same instance.
    
    Parameters:
    
    input - The input image. Not modified.
    
    output - Where the absolute value image is written to. Modified.
  - invert
```
public static void invert(ImageSInt32 input,
                          ImageSInt32 output)
```
    Changes the sign of every pixel in the image: output[x,y] = -input[x,y]
    
    Parameters:
    
    input - The input image. Not modified.
    
    output - Where the inverted image is written to. Modified.
  - abs
```
public static void abs(ImageSInt64 input,
                       ImageSInt64 output)
```
    Sets each pixel in the output image to be the absolute value of the input image. Both the input and output image can be the same instance.
    
    Parameters:
    
    input - The input image. Not modified.
    
    output - Where the absolute value image is written to. Modified.
  - invert
```
public static void invert(ImageSInt64 input,
                          ImageSInt64 output)
```
    Changes the sign of every pixel in the image: output[x,y] = -input[x,y]
    
    Parameters:
    
    input - The input image. Not modified.
    
    output - Where the inverted image is written to. Modified.
  - abs
```
public static void abs(ImageFloat32 input,
                       ImageFloat32 output)
```
    Sets each pixel in the output image to be the absolute value of the input image. Both the input and output image can be the same instance.
    
    Parameters:
    
    input - The input image. Not modified.
    
    output - Where the absolute value image is written to. Modified.
  - invert
```
public static void invert(ImageFloat32 input,
                          ImageFloat32 output)
```
    Changes the sign of every pixel in the image: output[x,y] = -input[x,y]
    
    Parameters:
    
    input - The input image. Not modified.
    
    output - Where the inverted image is written to. Modified.
  - abs
```
public static void abs(ImageFloat64 input,
                       ImageFloat64 output)
```
    Sets each pixel in the output image to be the absolute value of the input image. Both the input and output image can be the same instance.
    
    Parameters:
    
    input - The input image. Not modified.
    
    output - Where the absolute value image is written to. Modified.
  - invert
```
public static void invert(ImageFloat64 input,
                          ImageFloat64 output)
```
    Changes the sign of every pixel in the image: output[x,y] = -input[x,y]
    
    Parameters:
    
    input - The input image. Not modified.
    
    output - Where the inverted image is written to. Modified.
  - multiply
```
public static void multiply(ImageUInt8 input,
                            double value,
                            ImageUInt8 output)
```
    Multiply each element by a scalar value. Both input and output images can be the same instance.
    
    Parameters:
    
    input - The input image. Not modified.
    
    value - What each element is multiplied by.
    
    output - The output image. Modified.
  - multiply
```
public static void multiply(ImageUInt8 input,
                            double value,
                            int lower,
                            int upper,
                            ImageUInt8 output)
```
    Multiply each element by a scalar value and bounds the result. Both input and output images can be the same instance.
    
    Parameters:
    
    input - The input image. Not modified.
    
    value - What each element is multiplied by.
    
    lower - Lower bound on output. Inclusive.
    
    upper - Upper bound on output. Inclusive.
    
    output - The output image. Modified.
  - divide
```
public static void divide(ImageUInt8 input,
                          double denominator,
                          ImageUInt8 output)
```
    Divide each element by a scalar value. Both input and output images can be the same instance.
    
    Parameters:
    
    input - The input image. Not modified.
    
    denominator - What each element is divided by.
    
    output - The output image. Modified.
  - divide
```
public static void divide(ImageUInt8 input,
                          double denominator,
                          int lower,
                          int upper,
                          ImageUInt8 output)
```
    Divide each element by a scalar value and bounds the result. Both input and output images can be the same instance.
    
    Parameters:
    
    input - The input image. Not modified.
    
    denominator - What each element is divided by.
    
    lower - Lower bound on output. Inclusive.
    
    upper - Upper bound on output. Inclusive.
    
    output - The output image. Modified.
  - plus
```
public static void plus(ImageUInt8 input,
                        int value,
                        ImageUInt8 output)
```
    Add a scalar value to each element. Both input and output images can be the same instance.
    
    Parameters:
    
    input - The input image. Not modified.
    
    value - What is added to each element.
    
    output - The output image. Modified.
  - plus
```
public static void plus(ImageUInt8 input,
                        int value,
                        int lower,
                        int upper,
                        ImageUInt8 output)
```
    Add a scalar value to each element and bounds the result. Both input and output images can be the same instance.
    
    Parameters:
    
    input - The input image. Not modified.
    
    value - What is added to each element.
    
    lower - Lower bound on output. Inclusive.
    
    upper - Upper bound on output. Inclusive.
    
    output - The output image. Modified.
  - minus
```
public static void minus(ImageUInt8 input,
                         int value,
                         ImageUInt8 output)
```
    Subtracts a scalar value from each element. Both input and output images can be the same instance.
    
    output = input - value
    
    Parameters:
    
    input - The input image. Not modified.
    
    value - What is subtracted from each element in input.
    
    output - The output image. Modified.
  - minus
```
public static void minus(ImageUInt8 input,
                         int value,
                         int lower,
                         int upper,
                         ImageUInt8 output)
```
    Subtracts a scalar value from each element. Both input and output images can be the same instance.
    
    output = input - value
    
    Parameters:
    
    input - The input image. Not modified.
    
    value - What is subtracted from each element.
    
    lower - Lower bound on output. Inclusive.
    
    upper - Upper bound on output. Inclusive.
    
    output - The output image. Modified.
  - minus
```
public static void minus(int value,
                         ImageUInt8 input,
                         ImageUInt8 output)
```
    Subtracts the value of each element from a scalar value. Both input and output images can be the same instance.
    
    output = value - input
    
    Parameters:
    
    value - Value on left side of equation.
    
    input - The input image, elements subtracted from value. Not modified.
    
    output - The output image. Modified.
  - minus
```
public static void minus(int value,
                         ImageUInt8 input,
                         int lower,
                         int upper,
                         ImageUInt8 output)
```
    Subtracts the value of each element from a scalar value. Both input and output images can be the same instance.
    
    output = value - input
    
    Parameters:
    
    value - Left side of equation.
    
    input - The input image. Not modified.
    
    lower - Lower bound on output. Inclusive.
    
    upper - Upper bound on output. Inclusive.
    
    output - The output image. Modified.
  - boundImage
```
public static void boundImage(ImageUInt8 img,
                              int min,
                              int max)
```
    Bounds image pixels to be between these two values
    
    Parameters:
    
    img - Image
    
    min - minimum value.
    
    max - maximum value.
  - diffAbs
```
public static void diffAbs(ImageUInt8 imgA,
                           ImageUInt8 imgB,
                           ImageUInt8 diff)
```
    Computes the absolute value of the difference between each pixel in the two images.
    d(x,y) = |img1(x,y) - img2(x,y)|
    
    Parameters:
    
    imgA - Input image. Not modified.
    
    imgB - Input image. Not modified.
    
    diff - Absolute value of difference image. Modified.
  - averageBand
```
public static void averageBand(MultiSpectral<ImageUInt8> input,
                               ImageUInt8 output)
```
    Computes the average for each pixel across all bands in the MultiSpectral image.
    
    Parameters:
    
    input - MultiSpectral image
    
    output - Gray scale image containing average pixel values
  - multiply
```
public static void multiply(ImageSInt8 input,
                            double value,
                            ImageSInt8 output)
```
    Multiply each element by a scalar value. Both input and output images can be the same instance.
    
    Parameters:
    
    input - The input image. Not modified.
    
    value - What each element is multiplied by.
    
    output - The output image. Modified.
  - multiply
```
public static void multiply(ImageSInt8 input,
                            double value,
                            int lower,
                            int upper,
                            ImageSInt8 output)
```
    Multiply each element by a scalar value and bounds the result. Both input and output images can be the same instance.
    
    Parameters:
    
    input - The input image. Not modified.
    
    value - What each element is multiplied by.
    
    lower - Lower bound on output. Inclusive.
    
    upper - Upper bound on output. Inclusive.
    
    output - The output image. Modified.
  - divide
```
public static void divide(ImageSInt8 input,
                          double denominator,
                          ImageSInt8 output)
```
    Divide each element by a scalar value. Both input and output images can be the same instance.
    
    Parameters:
    
    input - The input image. Not modified.
    
    denominator - What each element is divided by.
    
    output - The output image. Modified.
  - divide
```
public static void divide(ImageSInt8 input,
                          double denominator,
                          int lower,
                          int upper,
                          ImageSInt8 output)
```
    Divide each element by a scalar value and bounds the result. Both input and output images can be the same instance.
    
    Parameters:
    
    input - The input image. Not modified.
    
    denominator - What each element is divided by.
    
    lower - Lower bound on output. Inclusive.
    
    upper - Upper bound on output. Inclusive.
    
    output - The output image. Modified.
  - plus
```
public static void plus(ImageSInt8 input,
                        int value,
                        ImageSInt8 output)
```
    Add a scalar value to each element. Both input and output images can be the same instance.
    
    Parameters:
    
    input - The input image. Not modified.
    
    value - What is added to each element.
    
    output - The output image. Modified.
  - plus
```
public static void plus(ImageSInt8 input,
                        int value,
                        int lower,
                        int upper,
                        ImageSInt8 output)
```
    Add a scalar value to each element and bounds the result. Both input and output images can be the same instance.
    
    Parameters:
    
    input - The input image. Not modified.
    
    value - What is added to each element.
    
    lower - Lower bound on output. Inclusive.
    
    upper - Upper bound on output. Inclusive.
    
    output - The output image. Modified.
  - minus
```
public static void minus(ImageSInt8 input,
                         int value,
                         ImageSInt8 output)
```
    Subtracts a scalar value from each element. Both input and output images can be the same instance.
    
    output = input - value
    
    Parameters:
    
    input - The input image. Not modified.
    
    value - What is subtracted from each element in input.
    
    output - The output image. Modified.
  - minus
```
public static void minus(ImageSInt8 input,
                         int value,
                         int lower,
                         int upper,
                         ImageSInt8 output)
```
    Subtracts a scalar value from each element. Both input and output images can be the same instance.
    
    output = input - value
    
    Parameters:
    
    input - The input image. Not modified.
    
    value - What is subtracted from each element.
    
    lower - Lower bound on output. Inclusive.
    
    upper - Upper bound on output. Inclusive.
    
    output - The output image. Modified.
  - minus
```
public static void minus(int value,
                         ImageSInt8 input,
                         ImageSInt8 output)
```
    Subtracts the value of each element from a scalar value. Both input and output images can be the same instance.
    
    output = value - input
    
    Parameters:
    
    value - Value on left side of equation.
    
    input - The input image, elements subtracted from value. Not modified.
    
    output - The output image. Modified.
  - minus
```
public static void minus(int value,
                         ImageSInt8 input,
                         int lower,
                         int upper,
                         ImageSInt8 output)
```
    Subtracts the value of each element from a scalar value. Both input and output images can be the same instance.
    
    output = value - input
    
    Parameters:
    
    value - Left side of equation.
    
    input - The input image. Not modified.
    
    lower - Lower bound on output. Inclusive.
    
    upper - Upper bound on output. Inclusive.
    
    output - The output image. Modified.
  - boundImage
```
public static void boundImage(ImageSInt8 img,
                              int min,
                              int max)
```
    Bounds image pixels to be between these two values
    
    Parameters:
    
    img - Image
    
    min - minimum value.
    
    max - maximum value.
  - diffAbs
```
public static void diffAbs(ImageSInt8 imgA,
                           ImageSInt8 imgB,
                           ImageSInt8 diff)
```
    Computes the absolute value of the difference between each pixel in the two images.
    d(x,y) = |img1(x,y) - img2(x,y)|
    
    Parameters:
    
    imgA - Input image. Not modified.
    
    imgB - Input image. Not modified.
    
    diff - Absolute value of difference image. Modified.
  - averageBand
```
public static void averageBand(MultiSpectral<ImageSInt8> input,
                               ImageSInt8 output)
```
    Computes the average for each pixel across all bands in the MultiSpectral image.
    
    Parameters:
    
    input - MultiSpectral image
    
    output - Gray scale image containing average pixel values
  - multiply
```
public static void multiply(ImageUInt16 input,
                            double value,
                            ImageUInt16 output)
```
    Multiply each element by a scalar value. Both input and output images can be the same instance.
    
    Parameters:
    
    input - The input image. Not modified.
    
    value - What each element is multiplied by.
    
    output - The output image. Modified.
  - multiply
```
public static void multiply(ImageUInt16 input,
                            double value,
                            int lower,
                            int upper,
                            ImageUInt16 output)
```
    Multiply each element by a scalar value and bounds the result. Both input and output images can be the same instance.
    
    Parameters:
    
    input - The input image. Not modified.
    
    value - What each element is multiplied by.
    
    lower - Lower bound on output. Inclusive.
    
    upper - Upper bound on output. Inclusive.
    
    output - The output image. Modified.
  - divide
```
public static void divide(ImageUInt16 input,
                          double denominator,
                          ImageUInt16 output)
```
    Divide each element by a scalar value. Both input and output images can be the same instance.
    
    Parameters:
    
    input - The input image. Not modified.
    
    denominator - What each element is divided by.
    
    output - The output image. Modified.
  - divide
```
public static void divide(ImageUInt16 input,
                          double denominator,
                          int lower,
                          int upper,
                          ImageUInt16 output)
```
    Divide each element by a scalar value and bounds the result. Both input and output images can be the same instance.
    
    Parameters:
    
    input - The input image. Not modified.
    
    denominator - What each element is divided by.
    
    lower - Lower bound on output. Inclusive.
    
    upper - Upper bound on output. Inclusive.
    
    output - The output image. Modified.
  - plus
```
public static void plus(ImageUInt16 input,
                        int value,
                        ImageUInt16 output)
```
    Add a scalar value to each element. Both input and output images can be the same instance.
    
    Parameters:
    
    input - The input image. Not modified.
    
    value - What is added to each element.
    
    output - The output image. Modified.
  - plus
```
public static void plus(ImageUInt16 input,
                        int value,
                        int lower,
                        int upper,
                        ImageUInt16 output)
```
    Add a scalar value to each element and bounds the result. Both input and output images can be the same instance.
    
    Parameters:
    
    input - The input image. Not modified.
    
    value - What is added to each element.
    
    lower - Lower bound on output. Inclusive.
    
    upper - Upper bound on output. Inclusive.
    
    output - The output image. Modified.
  - minus
```
public static void minus(ImageUInt16 input,
                         int value,
                         ImageUInt16 output)
```
    Subtracts a scalar value from each element. Both input and output images can be the same instance.
    
    output = input - value
    
    Parameters:
    
    input - The input image. Not modified.
    
    value - What is subtracted from each element in input.
    
    output - The output image. Modified.
  - minus
```
public static void minus(ImageUInt16 input,
                         int value,
                         int lower,
                         int upper,
                         ImageUInt16 output)
```
    Subtracts a scalar value from each element. Both input and output images can be the same instance.
    
    output = input - value
    
    Parameters:
    
    input - The input image. Not modified.
    
    value - What is subtracted from each element.
    
    lower - Lower bound on output. Inclusive.
    
    upper - Upper bound on output. Inclusive.
    
    output - The output image. Modified.
  - minus
```
public static void minus(int value,
                         ImageUInt16 input,
                         ImageUInt16 output)
```
    Subtracts the value of each element from a scalar value. Both input and output images can be the same instance.
    
    output = value - input
    
    Parameters:
    
    value - Value on left side of equation.
    
    input - The input image, elements subtracted from value. Not modified.
    
    output - The output image. Modified.
  - minus
```
public static void minus(int value,
                         ImageUInt16 input,
                         int lower,
                         int upper,
                         ImageUInt16 output)
```
    Subtracts the value of each element from a scalar value. Both input and output images can be the same instance.
    
    output = value - input
    
    Parameters:
    
    value - Left side of equation.
    
    input - The input image. Not modified.
    
    lower - Lower bound on output. Inclusive.
    
    upper - Upper bound on output. Inclusive.
    
    output - The output image. Modified.
  - boundImage
```
public static void boundImage(ImageUInt16 img,
                              int min,
                              int max)
```
    Bounds image pixels to be between these two values
    
    Parameters:
    
    img - Image
    
    min - minimum value.
    
    max - maximum value.
  - diffAbs
```
public static void diffAbs(ImageUInt16 imgA,
                           ImageUInt16 imgB,
                           ImageUInt16 diff)
```
    Computes the absolute value of the difference between each pixel in the two images.
    d(x,y) = |img1(x,y) - img2(x,y)|
    
    Parameters:
    
    imgA - Input image. Not modified.
    
    imgB - Input image. Not modified.
    
    diff - Absolute value of difference image. Modified.
  - averageBand
```
public static void averageBand(MultiSpectral<ImageUInt16> input,
                               ImageUInt16 output)
```
    Computes the average for each pixel across all bands in the MultiSpectral image.
    
    Parameters:
    
    input - MultiSpectral image
    
    output - Gray scale image containing average pixel values
  - multiply
```
public static void multiply(ImageSInt16 input,
                            double value,
                            ImageSInt16 output)
```
    Multiply each element by a scalar value. Both input and output images can be the same instance.
    
    Parameters:
    
    input - The input image. Not modified.
    
    value - What each element is multiplied by.
    
    output - The output image. Modified.
  - multiply
```
public static void multiply(ImageSInt16 input,
                            double value,
                            int lower,
                            int upper,
                            ImageSInt16 output)
```
    Multiply each element by a scalar value and bounds the result. Both input and output images can be the same instance.
    
    Parameters:
    
    input - The input image. Not modified.
    
    value - What each element is multiplied by.
    
    lower - Lower bound on output. Inclusive.
    
    upper - Upper bound on output. Inclusive.
    
    output - The output image. Modified.
  - divide
```
public static void divide(ImageSInt16 input,
                          double denominator,
                          ImageSInt16 output)
```
    Divide each element by a scalar value. Both input and output images can be the same instance.
    
    Parameters:
    
    input - The input image. Not modified.
    
    denominator - What each element is divided by.
    
    output - The output image. Modified.
  - divide
```
public static void divide(ImageSInt16 input,
                          double denominator,
                          int lower,
                          int upper,
                          ImageSInt16 output)
```
    Divide each element by a scalar value and bounds the result. Both input and output images can be the same instance.
    
    Parameters:
    
    input - The input image. Not modified.
    
    denominator - What each element is divided by.
    
    lower - Lower bound on output. Inclusive.
    
    upper - Upper bound on output. Inclusive.
    
    output - The output image. Modified.
  - plus
```
public static void plus(ImageSInt16 input,
                        int value,
                        ImageSInt16 output)
```
    Add a scalar value to each element. Both input and output images can be the same instance.
    
    Parameters:
    
    input - The input image. Not modified.
    
    value - What is added to each element.
    
    output - The output image. Modified.
  - plus
```
public static void plus(ImageSInt16 input,
                        int value,
                        int lower,
                        int upper,
                        ImageSInt16 output)
```
    Add a scalar value to each element and bounds the result. Both input and output images can be the same instance.
    
    Parameters:
    
    input - The input image. Not modified.
    
    value - What is added to each element.
    
    lower - Lower bound on output. Inclusive.
    
    upper - Upper bound on output. Inclusive.
    
    output - The output image. Modified.
  - minus
```
public static void minus(ImageSInt16 input,
                         int value,
                         ImageSInt16 output)
```
    Subtracts a scalar value from each element. Both input and output images can be the same instance.
    
    output = input - value
    
    Parameters:
    
    input - The input image. Not modified.
    
    value - What is subtracted from each element in input.
    
    output - The output image. Modified.
  - minus
```
public static void minus(ImageSInt16 input,
                         int value,
                         int lower,
                         int upper,
                         ImageSInt16 output)
```
    Subtracts a scalar value from each element. Both input and output images can be the same instance.
    
    output = input - value
    
    Parameters:
    
    input - The input image. Not modified.
    
    value - What is subtracted from each element.
    
    lower - Lower bound on output. Inclusive.
    
    upper - Upper bound on output. Inclusive.
    
    output - The output image. Modified.
  - minus
```
public static void minus(int value,
                         ImageSInt16 input,
                         ImageSInt16 output)
```
    Subtracts the value of each element from a scalar value. Both input and output images can be the same instance.
    
    output = value - input
    
    Parameters:
    
    value - Value on left side of equation.
    
    input - The input image, elements subtracted from value. Not modified.
    
    output - The output image. Modified.
  - minus
```
public static void minus(int value,
                         ImageSInt16 input,
                         int lower,
                         int upper,
                         ImageSInt16 output)
```
    Subtracts the value of each element from a scalar value. Both input and output images can be the same instance.
    
    output = value - input
    
    Parameters:
    
    value - Left side of equation.
    
    input - The input image. Not modified.
    
    lower - Lower bound on output. Inclusive.
    
    upper - Upper bound on output. Inclusive.
    
    output - The output image. Modified.
  - boundImage
```
public static void boundImage(ImageSInt16 img,
                              int min,
                              int max)
```
    Bounds image pixels to be between these two values
    
    Parameters:
    
    img - Image
    
    min - minimum value.
    
    max - maximum value.
  - diffAbs
```
public static void diffAbs(ImageSInt16 imgA,
                           ImageSInt16 imgB,
                           ImageSInt16 diff)
```
    Computes the absolute value of the difference between each pixel in the two images.
    d(x,y) = |img1(x,y) - img2(x,y)|
    
    Parameters:
    
    imgA - Input image. Not modified.
    
    imgB - Input image. Not modified.
    
    diff - Absolute value of difference image. Modified.
  - averageBand
```
public static void averageBand(MultiSpectral<ImageSInt16> input,
                               ImageSInt16 output)
```
    Computes the average for each pixel across all bands in the MultiSpectral image.
    
    Parameters:
    
    input - MultiSpectral image
    
    output - Gray scale image containing average pixel values
  - multiply
```
public static void multiply(ImageSInt32 input,
                            double value,
                            ImageSInt32 output)
```
    Multiply each element by a scalar value. Both input and output images can be the same instance.
    
    Parameters:
    
    input - The input image. Not modified.
    
    value - What each element is multiplied by.
    
    output - The output image. Modified.
  - multiply
```
public static void multiply(ImageSInt32 input,
                            double value,
                            int lower,
                            int upper,
                            ImageSInt32 output)
```
    Multiply each element by a scalar value and bounds the result. Both input and output images can be the same instance.
    
    Parameters:
    
    input - The input image. Not modified.
    
    value - What each element is multiplied by.
    
    lower - Lower bound on output. Inclusive.
    
    upper - Upper bound on output. Inclusive.
    
    output - The output image. Modified.
  - divide
```
public static void divide(ImageSInt32 input,
                          double denominator,
                          ImageSInt32 output)
```
    Divide each element by a scalar value. Both input and output images can be the same instance.
    
    Parameters:
    
    input - The input image. Not modified.
    
    denominator - What each element is divided by.
    
    output - The output image. Modified.
  - divide
```
public static void divide(ImageSInt32 input,
                          double denominator,
                          int lower,
                          int upper,
                          ImageSInt32 output)
```
    Divide each element by a scalar value and bounds the result. Both input and output images can be the same instance.
    
    Parameters:
    
    input - The input image. Not modified.
    
    denominator - What each element is divided by.
    
    lower - Lower bound on output. Inclusive.
    
    upper - Upper bound on output. Inclusive.
    
    output - The output image. Modified.
  - plus
```
public static void plus(ImageSInt32 input,
                        int value,
                        ImageSInt32 output)
```
    Add a scalar value to each element. Both input and output images can be the same instance.
    
    Parameters:
    
    input - The input image. Not modified.
    
    value - What is added to each element.
    
    output - The output image. Modified.
  - plus
```
public static void plus(ImageSInt32 input,
                        int value,
                        int lower,
                        int upper,
                        ImageSInt32 output)
```
    Add a scalar value to each element and bounds the result. Both input and output images can be the same instance.
    
    Parameters:
    
    input - The input image. Not modified.
    
    value - What is added to each element.
    
    lower - Lower bound on output. Inclusive.
    
    upper - Upper bound on output. Inclusive.
    
    output - The output image. Modified.
  - minus
```
public static void minus(ImageSInt32 input,
                         int value,
                         ImageSInt32 output)
```
    Subtracts a scalar value from each element. Both input and output images can be the same instance.
    
    output = input - value
    
    Parameters:
    
    input - The input image. Not modified.
    
    value - What is subtracted from each element in input.
    
    output - The output image. Modified.
  - minus
```
public static void minus(ImageSInt32 input,
                         int value,
                         int lower,
                         int upper,
                         ImageSInt32 output)
```
    Subtracts a scalar value from each element. Both input and output images can be the same instance.
    
    output = input - value
    
    Parameters:
    
    input - The input image. Not modified.
    
    value - What is subtracted from each element.
    
    lower - Lower bound on output. Inclusive.
    
    upper - Upper bound on output. Inclusive.
    
    output - The output image. Modified.
  - minus
```
public static void minus(int value,
                         ImageSInt32 input,
                         ImageSInt32 output)
```
    Subtracts the value of each element from a scalar value. Both input and output images can be the same instance.
    
    output = value - input
    
    Parameters:
    
    value - Value on left side of equation.
    
    input - The input image, elements subtracted from value. Not modified.
    
    output - The output image. Modified.
  - minus
```
public static void minus(int value,
                         ImageSInt32 input,
                         int lower,
                         int upper,
                         ImageSInt32 output)
```
    Subtracts the value of each element from a scalar value. Both input and output images can be the same instance.
    
    output = value - input
    
    Parameters:
    
    value - Left side of equation.
    
    input - The input image. Not modified.
    
    lower - Lower bound on output. Inclusive.
    
    upper - Upper bound on output. Inclusive.
    
    output - The output image. Modified.
  - boundImage
```
public static void boundImage(ImageSInt32 img,
                              int min,
                              int max)
```
    Bounds image pixels to be between these two values
    
    Parameters:
    
    img - Image
    
    min - minimum value.
    
    max - maximum value.
  - diffAbs
```
public static void diffAbs(ImageSInt32 imgA,
                           ImageSInt32 imgB,
                           ImageSInt32 diff)
```
    Computes the absolute value of the difference between each pixel in the two images.
    d(x,y) = |img1(x,y) - img2(x,y)|
    
    Parameters:
    
    imgA - Input image. Not modified.
    
    imgB - Input image. Not modified.
    
    diff - Absolute value of difference image. Modified.
  - averageBand
```
public static void averageBand(MultiSpectral<ImageSInt32> input,
                               ImageSInt32 output)
```
    Computes the average for each pixel across all bands in the MultiSpectral image.
    
    Parameters:
    
    input - MultiSpectral image
    
    output - Gray scale image containing average pixel values
  - multiply
```
public static void multiply(ImageSInt64 input,
                            double value,
                            ImageSInt64 output)
```
    Multiply each element by a scalar value. Both input and output images can be the same instance.
    
    Parameters:
    
    input - The input image. Not modified.
    
    value - What each element is multiplied by.
    
    output - The output image. Modified.
  - multiply
```
public static void multiply(ImageSInt64 input,
                            double value,
                            long lower,
                            long upper,
                            ImageSInt64 output)
```
    Multiply each element by a scalar value and bounds the result. Both input and output images can be the same instance.
    
    Parameters:
    
    input - The input image. Not modified.
    
    value - What each element is multiplied by.
    
    lower - Lower bound on output. Inclusive.
    
    upper - Upper bound on output. Inclusive.
    
    output - The output image. Modified.
  - divide
```
public static void divide(ImageSInt64 input,
                          double denominator,
                          ImageSInt64 output)
```
    Divide each element by a scalar value. Both input and output images can be the same instance.
    
    Parameters:
    
    input - The input image. Not modified.
    
    denominator - What each element is divided by.
    
    output - The output image. Modified.
  - divide
```
public static void divide(ImageSInt64 input,
                          double denominator,
                          long lower,
                          long upper,
                          ImageSInt64 output)
```
    Divide each element by a scalar value and bounds the result. Both input and output images can be the same instance.
    
    Parameters:
    
    input - The input image. Not modified.
    
    denominator - What each element is divided by.
    
    lower - Lower bound on output. Inclusive.
    
    upper - Upper bound on output. Inclusive.
    
    output - The output image. Modified.
  - plus
```
public static void plus(ImageSInt64 input,
                        long value,
                        ImageSInt64 output)
```
    Add a scalar value to each element. Both input and output images can be the same instance.
    
    Parameters:
    
    input - The input image. Not modified.
    
    value - What is added to each element.
    
    output - The output image. Modified.
  - plus
```
public static void plus(ImageSInt64 input,
                        long value,
                        long lower,
                        long upper,
                        ImageSInt64 output)
```
    Add a scalar value to each element and bounds the result. Both input and output images can be the same instance.
    
    Parameters:
    
    input - The input image. Not modified.
    
    value - What is added to each element.
    
    lower - Lower bound on output. Inclusive.
    
    upper - Upper bound on output. Inclusive.
    
    output - The output image. Modified.
  - minus
```
public static void minus(ImageSInt64 input,
                         long value,
                         ImageSInt64 output)
```
    Subtracts a scalar value from each element. Both input and output images can be the same instance.
    
    output = input - value
    
    Parameters:
    
    input - The input image. Not modified.
    
    value - What is subtracted from each element in input.
    
    output - The output image. Modified.
  - minus
```
public static void minus(ImageSInt64 input,
                         long value,
                         long lower,
                         long upper,
                         ImageSInt64 output)
```
    Subtracts a scalar value from each element. Both input and output images can be the same instance.
    
    output = input - value
    
    Parameters:
    
    input - The input image. Not modified.
    
    value - What is subtracted from each element.
    
    lower - Lower bound on output. Inclusive.
    
    upper - Upper bound on output. Inclusive.
    
    output - The output image. Modified.
  - minus
```
public static void minus(long value,
                         ImageSInt64 input,
                         ImageSInt64 output)
```
    Subtracts the value of each element from a scalar value. Both input and output images can be the same instance.
    
    output = value - input
    
    Parameters:
    
    value - Value on left side of equation.
    
    input - The input image, elements subtracted from value. Not modified.
    
    output - The output image. Modified.
  - minus
```
public static void minus(long value,
                         ImageSInt64 input,
                         long lower,
                         long upper,
                         ImageSInt64 output)
```
    Subtracts the value of each element from a scalar value. Both input and output images can be the same instance.
    
    output = value - input
    
    Parameters:
    
    value - Left side of equation.
    
    input - The input image. Not modified.
    
    lower - Lower bound on output. Inclusive.
    
    upper - Upper bound on output. Inclusive.
    
    output - The output image. Modified.
  - boundImage
```
public static void boundImage(ImageSInt64 img,
                              long min,
                              long max)
```
    Bounds image pixels to be between these two values
    
    Parameters:
    
    img - Image
    
    min - minimum value.
    
    max - maximum value.
  - diffAbs
```
public static void diffAbs(ImageSInt64 imgA,
                           ImageSInt64 imgB,
                           ImageSInt64 diff)
```
    Computes the absolute value of the difference between each pixel in the two images.
    d(x,y) = |img1(x,y) - img2(x,y)|
    
    Parameters:
    
    imgA - Input image. Not modified.
    
    imgB - Input image. Not modified.
    
    diff - Absolute value of difference image. Modified.
  - averageBand
```
public static void averageBand(MultiSpectral<ImageSInt64> input,
                               ImageSInt64 output)
```
    Computes the average for each pixel across all bands in the MultiSpectral image.
    
    Parameters:
    
    input - MultiSpectral image
    
    output - Gray scale image containing average pixel values
  - multiply
```
public static void multiply(ImageFloat32 input,
                            float value,
                            ImageFloat32 output)
```
    Multiply each element by a scalar value. Both input and output images can be the same instance.
    
    Parameters:
    
    input - The input image. Not modified.
    
    value - What each element is multiplied by.
    
    output - The output image. Modified.
  - multiply
```
public static void multiply(ImageFloat32 input,
                            float value,
                            float lower,
                            float upper,
                            ImageFloat32 output)
```
    Multiply each element by a scalar value and bounds the result. Both input and output images can be the same instance.
    
    Parameters:
    
    input - The input image. Not modified.
    
    value - What each element is multiplied by.
    
    lower - Lower bound on output. Inclusive.
    
    upper - Upper bound on output. Inclusive.
    
    output - The output image. Modified.
  - divide
```
public static void divide(ImageFloat32 input,
                          float denominator,
                          ImageFloat32 output)
```
    Divide each element by a scalar value. Both input and output images can be the same instance.
    
    Parameters:
    
    input - The input image. Not modified.
    
    denominator - What each element is divided by.
    
    output - The output image. Modified.
  - divide
```
public static void divide(ImageFloat32 input,
                          float denominator,
                          float lower,
                          float upper,
                          ImageFloat32 output)
```
    Divide each element by a scalar value and bounds the result. Both input and output images can be the same instance.
    
    Parameters:
    
    input - The input image. Not modified.
    
    denominator - What each element is divided by.
    
    lower - Lower bound on output. Inclusive.
    
    upper - Upper bound on output. Inclusive.
    
    output - The output image. Modified.
  - plus
```
public static void plus(ImageFloat32 input,
                        float value,
                        ImageFloat32 output)
```
    Add a scalar value to each element. Both input and output images can be the same instance.
    
    Parameters:
    
    input - The input image. Not modified.
    
    value - What is added to each element.
    
    output - The output image. Modified.
  - plus
```
public static void plus(ImageFloat32 input,
                        float value,
                        float lower,
                        float upper,
                        ImageFloat32 output)
```
    Add a scalar value to each element and bounds the result. Both input and output images can be the same instance.
    
    Parameters:
    
    input - The input image. Not modified.
    
    value - What is added to each element.
    
    lower - Lower bound on output. Inclusive.
    
    upper - Upper bound on output. Inclusive.
    
    output - The output image. Modified.
  - minus
```
public static void minus(ImageFloat32 input,
                         float value,
                         ImageFloat32 output)
```
    Subtracts a scalar value from each element. Both input and output images can be the same instance.
    
    output = input - value
    
    Parameters:
    
    input - The input image. Not modified.
    
    value - What is subtracted from each element in input.
    
    output - The output image. Modified.
  - minus
```
public static void minus(ImageFloat32 input,
                         float value,
                         float lower,
                         float upper,
                         ImageFloat32 output)
```
    Subtracts a scalar value from each element. Both input and output images can be the same instance.
    
    output = input - value
    
    Parameters:
    
    input - The input image. Not modified.
    
    value - What is subtracted from each element.
    
    lower - Lower bound on output. Inclusive.
    
    upper - Upper bound on output. Inclusive.
    
    output - The output image. Modified.
  - minus
```
public static void minus(float value,
                         ImageFloat32 input,
                         ImageFloat32 output)
```
    Subtracts the value of each element from a scalar value. Both input and output images can be the same instance.
    
    output = value - input
    
    Parameters:
    
    value - Value on left side of equation.
    
    input - The input image, elements subtracted from value. Not modified.
    
    output - The output image. Modified.
  - minus
```
public static void minus(float value,
                         ImageFloat32 input,
                         float lower,
                         float upper,
                         ImageFloat32 output)
```
    Subtracts the value of each element from a scalar value. Both input and output images can be the same instance.
    
    output = value - input
    
    Parameters:
    
    value - Left side of equation.
    
    input - The input image. Not modified.
    
    lower - Lower bound on output. Inclusive.
    
    upper - Upper bound on output. Inclusive.
    
    output - The output image. Modified.
  - boundImage
```
public static void boundImage(ImageFloat32 img,
                              float min,
                              float max)
```
    Bounds image pixels to be between these two values
    
    Parameters:
    
    img - Image
    
    min - minimum value.
    
    max - maximum value.
  - diffAbs
```
public static void diffAbs(ImageFloat32 imgA,
                           ImageFloat32 imgB,
                           ImageFloat32 diff)
```
    Computes the absolute value of the difference between each pixel in the two images.
    d(x,y) = |img1(x,y) - img2(x,y)|
    
    Parameters:
    
    imgA - Input image. Not modified.
    
    imgB - Input image. Not modified.
    
    diff - Absolute value of difference image. Modified.
  - averageBand
```
public static void averageBand(MultiSpectral<ImageFloat32> input,
                               ImageFloat32 output)
```
    Computes the average for each pixel across all bands in the MultiSpectral image.
    
    Parameters:
    
    input - MultiSpectral image
    
    output - Gray scale image containing average pixel values
  - multiply
```
public static void multiply(ImageFloat64 input,
                            double value,
                            ImageFloat64 output)
```
    Multiply each element by a scalar value. Both input and output images can be the same instance.
    
    Parameters:
    
    input - The input image. Not modified.
    
    value - What each element is multiplied by.
    
    output - The output image. Modified.
  - multiply
```
public static void multiply(ImageFloat64 input,
                            double value,
                            double lower,
                            double upper,
                            ImageFloat64 output)
```
    Multiply each element by a scalar value and bounds the result. Both input and output images can be the same instance.
    
    Parameters:
    
    input - The input image. Not modified.
    
    value - What each element is multiplied by.
    
    lower - Lower bound on output. Inclusive.
    
    upper - Upper bound on output. Inclusive.
    
    output - The output image. Modified.
  - divide
```
public static void divide(ImageFloat64 input,
                          double denominator,
                          ImageFloat64 output)
```
    Divide each element by a scalar value. Both input and output images can be the same instance.
    
    Parameters:
    
    input - The input image. Not modified.
    
    denominator - What each element is divided by.
    
    output - The output image. Modified.
  - divide
```
public static void divide(ImageFloat64 input,
                          double denominator,
                          double lower,
                          double upper,
                          ImageFloat64 output)
```
    Divide each element by a scalar value and bounds the result. Both input and output images can be the same instance.
    
    Parameters:
    
    input - The input image. Not modified.
    
    denominator - What each element is divided by.
    
    lower - Lower bound on output. Inclusive.
    
    upper - Upper bound on output. Inclusive.
    
    output - The output image. Modified.
  - plus
```
public static void plus(ImageFloat64 input,
                        double value,
                        ImageFloat64 output)
```
    Add a scalar value to each element. Both input and output images can be the same instance.
    
    Parameters:
    
    input - The input image. Not modified.
    
    value - What is added to each element.
    
    output - The output image. Modified.
  - plus
```
public static void plus(ImageFloat64 input,
                        double value,
                        double lower,
                        double upper,
                        ImageFloat64 output)
```
    Add a scalar value to each element and bounds the result. Both input and output images can be the same instance.
    
    Parameters:
    
    input - The input image. Not modified.
    
    value - What is added to each element.
    
    lower - Lower bound on output. Inclusive.
    
    upper - Upper bound on output. Inclusive.
    
    output - The output image. Modified.
  - minus
```
public static void minus(ImageFloat64 input,
                         double value,
                         ImageFloat64 output)
```
    Subtracts a scalar value from each element. Both input and output images can be the same instance.
    
    output = input - value
    
    Parameters:
    
    input - The input image. Not modified.
    
    value - What is subtracted from each element in input.
    
    output - The output image. Modified.
  - minus
```
public static void minus(ImageFloat64 input,
                         double value,
                         double lower,
                         double upper,
                         ImageFloat64 output)
```
    Subtracts a scalar value from each element. Both input and output images can be the same instance.
    
    output = input - value
    
    Parameters:
    
    input - The input image. Not modified.
    
    value - What is subtracted from each element.
    
    lower - Lower bound on output. Inclusive.
    
    upper - Upper bound on output. Inclusive.
    
    output - The output image. Modified.
  - minus
```
public static void minus(double value,
                         ImageFloat64 input,
                         ImageFloat64 output)
```
    Subtracts the value of each element from a scalar value. Both input and output images can be the same instance.
    
    output = value - input
    
    Parameters:
    
    value - Value on left side of equation.
    
    input - The input image, elements subtracted from value. Not modified.
    
    output - The output image. Modified.
  - minus
```
public static void minus(double value,
                         ImageFloat64 input,
                         double lower,
                         double upper,
                         ImageFloat64 output)
```
    Subtracts the value of each element from a scalar value. Both input and output images can be the same instance.
    
    output = value - input
    
    Parameters:
    
    value - Left side of equation.
    
    input - The input image. Not modified.
    
    lower - Lower bound on output. Inclusive.
    
    upper - Upper bound on output. Inclusive.
    
    output - The output image. Modified.
  - boundImage
```
public static void boundImage(ImageFloat64 img,
                              double min,
                              double max)
```
    Bounds image pixels to be between these two values
    
    Parameters:
    
    img - Image
    
    min - minimum value.
    
    max - maximum value.
  - diffAbs
```
public static void diffAbs(ImageFloat64 imgA,
                           ImageFloat64 imgB,
                           ImageFloat64 diff)
```
    Computes the absolute value of the difference between each pixel in the two images.
    d(x,y) = |img1(x,y) - img2(x,y)|
    
    Parameters:
    
    imgA - Input image. Not modified.
    
    imgB - Input image. Not modified.
    
    diff - Absolute value of difference image. Modified.
  - averageBand
```
public static void averageBand(MultiSpectral<ImageFloat64> input,
                               ImageFloat64 output)
```
    Computes the average for each pixel across all bands in the MultiSpectral image.
    
    Parameters:
    
    input - MultiSpectral image
    
    output - Gray scale image containing average pixel values
  - add
```
public static void add(ImageUInt8 imgA,
                       ImageUInt8 imgB,
                       ImageUInt16 output)
```
    Performs pixel-wise addition
    output(x,y) = imgA(x,y) + imgB(x,y)
    
    Parameters:
    
    imgA - Input image. Not modified.
    
    imgB - Input image. Not modified.
    
    output - Output image. Modified.
  - subtract
```
public static void subtract(ImageUInt8 imgA,
                            ImageUInt8 imgB,
                            ImageInt16 output)
```
    Performs pixel-wise subtraction.
    output(x,y) = imgA(x,y) - imgB(x,y)
    
    Parameters:
    
    imgA - Input image. Not modified.
    
    imgB - Input image. Not modified.
    
    output - Output image. Modified.
  - add
```
public static void add(ImageSInt8 imgA,
                       ImageSInt8 imgB,
                       ImageSInt16 output)
```
    Performs pixel-wise addition
    output(x,y) = imgA(x,y) + imgB(x,y)
    
    Parameters:
    
    imgA - Input image. Not modified.
    
    imgB - Input image. Not modified.
    
    output - Output image. Modified.
  - subtract
```
public static void subtract(ImageSInt8 imgA,
                            ImageSInt8 imgB,
                            ImageSInt16 output)
```
    Performs pixel-wise subtraction.
    output(x,y) = imgA(x,y) - imgB(x,y)
    
    Parameters:
    
    imgA - Input image. Not modified.
    
    imgB - Input image. Not modified.
    
    output - Output image. Modified.
  - add
```
public static void add(ImageUInt16 imgA,
                       ImageUInt16 imgB,
                       ImageSInt32 output)
```
    Performs pixel-wise addition
    output(x,y) = imgA(x,y) + imgB(x,y)
    
    Parameters:
    
    imgA - Input image. Not modified.
    
    imgB - Input image. Not modified.
    
    output - Output image. Modified.
  - subtract
```
public static void subtract(ImageUInt16 imgA,
                            ImageUInt16 imgB,
                            ImageSInt32 output)
```
    Performs pixel-wise subtraction.
    output(x,y) = imgA(x,y) - imgB(x,y)
    
    Parameters:
    
    imgA - Input image. Not modified.
    
    imgB - Input image. Not modified.
    
    output - Output image. Modified.
  - add
```
public static void add(ImageSInt16 imgA,
                       ImageSInt16 imgB,
                       ImageSInt32 output)
```
    Performs pixel-wise addition
    output(x,y) = imgA(x,y) + imgB(x,y)
    
    Parameters:
    
    imgA - Input image. Not modified.
    
    imgB - Input image. Not modified.
    
    output - Output image. Modified.
  - subtract
```
public static void subtract(ImageSInt16 imgA,
                            ImageSInt16 imgB,
                            ImageSInt32 output)
```
    Performs pixel-wise subtraction.
    output(x,y) = imgA(x,y) - imgB(x,y)
    
    Parameters:
    
    imgA - Input image. Not modified.
    
    imgB - Input image. Not modified.
    
    output - Output image. Modified.
  - add
```
public static void add(ImageSInt32 imgA,
                       ImageSInt32 imgB,
                       ImageSInt32 output)
```
    Performs pixel-wise addition
    output(x,y) = imgA(x,y) + imgB(x,y)
    
    Parameters:
    
    imgA - Input image. Not modified.
    
    imgB - Input image. Not modified.
    
    output - Output image. Modified.
  - subtract
```
public static void subtract(ImageSInt32 imgA,
                            ImageSInt32 imgB,
                            ImageSInt32 output)
```
    Performs pixel-wise subtraction.
    output(x,y) = imgA(x,y) - imgB(x,y)
    
    Parameters:
    
    imgA - Input image. Not modified.
    
    imgB - Input image. Not modified.
    
    output - Output image. Modified.
  - add
```
public static void add(ImageSInt64 imgA,
                       ImageSInt64 imgB,
                       ImageSInt64 output)
```
    Performs pixel-wise addition
    output(x,y) = imgA(x,y) + imgB(x,y)
    
    Parameters:
    
    imgA - Input image. Not modified.
    
    imgB - Input image. Not modified.
    
    output - Output image. Modified.
  - subtract
```
public static void subtract(ImageSInt64 imgA,
                            ImageSInt64 imgB,
                            ImageSInt64 output)
```
    Performs pixel-wise subtraction.
    output(x,y) = imgA(x,y) - imgB(x,y)
    
    Parameters:
    
    imgA - Input image. Not modified.
    
    imgB - Input image. Not modified.
    
    output - Output image. Modified.
  - add
```
public static void add(ImageFloat32 imgA,
                       ImageFloat32 imgB,
                       ImageFloat32 output)
```
    Performs pixel-wise addition
    output(x,y) = imgA(x,y) + imgB(x,y)
    
    Parameters:
    
    imgA - Input image. Not modified.
    
    imgB - Input image. Not modified.
    
    output - Output image. Modified.
  - subtract
```
public static void subtract(ImageFloat32 imgA,
                            ImageFloat32 imgB,
                            ImageFloat32 output)
```
    Performs pixel-wise subtraction.
    output(x,y) = imgA(x,y) - imgB(x,y)
    
    Parameters:
    
    imgA - Input image. Not modified.
    
    imgB - Input image. Not modified.
    
    output - Output image. Modified.
  - multiply
```
public static void multiply(ImageFloat32 imgA,
                            ImageFloat32 imgB,
                            ImageFloat32 output)
```
    Performs pixel-wise multiplication
    output(x,y) = imgA(x,y) * imgB(x,y)
    
    Parameters:
    
    imgA - Input image. Not modified.
    
    imgB - Input image. Not modified.
    
    output - Output image. Modified.
  - divide
```
public static void divide(ImageFloat32 imgA,
                          ImageFloat32 imgB,
                          ImageFloat32 output)
```
    Performs pixel-wise division
    output(x,y) = imgA(x,y) / imgB(x,y)
    
    Parameters:
    
    imgA - Input image. Not modified.
    
    imgB - Input image. Not modified.
    
    output - Output image. Modified.
  - log
```
public static void log(ImageFloat32 input,
                       ImageFloat32 output)
```
    Sets each pixel in the output image to log( 1 + input(x,y)) of the input image. Both the input and output image can be the same instance.
    
    Parameters:
    
    input - The input image. Not modified.
    
    output - Where the log image is written to. Modified.
  - pow2
```
public static void pow2(ImageFloat32 input,
                        ImageFloat32 output)
```
    Raises each pixel in the input image to the power of two. Both the input and output image can be the same instance. *
    
    Parameters:
    
    input - The input image. Not modified.
    
    output - Where the pow2 image is written to. Modified.
  - sqrt
```
public static void sqrt(ImageFloat32 input,
                        ImageFloat32 output)
```
    Computes the square root of each pixel in the input image. Both the input and output image can be the same instance.
    
    Parameters:
    
    input - The input image. Not modified.
    
    output - Where the sqrt() image is written to. Modified.
  - add
```
public static void add(ImageFloat64 imgA,
                       ImageFloat64 imgB,
                       ImageFloat64 output)
```
    Performs pixel-wise addition
    output(x,y) = imgA(x,y) + imgB(x,y)
    
    Parameters:
    
    imgA - Input image. Not modified.
    
    imgB - Input image. Not modified.
    
    output - Output image. Modified.
  - subtract
```
public static void subtract(ImageFloat64 imgA,
                            ImageFloat64 imgB,
                            ImageFloat64 output)
```
    Performs pixel-wise subtraction.
    output(x,y) = imgA(x,y) - imgB(x,y)
    
    Parameters:
    
    imgA - Input image. Not modified.
    
    imgB - Input image. Not modified.
    
    output - Output image. Modified.
  - multiply
```
public static void multiply(ImageFloat64 imgA,
                            ImageFloat64 imgB,
                            ImageFloat64 output)
```
    Performs pixel-wise multiplication
    output(x,y) = imgA(x,y) * imgB(x,y)
    
    Parameters:
    
    imgA - Input image. Not modified.
    
    imgB - Input image. Not modified.
    
    output - Output image. Modified.
  - divide
```
public static void divide(ImageFloat64 imgA,
                          ImageFloat64 imgB,
                          ImageFloat64 output)
```
    Performs pixel-wise division
    output(x,y) = imgA(x,y) / imgB(x,y)
    
    Parameters:
    
    imgA - Input image. Not modified.
    
    imgB - Input image. Not modified.
    
    output - Output image. Modified.
  - log
```
public static void log(ImageFloat64 input,
                       ImageFloat64 output)
```
    Sets each pixel in the output image to log( 1 + input(x,y)) of the input image. Both the input and output image can be the same instance.
    
    Parameters:
    
    input - The input image. Not modified.
    
    output - Where the log image is written to. Modified.
  - pow2
```
public static void pow2(ImageFloat64 input,
                        ImageFloat64 output)
```
    Raises each pixel in the input image to the power of two. Both the input and output image can be the same instance. *
    
    Parameters:
    
    input - The input image. Not modified.
    
    output - Where the pow2 image is written to. Modified.
  - sqrt
```
public static void sqrt(ImageFloat64 input,
                        ImageFloat64 output)
```
    Computes the square root of each pixel in the input image. Both the input and output image can be the same instance.
    
    Parameters:
    
    input - The input image. Not modified.
    
    output - Where the sqrt() image is written to. Modified.

Class PixelMath

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

PixelMath

Method Detail

abs

invert

abs

invert

abs

invert

abs

invert

abs

invert

abs

invert

multiply

multiply

divide

divide

plus

plus

minus

minus

minus

minus

boundImage

diffAbs

averageBand

multiply

multiply

divide

divide

plus

plus

minus

minus

minus

minus

boundImage

diffAbs

averageBand

multiply

multiply

divide

divide

plus

plus

minus

minus

minus

minus

boundImage

diffAbs

averageBand

multiply

multiply

divide

divide

plus

plus

minus

minus

minus

minus

boundImage

diffAbs

averageBand

multiply

multiply

divide

divide

plus

plus

minus

minus

minus