PixelMath (ip 0.22 API)

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

```
@Generated(value="boofcv.alg.misc.GeneratePixelMath")
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`	`abs(InterleavedF32 input, InterleavedF32 output)` Sets each pixel in the output image to be the absolute value of the input image.
`static void`	`abs(InterleavedF64 input, InterleavedF64 output)` Sets each pixel in the output image to be the absolute value of the input image.
`static void`	`abs(InterleavedS16 input, InterleavedS16 output)` Sets each pixel in the output image to be the absolute value of the input image.
`static void`	`abs(InterleavedS32 input, InterleavedS32 output)` Sets each pixel in the output image to be the absolute value of the input image.
`static void`	`abs(InterleavedS64 input, InterleavedS64 output)` Sets each pixel in the output image to be the absolute value of the input image.
`static void`	`abs(InterleavedS8 input, InterleavedS8 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.
`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.
`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.
`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.
`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.
`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.
`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.
`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.
`static void`	`divide(InterleavedF32 input, float denominator, float lower, float upper, InterleavedF32 output)` Divide each element by a scalar value.
`static void`	`divide(InterleavedF32 input, float denominator, InterleavedF32 output)` Divide each element by a scalar value.
`static void`	`divide(InterleavedF64 input, double denominator, double lower, double upper, InterleavedF64 output)` Divide each element by a scalar value.
`static void`	`divide(InterleavedF64 input, double denominator, InterleavedF64 output)` Divide each element by a scalar value.
`static void`	`divide(InterleavedS16 input, double denominator, InterleavedS16 output)` Divide each element by a scalar value.
`static void`	`divide(InterleavedS16 input, double denominator, int lower, int upper, InterleavedS16 output)` Divide each element by a scalar value.
`static void`	`divide(InterleavedS32 input, double denominator, InterleavedS32 output)` Divide each element by a scalar value.
`static void`	`divide(InterleavedS32 input, double denominator, int lower, int upper, InterleavedS32 output)` Divide each element by a scalar value.
`static void`	`divide(InterleavedS64 input, double denominator, InterleavedS64 output)` Divide each element by a scalar value.
`static void`	`divide(InterleavedS64 input, double denominator, long lower, long upper, InterleavedS64 output)` Divide each element by a scalar value.
`static void`	`divide(InterleavedS8 input, double denominator, InterleavedS8 output)` Divide each element by a scalar value.
`static void`	`divide(InterleavedS8 input, double denominator, int lower, int upper, InterleavedS8 output)` Divide each element by a scalar value.
`static void`	`divide(InterleavedU16 input, double denominator, InterleavedU16 output)` Divide each element by a scalar value.
`static void`	`divide(InterleavedU16 input, double denominator, int lower, int upper, InterleavedU16 output)` Divide each element by a scalar value.
`static void`	`divide(InterleavedU8 input, double denominator, InterleavedU8 output)` Divide each element by a scalar value.
`static void`	`divide(InterleavedU8 input, double denominator, int lower, int upper, InterleavedU8 output)` Divide each element by a scalar value.
`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`	`invert(InterleavedF32 input, InterleavedF32 output)` Changes the sign of every pixel in the image: output[x,y] = -input[x,y]
`static void`	`invert(InterleavedF64 input, InterleavedF64 output)` Changes the sign of every pixel in the image: output[x,y] = -input[x,y]
`static void`	`invert(InterleavedS16 input, InterleavedS16 output)` Changes the sign of every pixel in the image: output[x,y] = -input[x,y]
`static void`	`invert(InterleavedS32 input, InterleavedS32 output)` Changes the sign of every pixel in the image: output[x,y] = -input[x,y]
`static void`	`invert(InterleavedS64 input, InterleavedS64 output)` Changes the sign of every pixel in the image: output[x,y] = -input[x,y]
`static void`	`invert(InterleavedS8 input, InterleavedS8 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 each element's value from a scalar.
`static void`	`minus(double value, ImageFloat64 input, ImageFloat64 output)` Subtracts each element's value from a scalar.
`static void`	`minus(double value, InterleavedF64 input, double lower, double upper, InterleavedF64 output)` Subtracts each element's value from a scalar.
`static void`	`minus(double value, InterleavedF64 input, InterleavedF64 output)` Subtracts each element's value from a scalar.
`static void`	`minus(float value, ImageFloat32 input, float lower, float upper, ImageFloat32 output)` Subtracts each element's value from a scalar.
`static void`	`minus(float value, ImageFloat32 input, ImageFloat32 output)` Subtracts each element's value from a scalar.
`static void`	`minus(float value, InterleavedF32 input, float lower, float upper, InterleavedF32 output)` Subtracts each element's value from a scalar.
`static void`	`minus(float value, InterleavedF32 input, InterleavedF32 output)` Subtracts each element's value from a scalar.
`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(InterleavedF32 input, float value, float lower, float upper, InterleavedF32 output)` Subtracts a scalar value from each element.
`static void`	`minus(InterleavedF32 input, float value, InterleavedF32 output)` Subtracts a scalar value from each element.
`static void`	`minus(InterleavedF64 input, double value, double lower, double upper, InterleavedF64 output)` Subtracts a scalar value from each element.
`static void`	`minus(InterleavedF64 input, double value, InterleavedF64 output)` Subtracts a scalar value from each element.
`static void`	`minus(InterleavedS16 input, int value, InterleavedS16 output)` Subtracts a scalar value from each element.
`static void`	`minus(InterleavedS16 input, int value, int lower, int upper, InterleavedS16 output)` Subtracts a scalar value from each element.
`static void`	`minus(InterleavedS32 input, int value, InterleavedS32 output)` Subtracts a scalar value from each element.
`static void`	`minus(InterleavedS32 input, int value, int lower, int upper, InterleavedS32 output)` Subtracts a scalar value from each element.
`static void`	`minus(InterleavedS64 input, long value, InterleavedS64 output)` Subtracts a scalar value from each element.
`static void`	`minus(InterleavedS64 input, long value, long lower, long upper, InterleavedS64 output)` Subtracts a scalar value from each element.
`static void`	`minus(InterleavedS8 input, int value, InterleavedS8 output)` Subtracts a scalar value from each element.
`static void`	`minus(InterleavedS8 input, int value, int lower, int upper, InterleavedS8 output)` Subtracts a scalar value from each element.
`static void`	`minus(InterleavedU16 input, int value, InterleavedU16 output)` Subtracts a scalar value from each element.
`static void`	`minus(InterleavedU16 input, int value, int lower, int upper, InterleavedU16 output)` Subtracts a scalar value from each element.
`static void`	`minus(InterleavedU8 input, int value, InterleavedU8 output)` Subtracts a scalar value from each element.
`static void`	`minus(InterleavedU8 input, int value, int lower, int upper, InterleavedU8 output)` Subtracts a scalar value from each element.
`static void`	`minus(int value, ImageSInt16 input, ImageSInt16 output)` Subtracts each element's value from a scalar.
`static void`	`minus(int value, ImageSInt16 input, int lower, int upper, ImageSInt16 output)` Subtracts each element's value from a scalar.
`static void`	`minus(int value, ImageSInt32 input, ImageSInt32 output)` Subtracts each element's value from a scalar.
`static void`	`minus(int value, ImageSInt32 input, int lower, int upper, ImageSInt32 output)` Subtracts each element's value from a scalar.
`static void`	`minus(int value, ImageSInt8 input, ImageSInt8 output)` Subtracts each element's value from a scalar.
`static void`	`minus(int value, ImageSInt8 input, int lower, int upper, ImageSInt8 output)` Subtracts each element's value from a scalar.
`static void`	`minus(int value, ImageUInt16 input, ImageUInt16 output)` Subtracts each element's value from a scalar.
`static void`	`minus(int value, ImageUInt16 input, int lower, int upper, ImageUInt16 output)` Subtracts each element's value from a scalar.
`static void`	`minus(int value, ImageUInt8 input, ImageUInt8 output)` Subtracts each element's value from a scalar.
`static void`	`minus(int value, ImageUInt8 input, int lower, int upper, ImageUInt8 output)` Subtracts each element's value from a scalar.
`static void`	`minus(int value, InterleavedS16 input, InterleavedS16 output)` Subtracts each element's value from a scalar.
`static void`	`minus(int value, InterleavedS16 input, int lower, int upper, InterleavedS16 output)` Subtracts each element's value from a scalar.
`static void`	`minus(int value, InterleavedS32 input, InterleavedS32 output)` Subtracts each element's value from a scalar.
`static void`	`minus(int value, InterleavedS32 input, int lower, int upper, InterleavedS32 output)` Subtracts each element's value from a scalar.
`static void`	`minus(int value, InterleavedS8 input, InterleavedS8 output)` Subtracts each element's value from a scalar.
`static void`	`minus(int value, InterleavedS8 input, int lower, int upper, InterleavedS8 output)` Subtracts each element's value from a scalar.
`static void`	`minus(int value, InterleavedU16 input, InterleavedU16 output)` Subtracts each element's value from a scalar.
`static void`	`minus(int value, InterleavedU16 input, int lower, int upper, InterleavedU16 output)` Subtracts each element's value from a scalar.
`static void`	`minus(int value, InterleavedU8 input, InterleavedU8 output)` Subtracts each element's value from a scalar.
`static void`	`minus(int value, InterleavedU8 input, int lower, int upper, InterleavedU8 output)` Subtracts each element's value from a scalar.
`static void`	`minus(long value, ImageSInt64 input, ImageSInt64 output)` Subtracts each element's value from a scalar.
`static void`	`minus(long value, ImageSInt64 input, long lower, long upper, ImageSInt64 output)` Subtracts each element's value from a scalar.
`static void`	`minus(long value, InterleavedS64 input, InterleavedS64 output)` Subtracts each element's value from a scalar.
`static void`	`minus(long value, InterleavedS64 input, long lower, long upper, InterleavedS64 output)` Subtracts each element's value from a scalar.
`static void`	`multiply(ImageFloat32 input, float value, float lower, float upper, ImageFloat32 output)` Multiply each element by a scalar value.
`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.
`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.
`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.
`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.
`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.
`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.
`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.
`static void`	`multiply(InterleavedF32 input, float value, float lower, float upper, InterleavedF32 output)` Multiply each element by a scalar value.
`static void`	`multiply(InterleavedF32 input, float value, InterleavedF32 output)` Multiply each element by a scalar value.
`static void`	`multiply(InterleavedF64 input, double value, double lower, double upper, InterleavedF64 output)` Multiply each element by a scalar value.
`static void`	`multiply(InterleavedF64 input, double value, InterleavedF64 output)` Multiply each element by a scalar value.
`static void`	`multiply(InterleavedS16 input, double value, InterleavedS16 output)` Multiply each element by a scalar value.
`static void`	`multiply(InterleavedS16 input, double value, int lower, int upper, InterleavedS16 output)` Multiply each element by a scalar value.
`static void`	`multiply(InterleavedS32 input, double value, InterleavedS32 output)` Multiply each element by a scalar value.
`static void`	`multiply(InterleavedS32 input, double value, int lower, int upper, InterleavedS32 output)` Multiply each element by a scalar value.
`static void`	`multiply(InterleavedS64 input, double value, InterleavedS64 output)` Multiply each element by a scalar value.
`static void`	`multiply(InterleavedS64 input, double value, long lower, long upper, InterleavedS64 output)` Multiply each element by a scalar value.
`static void`	`multiply(InterleavedS8 input, double value, InterleavedS8 output)` Multiply each element by a scalar value.
`static void`	`multiply(InterleavedS8 input, double value, int lower, int upper, InterleavedS8 output)` Multiply each element by a scalar value.
`static void`	`multiply(InterleavedU16 input, double value, InterleavedU16 output)` Multiply each element by a scalar value.
`static void`	`multiply(InterleavedU16 input, double value, int lower, int upper, InterleavedU16 output)` Multiply each element by a scalar value.
`static void`	`multiply(InterleavedU8 input, double value, InterleavedU8 output)` Multiply each element by a scalar value.
`static void`	`multiply(InterleavedU8 input, double value, int lower, int upper, InterleavedU8 output)` Multiply each element by a scalar value.
`static void`	`plus(ImageFloat32 input, float value, float lower, float upper, ImageFloat32 output)` Adds a scalar value to each element.
`static void`	`plus(ImageFloat32 input, float value, ImageFloat32 output)` Adds a scalar value to each element.
`static void`	`plus(ImageFloat64 input, double value, double lower, double upper, ImageFloat64 output)` Adds a scalar value to each element.
`static void`	`plus(ImageFloat64 input, double value, ImageFloat64 output)` Adds a scalar value to each element.
`static void`	`plus(ImageSInt16 input, int value, ImageSInt16 output)` Adds a scalar value to each element.
`static void`	`plus(ImageSInt16 input, int value, int lower, int upper, ImageSInt16 output)` Adds a scalar value to each element.
`static void`	`plus(ImageSInt32 input, int value, ImageSInt32 output)` Adds a scalar value to each element.
`static void`	`plus(ImageSInt32 input, int value, int lower, int upper, ImageSInt32 output)` Adds a scalar value to each element.
`static void`	`plus(ImageSInt64 input, long value, ImageSInt64 output)` Adds a scalar value to each element.
`static void`	`plus(ImageSInt64 input, long value, long lower, long upper, ImageSInt64 output)` Adds a scalar value to each element.
`static void`	`plus(ImageSInt8 input, int value, ImageSInt8 output)` Adds a scalar value to each element.
`static void`	`plus(ImageSInt8 input, int value, int lower, int upper, ImageSInt8 output)` Adds a scalar value to each element.
`static void`	`plus(ImageUInt16 input, int value, ImageUInt16 output)` Adds a scalar value to each element.
`static void`	`plus(ImageUInt16 input, int value, int lower, int upper, ImageUInt16 output)` Adds a scalar value to each element.
`static void`	`plus(ImageUInt8 input, int value, ImageUInt8 output)` Adds a scalar value to each element.
`static void`	`plus(ImageUInt8 input, int value, int lower, int upper, ImageUInt8 output)` Adds a scalar value to each element.
`static void`	`plus(InterleavedF32 input, float value, float lower, float upper, InterleavedF32 output)` Adds a scalar value to each element.
`static void`	`plus(InterleavedF32 input, float value, InterleavedF32 output)` Adds a scalar value to each element.
`static void`	`plus(InterleavedF64 input, double value, double lower, double upper, InterleavedF64 output)` Adds a scalar value to each element.
`static void`	`plus(InterleavedF64 input, double value, InterleavedF64 output)` Adds a scalar value to each element.
`static void`	`plus(InterleavedS16 input, int value, InterleavedS16 output)` Adds a scalar value to each element.
`static void`	`plus(InterleavedS16 input, int value, int lower, int upper, InterleavedS16 output)` Adds a scalar value to each element.
`static void`	`plus(InterleavedS32 input, int value, InterleavedS32 output)` Adds a scalar value to each element.
`static void`	`plus(InterleavedS32 input, int value, int lower, int upper, InterleavedS32 output)` Adds a scalar value to each element.
`static void`	`plus(InterleavedS64 input, long value, InterleavedS64 output)` Adds a scalar value to each element.
`static void`	`plus(InterleavedS64 input, long value, long lower, long upper, InterleavedS64 output)` Adds a scalar value to each element.
`static void`	`plus(InterleavedS8 input, int value, InterleavedS8 output)` Adds a scalar value to each element.
`static void`	`plus(InterleavedS8 input, int value, int lower, int upper, InterleavedS8 output)` Adds a scalar value to each element.
`static void`	`plus(InterleavedU16 input, int value, InterleavedU16 output)` Adds a scalar value to each element.
`static void`	`plus(InterleavedU16 input, int value, int lower, int upper, InterleavedU16 output)` Adds a scalar value to each element.
`static void`	`plus(InterleavedU8 input, int value, InterleavedU8 output)` Adds a scalar value to each element.
`static void`	`plus(InterleavedU8 input, int value, int lower, int upper, InterleavedU8 output)` Adds a scalar value to each element.
`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.
  - abs
```
public static void abs(InterleavedS8 input,
                       InterleavedS8 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.
  - 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.
  - abs
```
public static void abs(InterleavedS16 input,
                       InterleavedS16 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.
  - 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.
  - abs
```
public static void abs(InterleavedS32 input,
                       InterleavedS32 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.
  - 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.
  - abs
```
public static void abs(InterleavedS64 input,
                       InterleavedS64 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.
  - 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.
  - abs
```
public static void abs(InterleavedF32 input,
                       InterleavedF32 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.
  - 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.
  - abs
```
public static void abs(InterleavedF64 input,
                       InterleavedF64 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.
  - invert
```
public static void invert(InterleavedS8 input,
                          InterleavedS8 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.
  - 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.
  - invert
```
public static void invert(InterleavedS16 input,
                          InterleavedS16 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.
  - 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.
  - invert
```
public static void invert(InterleavedS32 input,
                          InterleavedS32 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.
  - 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.
  - invert
```
public static void invert(InterleavedS64 input,
                          InterleavedS64 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.
  - 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.
  - invert
```
public static void invert(InterleavedF32 input,
                          InterleavedF32 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.
  - 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.
  - invert
```
public static void invert(InterleavedF64 input,
                          InterleavedF64 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(InterleavedU8 input,
                            double value,
                            InterleavedU8 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,
                            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(InterleavedS8 input,
                            double value,
                            InterleavedS8 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,
                            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(InterleavedU16 input,
                            double value,
                            InterleavedU16 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,
                            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(InterleavedS16 input,
                            double value,
                            InterleavedS16 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,
                            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(InterleavedS32 input,
                            double value,
                            InterleavedS32 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,
                            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(InterleavedS64 input,
                            double value,
                            InterleavedS64 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,
                            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(InterleavedF32 input,
                            float value,
                            InterleavedF32 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,
                            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(InterleavedF64 input,
                            double value,
                            InterleavedF64 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. 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(InterleavedU8 input,
                            double value,
                            int lower,
                            int upper,
                            InterleavedU8 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. 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(InterleavedS8 input,
                            double value,
                            int lower,
                            int upper,
                            InterleavedS8 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. 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(InterleavedU16 input,
                            double value,
                            int lower,
                            int upper,
                            InterleavedU16 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. 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(InterleavedS16 input,
                            double value,
                            int lower,
                            int upper,
                            InterleavedS16 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. 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(InterleavedS32 input,
                            double value,
                            int lower,
                            int upper,
                            InterleavedS32 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. 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(InterleavedS64 input,
                            double value,
                            long lower,
                            long upper,
                            InterleavedS64 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. 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(InterleavedF32 input,
                            float value,
                            float lower,
                            float upper,
                            InterleavedF32 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. 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(InterleavedF64 input,
                            double value,
                            double lower,
                            double upper,
                            InterleavedF64 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.
  - 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(InterleavedU8 input,
                          double denominator,
                          InterleavedU8 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,
                          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(InterleavedS8 input,
                          double denominator,
                          InterleavedS8 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,
                          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(InterleavedU16 input,
                          double denominator,
                          InterleavedU16 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,
                          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(InterleavedS16 input,
                          double denominator,
                          InterleavedS16 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,
                          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(InterleavedS32 input,
                          double denominator,
                          InterleavedS32 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,
                          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(InterleavedS64 input,
                          double denominator,
                          InterleavedS64 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,
                          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(InterleavedF32 input,
                          float denominator,
                          InterleavedF32 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,
                          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(InterleavedF64 input,
                          double denominator,
                          InterleavedF64 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. 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(InterleavedU8 input,
                          double denominator,
                          int lower,
                          int upper,
                          InterleavedU8 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. 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(InterleavedS8 input,
                          double denominator,
                          int lower,
                          int upper,
                          InterleavedS8 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. 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(InterleavedU16 input,
                          double denominator,
                          int lower,
                          int upper,
                          InterleavedU16 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. 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(InterleavedS16 input,
                          double denominator,
                          int lower,
                          int upper,
                          InterleavedS16 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. 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(InterleavedS32 input,
                          double denominator,
                          int lower,
                          int upper,
                          InterleavedS32 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. 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(InterleavedS64 input,
                          double denominator,
                          long lower,
                          long upper,
                          InterleavedS64 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. 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(InterleavedF32 input,
                          float denominator,
                          float lower,
                          float upper,
                          InterleavedF32 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. 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(InterleavedF64 input,
                          double denominator,
                          double lower,
                          double upper,
                          InterleavedF64 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.
  - plus
```
public static void plus(ImageUInt8 input,
                        int value,
                        ImageUInt8 output)
```
    Adds 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(InterleavedU8 input,
                        int value,
                        InterleavedU8 output)
```
    Adds 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,
                        ImageSInt8 output)
```
    Adds 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(InterleavedS8 input,
                        int value,
                        InterleavedS8 output)
```
    Adds 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,
                        ImageUInt16 output)
```
    Adds 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(InterleavedU16 input,
                        int value,
                        InterleavedU16 output)
```
    Adds 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,
                        ImageSInt16 output)
```
    Adds 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(InterleavedS16 input,
                        int value,
                        InterleavedS16 output)
```
    Adds 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,
                        ImageSInt32 output)
```
    Adds 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(InterleavedS32 input,
                        int value,
                        InterleavedS32 output)
```
    Adds 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,
                        ImageSInt64 output)
```
    Adds 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(InterleavedS64 input,
                        long value,
                        InterleavedS64 output)
```
    Adds 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,
                        ImageFloat32 output)
