PixelMath (ip 0.24.1 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(GrayF32 input, GrayF32 output)` Sets each pixel in the output image to be the absolute value of the input image.
`static void`	`abs(GrayF64 input, GrayF64 output)` Sets each pixel in the output image to be the absolute value of the input image.
`static void`	`abs(GrayS16 input, GrayS16 output)` Sets each pixel in the output image to be the absolute value of the input image.
`static void`	`abs(GrayS32 input, GrayS32 output)` Sets each pixel in the output image to be the absolute value of the input image.
`static void`	`abs(GrayS64 input, GrayS64 output)` Sets each pixel in the output image to be the absolute value of the input image.
`static void`	`abs(GrayS8 input, GrayS8 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(GrayF32 imgA, GrayF32 imgB, GrayF32 output)` Performs pixel-wise addition output(x,y) = imgA(x,y) + imgB(x,y)
`static void`	`add(GrayF64 imgA, GrayF64 imgB, GrayF64 output)` Performs pixel-wise addition output(x,y) = imgA(x,y) + imgB(x,y)
`static void`	`add(GrayS16 imgA, GrayS16 imgB, GrayS32 output)` Performs pixel-wise addition output(x,y) = imgA(x,y) + imgB(x,y)
`static void`	`add(GrayS32 imgA, GrayS32 imgB, GrayS32 output)` Performs pixel-wise addition output(x,y) = imgA(x,y) + imgB(x,y)
`static void`	`add(GrayS64 imgA, GrayS64 imgB, GrayS64 output)` Performs pixel-wise addition output(x,y) = imgA(x,y) + imgB(x,y)
`static void`	`add(GrayS8 imgA, GrayS8 imgB, GrayS16 output)` Performs pixel-wise addition output(x,y) = imgA(x,y) + imgB(x,y)
`static void`	`add(GrayU16 imgA, GrayU16 imgB, GrayS32 output)` Performs pixel-wise addition output(x,y) = imgA(x,y) + imgB(x,y)
`static void`	`add(GrayU8 imgA, GrayU8 imgB, GrayU16 output)` Performs pixel-wise addition output(x,y) = imgA(x,y) + imgB(x,y)
`static void`	`averageBand(Planar<GrayF32> input, GrayF32 output)` Computes the average for each pixel across all bands in the `Planar` image.
`static void`	`averageBand(Planar<GrayF64> input, GrayF64 output)` Computes the average for each pixel across all bands in the `Planar` image.
`static void`	`averageBand(Planar<GrayS16> input, GrayS16 output)` Computes the average for each pixel across all bands in the `Planar` image.
`static void`	`averageBand(Planar<GrayS32> input, GrayS32 output)` Computes the average for each pixel across all bands in the `Planar` image.
`static void`	`averageBand(Planar<GrayS64> input, GrayS64 output)` Computes the average for each pixel across all bands in the `Planar` image.
`static void`	`averageBand(Planar<GrayS8> input, GrayS8 output)` Computes the average for each pixel across all bands in the `Planar` image.
`static void`	`averageBand(Planar<GrayU16> input, GrayU16 output)` Computes the average for each pixel across all bands in the `Planar` image.
`static void`	`averageBand(Planar<GrayU8> input, GrayU8 output)` Computes the average for each pixel across all bands in the `Planar` image.
`static void`	`boundImage(GrayF32 img, float min, float max)` Bounds image pixels to be between these two values
`static void`	`boundImage(GrayF64 img, double min, double max)` Bounds image pixels to be between these two values
`static void`	`boundImage(GrayS16 img, int min, int max)` Bounds image pixels to be between these two values
`static void`	`boundImage(GrayS32 img, int min, int max)` Bounds image pixels to be between these two values
`static void`	`boundImage(GrayS64 img, long min, long max)` Bounds image pixels to be between these two values
`static void`	`boundImage(GrayS8 img, int min, int max)` Bounds image pixels to be between these two values
`static void`	`boundImage(GrayU16 img, int min, int max)` Bounds image pixels to be between these two values
`static void`	`boundImage(GrayU8 img, int min, int max)` Bounds image pixels to be between these two values
`static void`	`diffAbs(GrayF32 imgA, GrayF32 imgB, GrayF32 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(GrayF64 imgA, GrayF64 imgB, GrayF64 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(GrayS16 imgA, GrayS16 imgB, GrayS16 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(GrayS32 imgA, GrayS32 imgB, GrayS32 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(GrayS64 imgA, GrayS64 imgB, GrayS64 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(GrayS8 imgA, GrayS8 imgB, GrayS8 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(GrayU16 imgA, GrayU16 imgB, GrayU16 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(GrayU8 imgA, GrayU8 imgB, GrayU8 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(GrayF32 input, float denominator, float lower, float upper, GrayF32 output)` Divide each element by a scalar value.
`static void`	`divide(GrayF32 input, float denominator, GrayF32 output)` Divide each element by a scalar value.
`static void`	`divide(GrayF32 imgA, GrayF32 imgB, GrayF32 output)` Performs pixel-wise division output(x,y) = imgA(x,y) / imgB(x,y)
`static void`	`divide(GrayF64 input, double denominator, double lower, double upper, GrayF64 output)` Divide each element by a scalar value.
`static void`	`divide(GrayF64 input, double denominator, GrayF64 output)` Divide each element by a scalar value.
`static void`	`divide(GrayF64 imgA, GrayF64 imgB, GrayF64 output)` Performs pixel-wise division output(x,y) = imgA(x,y) / imgB(x,y)
`static void`	`divide(GrayS16 input, double denominator, GrayS16 output)` Divide each element by a scalar value.
`static void`	`divide(GrayS16 input, double denominator, int lower, int upper, GrayS16 output)` Divide each element by a scalar value.
`static void`	`divide(GrayS32 input, double denominator, GrayS32 output)` Divide each element by a scalar value.
`static void`	`divide(GrayS32 input, double denominator, int lower, int upper, GrayS32 output)` Divide each element by a scalar value.
`static void`	`divide(GrayS64 input, double denominator, GrayS64 output)` Divide each element by a scalar value.
`static void`	`divide(GrayS64 input, double denominator, long lower, long upper, GrayS64 output)` Divide each element by a scalar value.
`static void`	`divide(GrayS8 input, double denominator, GrayS8 output)` Divide each element by a scalar value.
`static void`	`divide(GrayS8 input, double denominator, int lower, int upper, GrayS8 output)` Divide each element by a scalar value.
`static void`	`divide(GrayU16 input, double denominator, GrayU16 output)` Divide each element by a scalar value.
`static void`	`divide(GrayU16 input, double denominator, int lower, int upper, GrayU16 output)` Divide each element by a scalar value.
`static void`	`divide(GrayU8 input, double denominator, GrayU8 output)` Divide each element by a scalar value.
`static void`	`divide(GrayU8 input, double denominator, int lower, int upper, GrayU8 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(GrayF32 input, GrayF32 output)` Changes the sign of every pixel in the image: output[x,y] = -input[x,y]
`static void`	`invert(GrayF64 input, GrayF64 output)` Changes the sign of every pixel in the image: output[x,y] = -input[x,y]
`static void`	`invert(GrayS16 input, GrayS16 output)` Changes the sign of every pixel in the image: output[x,y] = -input[x,y]
`static void`	`invert(GrayS32 input, GrayS32 output)` Changes the sign of every pixel in the image: output[x,y] = -input[x,y]
`static void`	`invert(GrayS64 input, GrayS64 output)` Changes the sign of every pixel in the image: output[x,y] = -input[x,y]
`static void`	`invert(GrayS8 input, GrayS8 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(GrayF32 input, GrayF32 output)` Sets each pixel in the output image to log( 1 + input(x,y)) of the input image.
`static void`	`log(GrayF64 input, GrayF64 output)` Sets each pixel in the output image to log( 1 + input(x,y)) of the input image.
`static void`	`minus(double value, GrayF64 input, double lower, double upper, GrayF64 output)` Subtracts each element's value from a scalar.
`static void`	`minus(double value, GrayF64 input, GrayF64 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, GrayF32 input, float lower, float upper, GrayF32 output)` Subtracts each element's value from a scalar.
`static void`	`minus(float value, GrayF32 input, GrayF32 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(GrayF32 input, float value, float lower, float upper, GrayF32 output)` Subtracts a scalar value from each element.
`static void`	`minus(GrayF32 input, float value, GrayF32 output)` Subtracts a scalar value from each element.
`static void`	`minus(GrayF64 input, double value, double lower, double upper, GrayF64 output)` Subtracts a scalar value from each element.
`static void`	`minus(GrayF64 input, double value, GrayF64 output)` Subtracts a scalar value from each element.
`static void`	`minus(GrayS16 input, int value, GrayS16 output)` Subtracts a scalar value from each element.
`static void`	`minus(GrayS16 input, int value, int lower, int upper, GrayS16 output)` Subtracts a scalar value from each element.
`static void`	`minus(GrayS32 input, int value, GrayS32 output)` Subtracts a scalar value from each element.
`static void`	`minus(GrayS32 input, int value, int lower, int upper, GrayS32 output)` Subtracts a scalar value from each element.
`static void`	`minus(GrayS64 input, long value, GrayS64 output)` Subtracts a scalar value from each element.
`static void`	`minus(GrayS64 input, long value, long lower, long upper, GrayS64 output)` Subtracts a scalar value from each element.
`static void`	`minus(GrayS8 input, int value, GrayS8 output)` Subtracts a scalar value from each element.
`static void`	`minus(GrayS8 input, int value, int lower, int upper, GrayS8 output)` Subtracts a scalar value from each element.
`static void`	`minus(GrayU16 input, int value, GrayU16 output)` Subtracts a scalar value from each element.
`static void`	`minus(GrayU16 input, int value, int lower, int upper, GrayU16 output)` Subtracts a scalar value from each element.
`static void`	`minus(GrayU8 input, int value, GrayU8 output)` Subtracts a scalar value from each element.
`static void`	`minus(GrayU8 input, int value, int lower, int upper, GrayU8 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, GrayS16 input, GrayS16 output)` Subtracts each element's value from a scalar.
`static void`	`minus(int value, GrayS16 input, int lower, int upper, GrayS16 output)` Subtracts each element's value from a scalar.
`static void`	`minus(int value, GrayS32 input, GrayS32 output)` Subtracts each element's value from a scalar.
`static void`	`minus(int value, GrayS32 input, int lower, int upper, GrayS32 output)` Subtracts each element's value from a scalar.
`static void`	`minus(int value, GrayS8 input, GrayS8 output)` Subtracts each element's value from a scalar.
`static void`	`minus(int value, GrayS8 input, int lower, int upper, GrayS8 output)` Subtracts each element's value from a scalar.
`static void`	`minus(int value, GrayU16 input, GrayU16 output)` Subtracts each element's value from a scalar.
`static void`	`minus(int value, GrayU16 input, int lower, int upper, GrayU16 output)` Subtracts each element's value from a scalar.
`static void`	`minus(int value, GrayU8 input, GrayU8 output)` Subtracts each element's value from a scalar.
`static void`	`minus(int value, GrayU8 input, int lower, int upper, GrayU8 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, GrayS64 input, GrayS64 output)` Subtracts each element's value from a scalar.
`static void`	`minus(long value, GrayS64 input, long lower, long upper, GrayS64 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(GrayF32 input, float value, float lower, float upper, GrayF32 output)` Multiply each element by a scalar value.
`static void`	`multiply(GrayF32 input, float value, GrayF32 output)` Multiply each element by a scalar value.
`static void`	`multiply(GrayF32 imgA, GrayF32 imgB, GrayF32 output)` Performs pixel-wise multiplication output(x,y) = imgA(x,y) * imgB(x,y)
`static void`	`multiply(GrayF64 input, double value, double lower, double upper, GrayF64 output)` Multiply each element by a scalar value.
`static void`	`multiply(GrayF64 input, double value, GrayF64 output)` Multiply each element by a scalar value.
`static void`	`multiply(GrayF64 imgA, GrayF64 imgB, GrayF64 output)` Performs pixel-wise multiplication output(x,y) = imgA(x,y) * imgB(x,y)
`static void`	`multiply(GrayS16 input, double value, GrayS16 output)` Multiply each element by a scalar value.
`static void`	`multiply(GrayS16 input, double value, int lower, int upper, GrayS16 output)` Multiply each element by a scalar value.
`static void`	`multiply(GrayS32 input, double value, GrayS32 output)` Multiply each element by a scalar value.
`static void`	`multiply(GrayS32 input, double value, int lower, int upper, GrayS32 output)` Multiply each element by a scalar value.
`static void`	`multiply(GrayS64 input, double value, GrayS64 output)` Multiply each element by a scalar value.
`static void`	`multiply(GrayS64 input, double value, long lower, long upper, GrayS64 output)` Multiply each element by a scalar value.
`static void`	`multiply(GrayS8 input, double value, GrayS8 output)` Multiply each element by a scalar value.
`static void`	`multiply(GrayS8 input, double value, int lower, int upper, GrayS8 output)` Multiply each element by a scalar value.
`static void`	`multiply(GrayU16 input, double value, GrayU16 output)` Multiply each element by a scalar value.
`static void`	`multiply(GrayU16 input, double value, int lower, int upper, GrayU16 output)` Multiply each element by a scalar value.
`static void`	`multiply(GrayU8 input, double value, GrayU8 output)` Multiply each element by a scalar value.
`static void`	`multiply(GrayU8 input, double value, int lower, int upper, GrayU8 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(GrayF32 input, float value, float lower, float upper, GrayF32 output)` Adds a scalar value to each element.
`static void`	`plus(GrayF32 input, float value, GrayF32 output)` Adds a scalar value to each element.
`static void`	`plus(GrayF64 input, double value, double lower, double upper, GrayF64 output)` Adds a scalar value to each element.
`static void`	`plus(GrayF64 input, double value, GrayF64 output)` Adds a scalar value to each element.
`static void`	`plus(GrayS16 input, int value, GrayS16 output)` Adds a scalar value to each element.
`static void`	`plus(GrayS16 input, int value, int lower, int upper, GrayS16 output)` Adds a scalar value to each element.
`static void`	`plus(GrayS32 input, int value, GrayS32 output)` Adds a scalar value to each element.
`static void`	`plus(GrayS32 input, int value, int lower, int upper, GrayS32 output)` Adds a scalar value to each element.
`static void`	`plus(GrayS64 input, long value, GrayS64 output)` Adds a scalar value to each element.
`static void`	`plus(GrayS64 input, long value, long lower, long upper, GrayS64 output)` Adds a scalar value to each element.
`static void`	`plus(GrayS8 input, int value, GrayS8 output)` Adds a scalar value to each element.
`static void`	`plus(GrayS8 input, int value, int lower, int upper, GrayS8 output)` Adds a scalar value to each element.
`static void`	`plus(GrayU16 input, int value, GrayU16 output)` Adds a scalar value to each element.
`static void`	`plus(GrayU16 input, int value, int lower, int upper, GrayU16 output)` Adds a scalar value to each element.
`static void`	`plus(GrayU8 input, int value, GrayU8 output)` Adds a scalar value to each element.
`static void`	`plus(GrayU8 input, int value, int lower, int upper, GrayU8 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(GrayF32 input, GrayF32 output)` Raises each pixel in the input image to the power of two.
`static void`	`pow2(GrayF64 input, GrayF64 output)` Raises each pixel in the input image to the power of two.
`static void`	`sqrt(GrayF32 input, GrayF32 output)` Computes the square root of each pixel in the input image.
`static void`	`sqrt(GrayF64 input, GrayF64 output)` Computes the square root of each pixel in the input image.
`static void`	`subtract(GrayF32 imgA, GrayF32 imgB, GrayF32 output)` Performs pixel-wise subtraction. output(x,y) = imgA(x,y) - imgB(x,y)
`static void`	`subtract(GrayF64 imgA, GrayF64 imgB, GrayF64 output)` Performs pixel-wise subtraction. output(x,y) = imgA(x,y) - imgB(x,y)
`static void`	`subtract(GrayS16 imgA, GrayS16 imgB, GrayS32 output)` Performs pixel-wise subtraction. output(x,y) = imgA(x,y) - imgB(x,y)
`static void`	`subtract(GrayS32 imgA, GrayS32 imgB, GrayS32 output)` Performs pixel-wise subtraction. output(x,y) = imgA(x,y) - imgB(x,y)
`static void`	`subtract(GrayS64 imgA, GrayS64 imgB, GrayS64 output)` Performs pixel-wise subtraction. output(x,y) = imgA(x,y) - imgB(x,y)
`static void`	`subtract(GrayS8 imgA, GrayS8 imgB, GrayS16 output)` Performs pixel-wise subtraction. output(x,y) = imgA(x,y) - imgB(x,y)
`static void`	`subtract(GrayU16 imgA, GrayU16 imgB, GrayS32 output)` Performs pixel-wise subtraction. output(x,y) = imgA(x,y) - imgB(x,y)
`static void`	`subtract(GrayU8 imgA, GrayU8 imgB, GrayI16 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(GrayS8 input,
                       GrayS8 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(GrayS16 input,
                       GrayS16 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(GrayS32 input,
                       GrayS32 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(GrayS64 input,
                       GrayS64 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(GrayF32 input,
                       GrayF32 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(GrayF64 input,
                       GrayF64 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(GrayS8 input,
                          GrayS8 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(GrayS16 input,
                          GrayS16 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(GrayS32 input,
                          GrayS32 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(GrayS64 input,
                          GrayS64 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(GrayF32 input,
                          GrayF32 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(GrayF64 input,
                          GrayF64 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(GrayU8 input,
                            double value,
                            GrayU8 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(GrayS8 input,
                            double value,
                            GrayS8 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(GrayU16 input,
                            double value,
                            GrayU16 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(GrayS16 input,
                            double value,
                            GrayS16 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(GrayS32 input,
                            double value,
                            GrayS32 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(GrayS64 input,
                            double value,
                            GrayS64 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(GrayF32 input,
                            float value,
                            GrayF32 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(GrayF64 input,
                            double value,
                            GrayF64 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(GrayU8 input,
                            double value,
                            int lower,
                            int upper,
                            GrayU8 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(GrayS8 input,
                            double value,
                            int lower,
                            int upper,
                            GrayS8 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(GrayU16 input,
                            double value,
                            int lower,
                            int upper,
                            GrayU16 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(GrayS16 input,
                            double value,
                            int lower,
                            int upper,
                            GrayS16 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(GrayS32 input,
                            double value,
                            int lower,
                            int upper,
                            GrayS32 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(GrayS64 input,
                            double value,
                            long lower,
                            long upper,
                            GrayS64 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(GrayF32 input,
                            float value,
                            float lower,
                            float upper,
                            GrayF32 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(GrayF64 input,
                            double value,
                            double lower,
                            double upper,
                            GrayF64 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(GrayU8 input,
                          double denominator,
                          GrayU8 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(GrayS8 input,
                          double denominator,
                          GrayS8 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(GrayU16 input,
                          double denominator,
                          GrayU16 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(GrayS16 input,
                          double denominator,
                          GrayS16 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(GrayS32 input,
                          double denominator,
                          GrayS32 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(GrayS64 input,
                          double denominator,
                          GrayS64 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(GrayF32 input,
                          float denominator,
                          GrayF32 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(GrayF64 input,
                          double denominator,
                          GrayF64 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(GrayU8 input,
                          double denominator,
                          int lower,
                          int upper,
                          GrayU8 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(GrayS8 input,
                          double denominator,
                          int lower,
                          int upper,
                          GrayS8 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(GrayU16 input,
                          double denominator,
                          int lower,
                          int upper,
                          GrayU16 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(GrayS16 input,
                          double denominator,
                          int lower,
                          int upper,
                          GrayS16 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(GrayS32 input,
                          double denominator,
                          int lower,
                          int upper,
                          GrayS32 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(GrayS64 input,
                          double denominator,
                          long lower,
                          long upper,
                          GrayS64 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(GrayF32 input,
                          float denominator,
                          float lower,
                          float upper,
                          GrayF32 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(GrayF64 input,
                          double denominator,
                          double lower,
                          double upper,
                          GrayF64 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(GrayU8 input,
                        int value,
                        GrayU8 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(GrayS8 input,
                        int value,
                        GrayS8 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(GrayU16 input,
                        int value,
                        GrayU16 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(GrayS16 input,
                        int value,
                        GrayS16 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(GrayS32 input,
                        int value,
                        GrayS32 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(GrayS64 input,
                        long value,
                        GrayS64 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(GrayF32 input,
                        float value,
                        GrayF32 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(GrayF64 input,
                        double value,
                        GrayF64 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(GrayU8 input,
                        int value,
                        int lower,
                        int upper,
                        GrayU8 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(GrayS8 input,
                        int value,
                        int lower,
                        int upper,
                        GrayS8 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(GrayU16 input,
                        int value,
                        int lower,
                        int upper,
                        GrayU16 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(GrayS16 input,
                        int value,
                        int lower,
                        int upper,
                        GrayS16 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(GrayS32 input,
                        int value,
                        int lower,
                        int upper,
                        GrayS32 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(GrayS64 input,
                        long value,
                        long lower,
                        long upper,
                        GrayS64 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(GrayF32 input,
                        float value,
                        float lower,
                        float upper,
                        GrayF32 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(GrayF64 input,
                        double value,
                        double lower,
                        double upper,
                        GrayF64 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(GrayU8 input,
                         int value,
                         GrayU8 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(GrayS8 input,
                         int value,
                         GrayS8 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(GrayU16 input,
                         int value,
                         GrayU16 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(GrayS16 input,
                         int value,
                         GrayS16 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(GrayS32 input,
                         int value,
                         GrayS32 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(GrayS64 input,
                         long value,
                         GrayS64 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(GrayF32 input,
                         float value,
                         GrayF32 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(GrayF64 input,
                         double value,
                         GrayF64 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(GrayU8 input,
                         int value,
                         int lower,
                         int upper,
                         GrayU8 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(GrayS8 input,
                         int value,
                         int lower,
                         int upper,
                         GrayS8 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(GrayU16 input,
                         int value,
                         int lower,
                         int upper,
                         GrayU16 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(GrayS16 input,
                         int value,
                         int lower,
                         int upper,
                         GrayS16 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(GrayS32 input,
                         int value,
                         int lower,
                         int upper,
                         GrayS32 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(GrayS64 input,
                         long value,
                         long lower,
                         long upper,
                         GrayS64 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(GrayF32 input,
                         float value,
                         float lower,
                         float upper,
                         GrayF32 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(GrayF64 input,
                         double value,
                         double lower,
                         double upper,
                         GrayF64 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,
                         GrayU8 input,
                         GrayU8 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,
                         GrayS8 input,
                         GrayS8 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,
                         GrayU16 input,
                         GrayU16 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,
                         GrayS16 input,
                         GrayS16 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,
                         GrayS32 input,
                         GrayS32 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,
                         GrayS64 input,
                         GrayS64 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,
                         GrayF32 input,
                         GrayF32 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,
                         GrayF64 input,
                         GrayF64 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,
                         GrayU8 input,
                         int lower,
                         int upper,
                         GrayU8 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,
                         GrayS8 input,
                         int lower,
                         int upper,
                         GrayS8 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,
                         GrayU16 input,
                         int lower,
                         int upper,
                         GrayU16 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,
                         GrayS16 input,
                         int lower,
                         int upper,
                         GrayS16 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,
                         GrayS32 input,
                         int lower,
                         int upper,
                         GrayS32 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,
                         GrayS64 input,
                         long lower,
                         long upper,
                         GrayS64 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,
                         GrayF32 input,
                         float lower,
                         float upper,
                         GrayF32 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,
                         GrayF64 input,
                         double lower,
                         double upper,
                         GrayF64 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(GrayU8 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(GrayU8 imgA,
                           GrayU8 imgB,
                           GrayU8 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(Planar<GrayU8> input,
                               GrayU8 output)
```
    Computes the average for each pixel across all bands in the Planar image.
    
    Parameters:
    
    input - Planar image
    
    output - Gray scale image containing average pixel values
  - boundImage
```
public static void boundImage(GrayS8 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(GrayS8 imgA,
                           GrayS8 imgB,
                           GrayS8 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(Planar<GrayS8> input,
                               GrayS8 output)
```
    Computes the average for each pixel across all bands in the Planar image.
    
    Parameters:
    
    input - Planar image
    
    output - Gray scale image containing average pixel values
  - boundImage
```
public static void boundImage(GrayU16 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(GrayU16 imgA,
                           GrayU16 imgB,
                           GrayU16 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(Planar<GrayU16> input,
                               GrayU16 output)
```
    Computes the average for each pixel across all bands in the Planar image.
    
    Parameters:
    
    input - Planar image
    
    output - Gray scale image containing average pixel values
  - boundImage
```
public static void boundImage(GrayS16 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(GrayS16 imgA,
                           GrayS16 imgB,
                           GrayS16 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(Planar<GrayS16> input,
                               GrayS16 output)
```
    Computes the average for each pixel across all bands in the Planar image.
    
    Parameters:
    
    input - Planar image
    
    output - Gray scale image containing average pixel values
  - boundImage
```
public static void boundImage(GrayS32 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(GrayS32 imgA,
                           GrayS32 imgB,
                           GrayS32 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(Planar<GrayS32> input,
                               GrayS32 output)
```
    Computes the average for each pixel across all bands in the Planar image.
    
    Parameters:
    
    input - Planar image
    
    output - Gray scale image containing average pixel values
  - boundImage
```
public static void boundImage(GrayS64 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(GrayS64 imgA,
                           GrayS64 imgB,
                           GrayS64 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(Planar<GrayS64> input,
                               GrayS64 output)
```
    Computes the average for each pixel across all bands in the Planar image.
    
    Parameters:
    
    input - Planar image
    
    output - Gray scale image containing average pixel values
  - boundImage
```
public static void boundImage(GrayF32 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(GrayF32 imgA,
                           GrayF32 imgB,
                           GrayF32 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(Planar<GrayF32> input,
                               GrayF32 output)
```
    Computes the average for each pixel across all bands in the Planar image.
    
    Parameters:
    
    input - Planar image
    
    output - Gray scale image containing average pixel values
  - boundImage
```
public static void boundImage(GrayF64 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(GrayF64 imgA,
                           GrayF64 imgB,
                           GrayF64 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(Planar<GrayF64> input,
                               GrayF64 output)
```
    Computes the average for each pixel across all bands in the Planar image.
    
    Parameters:
    
    input - Planar image
    
    output - Gray scale image containing average pixel values
  - add
```
public static void add(GrayU8 imgA,
                       GrayU8 imgB,
                       GrayU16 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(GrayU8 imgA,
                            GrayU8 imgB,
                            GrayI16 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(GrayS8 imgA,
                       GrayS8 imgB,
                       GrayS16 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(GrayS8 imgA,
                            GrayS8 imgB,
                            GrayS16 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(GrayU16 imgA,
                       GrayU16 imgB,
                       GrayS32 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(GrayU16 imgA,
                            GrayU16 imgB,
                            GrayS32 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(GrayS16 imgA,
                       GrayS16 imgB,
                       GrayS32 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(GrayS16 imgA,
                            GrayS16 imgB,
                            GrayS32 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(GrayS32 imgA,
                       GrayS32 imgB,
                       GrayS32 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(GrayS32 imgA,
                            GrayS32 imgB,
                            GrayS32 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(GrayS64 imgA,
                       GrayS64 imgB,
                       GrayS64 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(GrayS64 imgA,
                            GrayS64 imgB,
                            GrayS64 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(GrayF32 imgA,
                       GrayF32 imgB,
                       GrayF32 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(GrayF32 imgA,
                            GrayF32 imgB,
                            GrayF32 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(GrayF32 imgA,
                            GrayF32 imgB,
                            GrayF32 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(GrayF32 imgA,
                          GrayF32 imgB,
                          GrayF32 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(GrayF32 input,
                       GrayF32 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(GrayF32 input,
                        GrayF32 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(GrayF32 input,
                        GrayF32 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(GrayF64 imgA,
                       GrayF64 imgB,
                       GrayF64 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(GrayF64 imgA,
                            GrayF64 imgB,
                            GrayF64 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(GrayF64 imgA,
                            GrayF64 imgB,
                            GrayF64 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(GrayF64 imgA,
                          GrayF64 imgB,
                          GrayF64 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(GrayF64 input,
                       GrayF64 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(GrayF64 input,
                        GrayF64 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(GrayF64 input,
                        GrayF64 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