```
    Adds 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(InterleavedF32 input,
                        float value,
                        InterleavedF32 output)
```
    Adds 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,
                        ImageFloat64 output)
```
    Adds 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(InterleavedF64 input,
                        double value,
                        InterleavedF64 output)
```
    Adds 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)
```
    Adds 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(InterleavedU8 input,
                        int value,
                        int lower,
                        int upper,
                        InterleavedU8 output)
```
    Adds 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)
```
    Adds 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(InterleavedS8 input,
                        int value,
                        int lower,
                        int upper,
                        InterleavedS8 output)
```
    Adds 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)
```
    Adds 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(InterleavedU16 input,
                        int value,
                        int lower,
                        int upper,
                        InterleavedU16 output)
```
    Adds 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)
```
    Adds 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(InterleavedS16 input,
                        int value,
                        int lower,
                        int upper,
                        InterleavedS16 output)
```
    Adds 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)
```
    Adds 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(InterleavedS32 input,
                        int value,
                        int lower,
                        int upper,
                        InterleavedS32 output)
```
    Adds 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)
```
    Adds 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(InterleavedS64 input,
                        long value,
                        long lower,
                        long upper,
                        InterleavedS64 output)
```
    Adds 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)
```
    Adds 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(InterleavedF32 input,
                        float value,
                        float lower,
                        float upper,
                        InterleavedF32 output)
```
    Adds 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)
```
    Adds 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(InterleavedF64 input,
                        double value,
                        double lower,
                        double upper,
                        InterleavedF64 output)
```
    Adds 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.
  - 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.
    
    Parameters:
    
    input - The input image. Not modified.
    
    value - What is subtracted from each element.
    
    output - The output image. Modified.
  - minus
```
public static void minus(InterleavedU8 input,
                         int value,
                         InterleavedU8 output)
```
    Subtracts a scalar value from each element. Both input and output images can be the same instance.
    
    Parameters:
    
    input - The input image. Not modified.
    
    value - What is subtracted from each element.
    
    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.
    
    Parameters:
    
    input - The input image. Not modified.
    
    value - What is subtracted from each element.
    
    output - The output image. Modified.
  - minus
```
public static void minus(InterleavedS8 input,
                         int value,
                         InterleavedS8 output)
```
    Subtracts a scalar value from each element. Both input and output images can be the same instance.
    
    Parameters:
    
    input - The input image. Not modified.
    
    value - What is subtracted from each element.
    
    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.
    
    Parameters:
    
    input - The input image. Not modified.
    
    value - What is subtracted from each element.
    
    output - The output image. Modified.
  - minus
```
public static void minus(InterleavedU16 input,
                         int value,
                         InterleavedU16 output)
```
    Subtracts a scalar value from each element. Both input and output images can be the same instance.
    
    Parameters:
    
    input - The input image. Not modified.
    
    value - What is subtracted from each element.
    
    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.
    
    Parameters:
    
    input - The input image. Not modified.
    
    value - What is subtracted from each element.
    
    output - The output image. Modified.
  - minus
```
public static void minus(InterleavedS16 input,
                         int value,
                         InterleavedS16 output)
```
    Subtracts a scalar value from each element. Both input and output images can be the same instance.
    
    Parameters:
    
    input - The input image. Not modified.
    
    value - What is subtracted from each element.
    
    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.
    
    Parameters:
    
    input - The input image. Not modified.
    
    value - What is subtracted from each element.
    
    output - The output image. Modified.
  - minus
```
public static void minus(InterleavedS32 input,
                         int value,
                         InterleavedS32 output)
```
    Subtracts a scalar value from each element. Both input and output images can be the same instance.
    
    Parameters:
    
    input - The input image. Not modified.
    
    value - What is subtracted from each element.
    
    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.
    
    Parameters:
    
    input - The input image. Not modified.
    
    value - What is subtracted from each element.
    
    output - The output image. Modified.
  - minus
```
public static void minus(InterleavedS64 input,
                         long value,
                         InterleavedS64 output)
```
    Subtracts a scalar value from each element. Both input and output images can be the same instance.
    
    Parameters:
    
    input - The input image. Not modified.
    
    value - What is subtracted from each element.
    
    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.
    
    Parameters:
    
    input - The input image. Not modified.
    
    value - What is subtracted from each element.
    
    output - The output image. Modified.
  - minus
```
public static void minus(InterleavedF32 input,
                         float value,
                         InterleavedF32 output)
```
    Subtracts a scalar value from each element. Both input and output images can be the same instance.
    
    Parameters:
    
    input - The input image. Not modified.
    
    value - What is subtracted from each element.
    
    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.
    
    Parameters:
    
    input - The input image. Not modified.
    
    value - What is subtracted from each element.
    
    output - The output image. Modified.
  - minus
```
public static void minus(InterleavedF64 input,
                         double value,
                         InterleavedF64 output)
```
    Subtracts a scalar value from each element. Both input and output images can be the same instance.
    
    Parameters:
    
    input - The input image. Not modified.
    
    value - What is subtracted from each element.
    
    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.
    
    Parameters:
    
    input - The input image. Not modified.
    
    value - What is subtracted from each element.
    
    output - The output image. Modified.
  - minus
```
public static void minus(InterleavedU8 input,
                         int value,
                         int lower,
                         int upper,
                         InterleavedU8 output)
```
    Subtracts a scalar value from each element. Both input and output images can be the same instance.
    
    Parameters:
    
    input - The input image. Not modified.
    
    value - What is subtracted from each element.
    
    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.
    
    Parameters:
    
    input - The input image. Not modified.
    
    value - What is subtracted from each element.
    
    output - The output image. Modified.
  - minus
```
public static void minus(InterleavedS8 input,
                         int value,
                         int lower,
                         int upper,
                         InterleavedS8 output)
```
    Subtracts a scalar value from each element. Both input and output images can be the same instance.
    
    Parameters:
    
    input - The input image. Not modified.
    
    value - What is subtracted from each element.
    
    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.
    
    Parameters:
    
    input - The input image. Not modified.
    
    value - What is subtracted from each element.
    
    output - The output image. Modified.
  - minus
```
public static void minus(InterleavedU16 input,
                         int value,
                         int lower,
                         int upper,
                         InterleavedU16 output)
```
    Subtracts a scalar value from each element. Both input and output images can be the same instance.
    
    Parameters:
    
    input - The input image. Not modified.
    
    value - What is subtracted from each element.
    
    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.
    
    Parameters:
    
    input - The input image. Not modified.
    
    value - What is subtracted from each element.
    
    output - The output image. Modified.
  - minus
```
public static void minus(InterleavedS16 input,
                         int value,
                         int lower,
                         int upper,
                         InterleavedS16 output)
```
    Subtracts a scalar value from each element. Both input and output images can be the same instance.
    
    Parameters:
    
    input - The input image. Not modified.
    
    value - What is subtracted from each element.
    
    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.
    
    Parameters:
    
    input - The input image. Not modified.
    
    value - What is subtracted from each element.
    
    output - The output image. Modified.
  - minus
```
public static void minus(InterleavedS32 input,
                         int value,
                         int lower,
                         int upper,
                         InterleavedS32 output)
```
    Subtracts a scalar value from each element. Both input and output images can be the same instance.
    
    Parameters:
    
    input - The input image. Not modified.
    
    value - What is subtracted from each element.
    
    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.
    
    Parameters:
    
    input - The input image. Not modified.
    
    value - What is subtracted from each element.
    
    output - The output image. Modified.
  - minus
```
public static void minus(InterleavedS64 input,
                         long value,
                         long lower,
                         long upper,
                         InterleavedS64 output)
```
    Subtracts a scalar value from each element. Both input and output images can be the same instance.
    
    Parameters:
    
    input - The input image. Not modified.
    
    value - What is subtracted from each element.
    
    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.
    
    Parameters:
    
    input - The input image. Not modified.
    
    value - What is subtracted from each element.
    
    output - The output image. Modified.
  - minus
```
public static void minus(InterleavedF32 input,
                         float value,
                         float lower,
                         float upper,
                         InterleavedF32 output)
```
    Subtracts a scalar value from each element. Both input and output images can be the same instance.
    
    Parameters:
    
    input - The input image. Not modified.
    
    value - What is subtracted from each element.
    
    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.
    
    Parameters:
    
    input - The input image. Not modified.
    
    value - What is subtracted from each element.
    
    output - The output image. Modified.
  - minus
```
public static void minus(InterleavedF64 input,
                         double value,
                         double lower,
                         double upper,
                         InterleavedF64 output)
```
    Subtracts a scalar value from each element. Both input and output images can be the same instance.
    
    Parameters:
    
    input - The input image. Not modified.
    
    value - What is subtracted from each element.
    
    output - The output image. Modified.
  - minus
```
public static void minus(int value,
                         ImageUInt8 input,
                         ImageUInt8 output)
```
    Subtracts each element's value from a scalar. Both input and output images can be the same instance.
    
    Parameters:
    
    value - Scalar value
    
    input - The input image. Not modified.
    
    output - The output image. Modified.
  - minus
```
public static void minus(int value,
                         InterleavedU8 input,
                         InterleavedU8 output)
```
    Subtracts each element's value from a scalar. Both input and output images can be the same instance.
    
    Parameters:
    
    value - Scalar value
    
    input - The input image. Not modified.
    
    output - The output image. Modified.
  - minus
```
public static void minus(int value,
                         ImageSInt8 input,
                         ImageSInt8 output)
```
    Subtracts each element's value from a scalar. Both input and output images can be the same instance.
    
    Parameters:
    
    value - Scalar value
    
    input - The input image. Not modified.
    
    output - The output image. Modified.
  - minus
```
public static void minus(int value,
                         InterleavedS8 input,
                         InterleavedS8 output)
```
    Subtracts each element's value from a scalar. Both input and output images can be the same instance.
    
    Parameters:
    
    value - Scalar value
    
    input - The input image. Not modified.
    
    output - The output image. Modified.
  - minus
```
public static void minus(int value,
                         ImageUInt16 input,
                         ImageUInt16 output)
```
    Subtracts each element's value from a scalar. Both input and output images can be the same instance.
    
    Parameters:
    
    value - Scalar value
    
    input - The input image. Not modified.
    
    output - The output image. Modified.
  - minus
```
public static void minus(int value,
                         InterleavedU16 input,
                         InterleavedU16 output)
```
    Subtracts each element's value from a scalar. Both input and output images can be the same instance.
    
    Parameters:
    
    value - Scalar value
    
    input - The input image. Not modified.
    
    output - The output image. Modified.
  - minus
```
public static void minus(int value,
                         ImageSInt16 input,
                         ImageSInt16 output)
```
    Subtracts each element's value from a scalar. Both input and output images can be the same instance.
    
    Parameters:
    
    value - Scalar value
    
    input - The input image. Not modified.
    
    output - The output image. Modified.
  - minus
```
public static void minus(int value,
                         InterleavedS16 input,
                         InterleavedS16 output)
```
    Subtracts each element's value from a scalar. Both input and output images can be the same instance.
    
    Parameters:
    
    value - Scalar value
    
    input - The input image. Not modified.
    
    output - The output image. Modified.
  - minus
```
public static void minus(int value,
                         ImageSInt32 input,
                         ImageSInt32 output)
```
    Subtracts each element's value from a scalar. Both input and output images can be the same instance.
    
    Parameters:
    
    value - Scalar value
    
    input - The input image. Not modified.
    
    output - The output image. Modified.
  - minus
```
public static void minus(int value,
                         InterleavedS32 input,
                         InterleavedS32 output)
```
    Subtracts each element's value from a scalar. Both input and output images can be the same instance.
    
    Parameters:
    
    value - Scalar value
    
    input - The input image. Not modified.
    
    output - The output image. Modified.
  - minus
```
public static void minus(long value,
                         ImageSInt64 input,
                         ImageSInt64 output)
```
    Subtracts each element's value from a scalar. Both input and output images can be the same instance.
    
    Parameters:
    
    value - Scalar value
    
    input - The input image. Not modified.
    
    output - The output image. Modified.
  - minus
```
public static void minus(long value,
                         InterleavedS64 input,
                         InterleavedS64 output)
```
    Subtracts each element's value from a scalar. Both input and output images can be the same instance.
    
    Parameters:
    
    value - Scalar value
    
    input - The input image. Not modified.
    
    output - The output image. Modified.
  - minus
```
public static void minus(float value,
                         ImageFloat32 input,
                         ImageFloat32 output)
```
    Subtracts each element's value from a scalar. Both input and output images can be the same instance.
    
    Parameters:
    
    value - Scalar value
    
    input - The input image. Not modified.
    
    output - The output image. Modified.
  - minus
```
public static void minus(float value,
                         InterleavedF32 input,
                         InterleavedF32 output)
```
    Subtracts each element's value from a scalar. Both input and output images can be the same instance.
    
    Parameters:
    
    value - Scalar value
    
    input - The input image. Not modified.
    
    output - The output image. Modified.
  - minus
```
public static void minus(double value,
                         ImageFloat64 input,
                         ImageFloat64 output)
```
    Subtracts each element's value from a scalar. Both input and output images can be the same instance.
    
    Parameters:
    
    value - Scalar value
    
    input - The input image. Not modified.
    
    output - The output image. Modified.
  - minus
```
public static void minus(double value,
                         InterleavedF64 input,
                         InterleavedF64 output)
```
    Subtracts each element's value from a scalar. Both input and output images can be the same instance.
    
    Parameters:
    
    value - Scalar value
    
    input - The input image. Not modified.
    
    output - The output image. Modified.
  - minus
```
public static void minus(int value,
                         ImageUInt8 input,
                         int lower,
                         int upper,
                         ImageUInt8 output)
```
    Subtracts each element's value from a scalar. Both input and output images can be the same instance.
    
    Parameters:
    
    value - Scalar value
    
    input - The input image. Not modified.
    
    output - The output image. Modified.
  - minus
```
public static void minus(int value,
                         InterleavedU8 input,
                         int lower,
                         int upper,
                         InterleavedU8 output)
```
    Subtracts each element's value from a scalar. Both input and output images can be the same instance.
    
    Parameters:
    
    value - Scalar value
    
    input - The input image. Not modified.
    
    output - The output image. Modified.
  - minus
```
public static void minus(int value,
                         ImageSInt8 input,
                         int lower,
                         int upper,
                         ImageSInt8 output)
```
    Subtracts each element's value from a scalar. Both input and output images can be the same instance.
    
    Parameters:
    
    value - Scalar value
    
    input - The input image. Not modified.
    
    output - The output image. Modified.
  - minus
```
public static void minus(int value,
                         InterleavedS8 input,
                         int lower,
                         int upper,
                         InterleavedS8 output)
```
    Subtracts each element's value from a scalar. Both input and output images can be the same instance.
    
    Parameters:
    
    value - Scalar value
    
    input - The input image. Not modified.
    
    output - The output image. Modified.
  - minus
```
public static void minus(int value,
                         ImageUInt16 input,
                         int lower,
                         int upper,
                         ImageUInt16 output)
```
    Subtracts each element's value from a scalar. Both input and output images can be the same instance.
    
    Parameters:
    
    value - Scalar value
    
    input - The input image. Not modified.
    
    output - The output image. Modified.
  - minus
```
public static void minus(int value,
                         InterleavedU16 input,
                         int lower,
                         int upper,
                         InterleavedU16 output)
```
    Subtracts each element's value from a scalar. Both input and output images can be the same instance.
    
    Parameters:
    
    value - Scalar value
    
    input - The input image. Not modified.
    
    output - The output image. Modified.
  - minus
```
public static void minus(int value,
                         ImageSInt16 input,
                         int lower,
                         int upper,
                         ImageSInt16 output)
```
    Subtracts each element's value from a scalar. Both input and output images can be the same instance.
    
    Parameters:
    
    value - Scalar value
    
    input - The input image. Not modified.
    
    output - The output image. Modified.
  - minus
```
public static void minus(int value,
                         InterleavedS16 input,
                         int lower,
                         int upper,
                         InterleavedS16 output)
```
    Subtracts each element's value from a scalar. Both input and output images can be the same instance.
    
    Parameters:
    
    value - Scalar value
    
    input - The input image. Not modified.
    
    output - The output image. Modified.
  - minus
```
public static void minus(int value,
                         ImageSInt32 input,
                         int lower,
                         int upper,
                         ImageSInt32 output)
```
    Subtracts each element's value from a scalar. Both input and output images can be the same instance.
    
    Parameters:
    
    value - Scalar value
    
    input - The input image. Not modified.
    
    output - The output image. Modified.
  - minus
```
public static void minus(int value,
                         InterleavedS32 input,
                         int lower,
                         int upper,
                         InterleavedS32 output)
```
    Subtracts each element's value from a scalar. Both input and output images can be the same instance.
    
    Parameters:
    
    value - Scalar value
    
    input - The input image. Not modified.
    
    output - The output image. Modified.
  - minus
```
public static void minus(long value,
                         ImageSInt64 input,
                         long lower,
                         long upper,
                         ImageSInt64 output)
```
    Subtracts each element's value from a scalar. Both input and output images can be the same instance.
    
    Parameters:
    
    value - Scalar value
    
    input - The input image. Not modified.
    
    output - The output image. Modified.
  - minus
```
public static void minus(long value,
                         InterleavedS64 input,
                         long lower,
                         long upper,
                         InterleavedS64 output)
```
    Subtracts each element's value from a scalar. Both input and output images can be the same instance.
    
    Parameters:
    
    value - Scalar value
    
    input - The input image. Not modified.
    
    output - The output image. Modified.
  - minus
```
public static void minus(float value,
                         ImageFloat32 input,
                         float lower,
                         float upper,
                         ImageFloat32 output)
```
    Subtracts each element's value from a scalar. Both input and output images can be the same instance.
    
    Parameters:
    
    value - Scalar value
    
    input - The input image. Not modified.
    
    output - The output image. Modified.
  - minus
```
public static void minus(float value,
                         InterleavedF32 input,
                         float lower,
                         float upper,
                         InterleavedF32 output)
```
    Subtracts each element's value from a scalar. Both input and output images can be the same instance.
    
    Parameters:
    
    value - Scalar value
    
    input - The input image. Not modified.
    
    output - The output image. Modified.
  - minus
```
public static void minus(double value,
                         ImageFloat64 input,
                         double lower,
                         double upper,
                         ImageFloat64 output)
```
    Subtracts each element's value from a scalar. Both input and output images can be the same instance.
    
    Parameters:
    
    value - Scalar value
    
    input - The input image. Not modified.
    
    output - The output image. Modified.
  - minus
```
public static void minus(double value,
                         InterleavedF64 input,
                         double lower,
                         double upper,
                         InterleavedF64 output)
```
    Subtracts each element's value from a scalar. Both input and output images can be the same instance.
    
    Parameters:
    
    value - Scalar value
    
    input - The input image. Not modified.
    
    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
  - 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
  - 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
  - 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
  - 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
  - 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
  - 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
  - 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

abs

abs

abs

abs

abs

abs

abs

abs

abs

abs

abs

invert

invert

invert

invert

invert

invert

invert

invert

invert

invert

invert

invert

multiply

multiply

multiply

multiply

multiply

multiply

multiply

multiply

multiply

multiply

multiply

multiply

multiply

multiply

multiply

multiply

multiply

multiply

multiply

multiply

multiply

multiply

multiply

multiply

multiply

multiply

multiply

multiply

multiply

multiply

multiply

multiply

divide

divide

divide

divide

divide

divide

divide

divide

divide

divide

divide

divide

divide

divide

divide

divide

divide