Image (OpenIMAJ master project 1.3.1 API)

java.lang.Object
- org.openimaj.image.Image<Q,I>

Type Parameters:
Q - the pixel type
I - the actual image of the concrete subclass

All Implemented Interfaces:

Serializable, Cloneable, ImageProvider

Direct Known Subclasses:

MultiBandImage, SingleBandImage, SVGImage
```
public abstract class Image<Q,I extends Image<Q,I>>
extends Object
implements Cloneable, Serializable, ImageProvider
```
Base class for representing and manipulating images. Images are typed by the type of pixel at each coordinate and the concrete subclass type.

Author:

Jonathon Hare (jsh2@ecs.soton.ac.uk)

See Also:
Serialized Form

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class Image.Field
Enumerator for representing the type of field interlacing operations.

Nested Classes
Modifier and Type	Class and Description
`static class`	`Image.Field` Enumerator for representing the type of field interlacing operations.

Constructor Summary

Constructors
Constructor and Description

Image()

Constructors
Constructor and Description
`Image()`

Method Summary

Methods
Modifier and Type	Method and Description
`abstract I`	`abs()` Set all pixels to their absolute values, so that all pixel values in the image will be greater than zero.
`void`	`accumulateWith(AccumulatingImageCombiner<I,?> combiner)` Accumulate this image the the given `AccumulatingImageCombiner`.
`I`	`add(Image<?,?> im)` Adds the given image to this image and return new image.
`I`	`add(Q num)` Add a value to each pixel and return new image.
`abstract I`	`addInplace(Image<?,?> im)` Add the given image to this image (side-affects this image).
`abstract I`	`addInplace(Q num)` Add a scalar to each pixel in this image (side-affects this image).
`void`	`analyseWith(ImageAnalyser<I> analyser)` Analyse this image with an `ImageAnalyser`.
`void`	`analyseWith(PixelAnalyser<Q> analyser)` Analyse this image with a `PixelAnalyser`.
`void`	`analyseWithMasked(FImage mask, PixelAnalyser<Q> analyser)` Analyse this image with the given `PixelAnalyser`, only analysing those pixels where the mask is non-zero.
`abstract I`	`clip(Q min, Q max)` Sets any pixels that are below `min` to zero or above `max` to the highest normal value that the image allows (usually 1 for floating-point images).
`abstract I`	`clipMax(Q thresh)` Set all values greater than the given value to the highest normal value that the image allows (usually 1 for floating-point images).
`abstract I`	`clipMin(Q thresh)` Set all values less than the given value to zero.
`abstract I`	`clone()` Deep copy of an image (internal image buffers copied).
`<OUT extends Image<?,OUT>,OTHER extends Image<?,OTHER>> OUT`	`combineWith(ImageCombiner<I,OTHER,OUT> combiner, OTHER other)` Combine this image with another using an `ImageCombiner`.
`abstract ImageRenderer<Q,I>`	`createRenderer()` Create a `ImageRenderer` capable of drawing into this image.
`abstract ImageRenderer<Q,I>`	`createRenderer(RenderHints options)` Create a `ImageRenderer` capable of drawing into this image.
`Q`	`defaultBackgroundColour()` Get the default foreground colour.
`Q`	`defaultForegroundColour()` Get the default foreground colour.
`I`	`divide(Image<?,?> im)` Divide each pixel of the image by corresponding pixel in the given image.
`I`	`divide(Q val)` Divide each pixel of the image by the given scalar value.
`abstract I`	`divideInplace(Image<?,?> im)` Divide each pixel in this image by the corresponding pixel value in the given image.
`abstract I`	`divideInplace(Q val)` Divide each pixel of the image by the given scalar value.
`void`	`drawConnectedPoints(List<? extends Point2d> pts, Q col)` Draw onto this image lines drawn with the given colour between the points given.
`Point2d[]`	`drawCubicBezier(Point2d p1, Point2d p2, Point2d c1, Point2d c2, int thickness, Q col)` Draw a cubic Bezier curve into the image with 100 point accuracy.
`void`	`drawImage(I image, int x, int y)` Draw into this image the provided image at the given coordinates.
`void`	`drawImage(I image, int x, int y, Q... ignoreList)` Draw into this image the provided image at the given coordinates ignoring certain pixels.
`void`	`drawImage(I image, Point2d pt)` Draw into this image the provided image at the given coordinates.
`void`	`drawLine(int x1, int y1, double theta, int length, int thickness, Q col)` Draw a line from the coordinates specified by `(x1,y1)` at an angle of `theta` with the given length, thickness and colour.
`void`	`drawLine(int x1, int y1, double theta, int length, Q col)` Draw a line from the coordinates specified by `(x1,y1)` at an angle of `theta` with the given length and colour.
`void`	`drawLine(int x0, int y0, int x1, int y1, int thickness, Q col)` Draw a line from the coordinates specified by `(x0,y0)` to the coordinates specified by `(x1,y1)` using the given color and thickness.
`void`	`drawLine(int x0, int y0, int x1, int y1, Q col)` Draw a line from the coordinates specified by `(x0,y0)` to `(x1,y1)` using the given colour.
`void`	`drawLine(Line2d line, int thickness, Q col)` Draw a line from the specified Line2d object
`void`	`drawLine(Point2d p1, Point2d p2, int thickness, Q col)` Draw a line from the coordinates specified using the given colour and thickness.
`void`	`drawLine(Point2d p1, Point2d p2, Q col)` Draw a line from the coordinates specified using the given colour.
`void`	`drawLines(Iterable<? extends Line2d> lines, int thickness, Q col)` Draw the given list of lines using `drawLine(Line2d, int, Object)` with the given colour and thickness.
`void`	`drawPoint(Point2d p, Q col, int size)` Draw a dot centered on the given location (rounded to nearest integer location) at the given size and with the given color.
`void`	`drawPoints(Iterable<? extends Point2d> pts, Q col, int size)` Draw the given list of points using `drawPoint(Point2d, Object, int)` with the given colour and size.
`void`	`drawPolygon(Polygon p, int thickness, Q col)` Draw the given polygon in the specified colour with the given thickness lines.
`void`	`drawPolygon(Polygon p, Q col)` Draw the given polygon in the specified colour.
`void`	`drawPolygonFilled(Polygon p, Q col)` Draw the given polygon, filled with the specified colour.
`void`	`drawShape(Shape s, int thickness, Q col)` Draw the given shape in the specified colour with the given thickness lines.
`void`	`drawShape(Shape p, Q col)` Draw the given shape in the specified colour.
`void`	`drawShapeFilled(Shape s, Q col)` Draw the given shape, filled with the specified colour.
`void`	`drawText(AttributedString text, int x, int y)` Render the text using its attributes.
`void`	`drawText(AttributedString text, Point2d pt)` Render the text using its attributes.
`<F extends Font<F>> void`	`drawText(String text, int x, int y, F f, int sz)` Render the text in the given font with the default style.
`<F extends Font<F>> void`	`drawText(String text, int x, int y, F f, int sz, Q col)` Render the text in the given font in the given colour with the default style.
`void`	`drawText(String text, int x, int y, FontStyle<Q> f)` Render the text with the given `FontStyle`.
`<F extends Font<F>> void`	`drawText(String text, Point2d pt, F f, int sz)` Render the text in the given font with the default style.
`<F extends Font<F>> void`	`drawText(String text, Point2d pt, F f, int sz, Q col)` Render the text in the given font in the given colour with the default style.
`void`	`drawText(String text, Point2d pt, FontStyle<Q> f)` Render the text with the given `FontStyle`.
`I`	`extractCenter(int w, int h)` Extract a rectangular region about the centre of the image with the given width and height.
`I`	`extractCenter(int x, int y, int w, int h)` Extract a rectangular region centred on a given point.
`abstract I`	`extractCentreSubPix(float cx, float cy, I out)` Sub-pixel sampling of a centred rectangular region such that `dst(x, y) = src(x + center.x (width(dst) 1) ⇤ 0.5, y + center.y (height(dst) 1) ⇤ 0.5)` .
`I`	`extractCentreSubPix(float cx, float cy, int width, int height)` Sub-pixel sampling of a centred rectangular region such that `dst(x, y) = src(x + center.x (width(dst) 1) ⇤ 0.5, y + center.y (height(dst) 1) ⇤ 0.5)` .
`I`	`extractCentreSubPix(Point2d centre, I out)` Sub-pixel sampling of a centred rectangular region such that `dst(x, y) = src(x + center.x (width(dst) 1) ⇤ 0.5, y + center.y (height(dst) 1) ⇤ 0.5)` .
`I`	`extractCentreSubPix(Point2d centre, int width, int height)` Sub-pixel sampling of a centred rectangular region such that `dst(x, y) = src(x + center.x (width(dst) 1) ⇤ 0.5, y + center.y (height(dst) 1) ⇤ 0.5)` .
`abstract I`	`extractROI(int x, int y, I img)` Extract a rectangular region of interest from this image and put it in the given image.
`abstract I`	`extractROI(int x, int y, int w, int h)` Extract a rectangular region of interest of the given width and height.
`I`	`extractROI(Rectangle r)` Extract a rectangular region of interest of the given width and height.
`abstract I`	`fill(Q colour)` Fill this image with the given colour.
`abstract I`	`flipX()` Flips the content horizontally.
`abstract I`	`flipY()` Flips the content vertically.
`Rectangle`	`getBounds()` Get a rectangle representing the image, with the top-left at 0,0 and the bottom-right at width,height
`int`	`getCols()` Get the image width in pixels.
`abstract Rectangle`	`getContentArea()` Get bounding box of non-zero-valued pixels around the outside of the image.
`abstract I`	`getField(Image.Field f)` Get the given field of this image.
`abstract I`	`getFieldCopy(Image.Field f)` Get the given field of this image, maintaining the image's aspect ratio by doubling the fields.
`abstract I`	`getFieldInterpolate(Image.Field f)` Get the given field of this image, maintaining the image's aspect ratio by interpolating between the fields.
`abstract int`	`getHeight()` Returns the image height in pixels.
`I`	`getImage()` Get the image that this provider provides.
`abstract Q`	`getPixel(int x, int y)` Get the value of the pixel at coordinate `(x, y)`.
`Q`	`getPixel(Pixel p)` Get the value of the pixel at coordinate p
`abstract Comparator<? super Q>`	`getPixelComparator()` Returns a pixel comparator that is able to compare equality of pixels in the given image type.
`abstract Q`	`getPixelInterp(double x, double y)` Get the value of a sub-pixel using linear-interpolation.
`abstract Q`	`getPixelInterp(double x, double y, Q backgroundColour)` Get the value of a sub-pixel using linear-interpolation.
`Q[]`	`getPixelVector(Q[] f)` Returns the pixels in this image as a vector (an array of the pixel type).
`int`	`getRows()` Get the height of this image.
`abstract int`	`getWidth()` Get the width (number of columns) in this image.
`abstract I`	`internalAssign(I im)` Assign the internal state from another image of the same type.
`abstract I`	`internalAssign(int[] pixelData, int width, int height)` Copy pixels from given ARGB buffer image into this image.
`abstract I`	`internalCopy(I im)` Copy the internal state from another image of the same type.
`abstract I`	`inverse()` Invert the image pixels by finding the maximum value and subtracting each pixel value from that maximum.
`abstract Q`	`max()` Find the maximum pixel value.
`abstract Q`	`min()` Find the minimum pixel value.
`I`	`multiply(Image<?,?> im)` Multiply the pixel values in this image with the corresponding pixel values in the given image.
`I`	`multiply(Q num)` Multiply each pixel of this by the given scalar and return new image.
`abstract I`	`multiplyInplace(Image<?,?> im)` Multiply each pixel in this image by the corresponding pixel in the given image.
`abstract I`	`multiplyInplace(Q num)` Multiply each pixel of this by the given scalar.
`abstract I`	`newInstance(int width, int height)` Create a new instance of this image subclass with given dimensions.
`abstract I`	`normalise()` Normalise all pixel values to fall within the range 0.0 - 1.0.
`I`	`overlay(I image, int x, int y)` Overlays the given image on this image and returns a new image containing the result.
`abstract I`	`overlayInplace(I image, int x, int y)` Overlays the given image on this image directly.
`I`	`padding(int paddingWidth, int paddingHeight)` Adds padding as in `padding(int, int, Object)`.
`I`	`padding(int paddingWidth, int paddingHeight, Q paddingColour)` Adds this many pixels to both sides of the image such that the new image width = padding + width + padding with the original image in the middle
`I`	`paddingSymmetric(int paddingLeft, int paddingRight, int paddingTop, int paddingBottom)` Adds pixels to around the image such that the new image width = paddingLeft + width + paddingRight with the original image in the middle.
`I`	`process(GridProcessor<Q,I> p)` Process this image with the given `GridProcessor` and return new image containing the result.
`I`	`process(ImageProcessor<I> p)` Process this image with an `ImageProcessor` and return new image containing the result.
`I`	`process(KernelProcessor<Q,I> p)` Process this image with the given `KernelProcessor` and return new image containing the result.
`I`	`process(KernelProcessor<Q,I> p, boolean pad)` Process this image with the given `KernelProcessor` and return new image containing the result.
`I`	`process(PixelProcessor<Q> p)` Process this image with the given `PixelProcessor` and return a new image containing the result.
`I`	`process(Processor<I> p)` Process this image with an `Processor` and return new image containing the result.
`I`	`processInplace(ImageProcessor<I> p)` Process this image with the given `ImageProcessor` side-affecting this image.
`I`	`processInplace(KernelProcessor<Q,I> p)` Process this image with the given `KernelProcessor` side-affecting this image.
`I`	`processInplace(KernelProcessor<Q,I> p, boolean pad)` Process this image with the given `KernelProcessor` side-affecting this image.
`I`	`processInplace(PixelProcessor<Q> p)` Process this image with the given `PixelProcessor` side-affecting this image.
`I`	`processInplace(Processor<I> p)` Process this image with the given `Processor` side-affecting this image.
`I`	`processMasked(FImage mask, PixelProcessor<Q> p)` Process this image with the given `PixelProcessor` only affecting those pixels where the mask is non-zero.
`I`	`processMaskedInplace(FImage mask, PixelProcessor<Q> p)` Process this image with the given `PixelProcessor`, only affecting those pixels where the mask is non-zero.
`abstract I`	`replace(Q target, Q replacement)` Replace pixels of a certain colour with another colour.
`abstract void`	`setPixel(int x, int y, Q val)` Sets the pixel at `(x,y)` to the given value.
`I`	`shiftDown()` Returns a new image that is it shifted around the x-ordinates by one pixel
`I`	`shiftDown(int nPixels)` Returns a new image that is it shifted around the x-ordinates by the number of pixels given.
`I`	`shiftDownInplace()` Shifts all the pixels down by one pixels
`I`	`shiftDownInplace(int count)` Shifts all the pixels down by count pixels
`I`	`shiftLeft()` Returns a new image that is it shifted around the x-ordinates by one pixel
`I`	`shiftLeft(int nPixels)` Returns a new image that is it shifted around the x-ordinates by the number of pixels given.
`I`	`shiftLeftInplace()` Shifts all the pixels to the left by one pixel
`I`	`shiftLeftInplace(int count)` Shifts all the pixels to the left by count pixel
`I`	`shiftRight()` Returns a new image that is it shifted around the x-ordinates by one pixel
`I`	`shiftRight(int nPixels)` Returns a new image that is it shifted around the x-ordinates by the number of pixels given.
`I`	`shiftRightInplace()` Shifts all the pixels to the right by one pixel
`I`	`shiftRightInplace(int count)` Shifts all the pixels to the right by count pixel
`I`	`shiftUp()` Returns a new image that is it shifted around the x-ordinates by one pixel
`I`	`shiftUp(int nPixels)` Returns a new image that is it shifted around the x-ordinates by the number of pixels given.
`I`	`shiftUpInplace()` Shifts all the pixels up by one pixel
`I`	`shiftUpInplace(int count)` Shifts all the pixels up by count pixels
`I`	`subtract(Image<?,?> im)` Subtract the corresponding pixel value from the given image from the pixel values in this image.
`I`	`subtract(Q num)` Subtract a scalar from every pixel value in this image and return new image.
`abstract I`	`subtractInplace(Image<?,?> im)` Subtract the corresponding pixel value from the given image from the pixel values in this image.
`abstract I`	`subtractInplace(Q num)` Subtract a scalar from every pixel value in this image.
`abstract I`	`threshold(Q thresh)` Set all values less than the given threshold to 0 and all others to 1.
`abstract byte[]`	`toByteImage()` Convert the image to a byte representation suitable for writing to a pnm type format.
`abstract int[]`	`toPackedARGBPixels()` Returns a 1D array representation of this image with each pixel represented as a packed ARGB integer.
`I`	`transform(Jama.Matrix transform)` Apply a transform matrix to the image and returns the result as a new image.
`I`	`trim()` Removes zero-valued pixels from around the outside of the image.
`abstract I`	`zero()` Set all pixels in the image to zero.

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

- Constructor Detail
 - Image
```
public Image()
```
- Method Detail
 - accumulateWith
```
public void accumulateWith(AccumulatingImageCombiner<I,?> combiner)
```
 Accumulate this image the the given AccumulatingImageCombiner.
 
 Parameters:
 combiner - the combiner
 See Also:
 AccumulatingImageCombiner.accumulate(Image)
 - abs
```
public abstract I abs()
```
 Set all pixels to their absolute values, so that all pixel values in the image will be greater than zero.
 
 Returns:
 The image with absolute values
 - add
```
public I add(Image<?,?> im)
```
 Adds the given image to this image and return new image.
 
 Parameters:
 im - The image to add
 
 Returns:
 A new image that is the sum of this image and the given image.
 - add
```
public I add(Q num)
```
 Add a value to each pixel and return new image.
 
 Parameters:
 num - The value to add to each pixel
 
 Returns:
 A new image that is the sum of this image and the given value.
 - addInplace
```
public abstract I addInplace(Image<?,?> im)
```
 Add the given image to this image (side-affects this image).
 
 Parameters:
 im - The image to add to this image
 
 Returns:
 A reference to this image.
 - addInplace
```
public abstract I addInplace(Q num)
```
 Add a scalar to each pixel in this image (side-affects this image).
 
 Parameters:
 num - The value to add to every pixel in this image.
 
 Returns:
 A reference to this image.
 - analyseWith
```
public void analyseWith(ImageAnalyser analyser)
```
 Analyse this image with an ImageAnalyser.
 
 Parameters:
 analyser - The analyser to analyse with.
 See Also:
 ImageAnalyser.analyseImage(Image)
 - analyseWith
```
public void analyseWith(PixelAnalyser<Q> analyser)
```
 Analyse this image with a PixelAnalyser.
 
 Parameters:
 analyser - The analyser to analyse with.
 See Also:
 PixelAnalyser.analysePixel(Object)
 - analyseWithMasked
```
public void analyseWithMasked(FImage mask,
 PixelAnalyser<Q> analyser)
```
 Analyse this image with the given PixelAnalyser, only analysing those pixels where the mask is non-zero.
 
 Parameters:
 mask - The mask to apply to the analyser.
 analyser - The PixelProcessor to apply.
 See Also:
 PixelAnalyser.analysePixel(Object)
 - clip
```
public abstract I clip(Q min,
 Q max)
```
 Sets any pixels that are below min to zero or above max to the highest normal value that the image allows (usually 1 for floating-point images). This method may side-affect this image.
 
 Parameters:
 min - The minimum value
 max - The maximum value
 
 Returns:
 The clipped image.
 - clipMax
```
public abstract I clipMax(Q thresh)
```
 Set all values greater than the given value to the highest normal value that the image allows (usually 1 for floating-point images). This method may side-affect this image.
 
 Parameters:
 thresh - The value over which pixels are clipped to zero.
 
 Returns:
 The clipped image.
 - clipMin
```
public abstract I clipMin(Q thresh)
```
 Set all values less than the given value to zero. This method may side-affect this image.
 
 Parameters:
 thresh - The value below which pixels are clipped to zero.
 
 Returns:
 The clipped image.
 - clone
```
public abstract I clone()
```
 Deep copy of an image (internal image buffers copied).
 
 Overrides:
 
 clone in class Object
 
 Returns:
 A copy of this image.
 - createRenderer
```
public abstract ImageRenderer<Q,I> createRenderer()
```
 Create a ImageRenderer capable of drawing into this image.
 
 Returns:
 the renderer
 - createRenderer
```
public abstract ImageRenderer<Q,I> createRenderer(RenderHints options)
```
 Create a ImageRenderer capable of drawing into this image.
 
 Parameters:
 options - Options for the renderer
 
 Returns:
 the renderer
 - combineWith
```
public <OUT extends Image<?,OUT>,OTHER extends Image<?,OTHER>> OUT combineWith(ImageCombiner<I,OTHER,OUT> combiner,
 OTHER other)
```
 Combine this image with another using an ImageCombiner.
 
 Type Parameters:
 OUT - The output Image type.
 OTHER - The type of the other Image being combined.
 Parameters:
 combiner - The combiner.
 other - The image to combine with this
 
 Returns:
 The combined output.
 - defaultBackgroundColour
```
public Q defaultBackgroundColour()
```
 Get the default foreground colour.
 This is a convenience method that calls createRenderer() to get the default renderer to do the actual drawing. Create the renderer yourself and use it to draw if you need more control.
 
 Returns:
 the default foreground colour.
 - defaultForegroundColour
```
public Q defaultForegroundColour()
```
 Get the default foreground colour.
 This is a convenience method that calls createRenderer() to get the default renderer to do the actual drawing. Create the renderer yourself and use it to draw if you need more control.
 
 Returns:
 the default foreground colour.
 - divide
```
public I divide(Image<?,?> im)
```
 Divide each pixel of the image by corresponding pixel in the given image. This method should return a new image.
 
 Parameters:
 im - image The image to divide this image by.
 
 Returns:
 A new image containing the result.
 - divide
```
public I divide(Q val)
```
 Divide each pixel of the image by the given scalar value. This method should return a new image.
 
 Parameters:
 val - The value to divide the pixels in this image by.
 
 Returns:
 A new image containing the result.
 - divideInplace
```
public abstract I divideInplace(Image<?,?> im)
```
 Divide each pixel in this image by the corresponding pixel value in the given image. This method should side-affect this image.
 
 Parameters:
 im - image The image to divide this image by.
 
 Returns:
 A reference to this image containing the result.
 - divideInplace
```
public abstract I divideInplace(Q val)
```
 Divide each pixel of the image by the given scalar value. This method should side-affect this image.
 
 Parameters:
 val - The value to divide each pixel by.
 
 Returns:
 A reference to this image containing the result.
 - drawConnectedPoints
```
public void drawConnectedPoints(List<? extends Point2d> pts,
 Q col)
```
 Draw onto this image lines drawn with the given colour between the points given. No points are drawn. Side-affects this image.
 This is a convenience method that calls createRenderer() to get the default renderer to do the actual drawing. Create the renderer yourself and use it to draw if you need more control.
 
 Parameters:
 pts - The point list to draw onto this image.
 col - The colour to draw the lines
 - drawCubicBezier
```
public Point2d[] drawCubicBezier(Point2d p1,
 Point2d p2,
 Point2d c1,
 Point2d c2,
 int thickness,
 Q col)
```
 Draw a cubic Bezier curve into the image with 100 point accuracy.
 This is a convenience method that calls createRenderer() to get the default renderer to do the actual drawing. Create the renderer yourself and use it to draw if you need more control.
 
 Parameters:
 p1 - One end point of the line
 p2 - The other end point of the line
 c1 - The control point associated with p1
 c2 - The control point associated with p2
 thickness - The thickness to draw the line
 col - The colour to draw the line
 
 Returns:
 The points along the bezier curve
 - drawImage
```
public void drawImage(I image,
 int x,
 int y)
```
 Draw into this image the provided image at the given coordinates. Parts of the image outside the bounds of this image will be ignored. Side-affects this image.
 This is a convenience method that calls createRenderer() to get the default renderer to do the actual drawing. Create the renderer yourself and use it to draw if you need more control.
 
 Parameters:
 image - The image to draw.
 x - The x-ordinate of the top-left of the image
 y - The y-ordinate of the top-left of the image
 - drawImage
```
public void drawImage(I image,
 Point2d pt)
```
 Draw into this image the provided image at the given coordinates. Parts of the image outside the bounds of this image will be ignored. Side-affects this image.
 This is a convenience method that calls createRenderer() to get the default renderer to do the actual drawing. Create the renderer yourself and use it to draw if you need more control.
 
 Parameters:
 image - The image to draw.
 pt - the coordinate at which to draw
 - drawImage
```
public void drawImage(I image,
 int x,
 int y,
 Q... ignoreList)
```
 Draw into this image the provided image at the given coordinates ignoring certain pixels. Parts of the image outside the bounds of this image will be ignored. Side-affects this image. Pixels in the ignore list will be stripped from the image to draw.
 This is a convenience method that calls createRenderer() to get the default renderer to do the actual drawing. Create the renderer yourself and use it to draw if you need more control.
 
 Parameters:
 image - The image to draw.
 x - The x-ordinate of the top-left of the image
 y - The y-ordinate of the top-left of the image
 ignoreList - The list of pixels to ignore when copying the image
 - drawLine
```
public void drawLine(int x1,
 int y1,
 double theta,
 int length,
 int thickness,
 Q col)
```
 Draw a line from the coordinates specified by (x1,y1) at an angle of theta with the given length, thickness and colour. Side-affects this image.
 This is a convenience method that calls createRenderer() to get the default renderer to do the actual drawing. Create the renderer yourself and use it to draw if you need more control.
 
 Parameters:
 x1 - The x-ordinate to start the line.
 y1 - The y-ordinate to start the line.
 theta - The angle at which to draw the line.
 length - The length to draw the line.
 thickness - The thickness to draw the line.
 col - The colour to draw the line.
 - drawLine
```
public void drawLine(int x1,
 int y1,
 double theta,
 int length,
 Q col)
```
 Draw a line from the coordinates specified by (x1,y1) at an angle of theta with the given length and colour. Line-thickness will be 1. Side-affects this image.
 This is a convenience method that calls createRenderer() to get the default renderer to do the actual drawing. Create the renderer yourself and use it to draw if you need more control.
 
 Parameters:
 x1 - The x-ordinate to start the line.
 y1 - The y-ordinate to start the line.
 theta - The angle at which to draw the line.
 length - The length to draw the line.
 col - The colour to draw the line.
 - drawLine
```
public void drawLine(int x0,
 int y0,
 int x1,
 int y1,
 int thickness,
 Q col)
```
 Draw a line from the coordinates specified by (x0,y0) to the coordinates specified by (x1,y1) using the given color and thickness. Side-affects this image.
 This is a convenience method that calls createRenderer() to get the default renderer to do the actual drawing. Create the renderer yourself and use it to draw if you need more control.
 
 Parameters:
 x0 - The x-ordinate at the start of the line.
 y0 - The y-ordinate at the start of the line.
 x1 - The x-ordinate at the end of the line.
 y1 - The y-ordinate at the end of the line.
 thickness - The thickness which to draw the line.
 col - The colour in which to draw the line.
 - drawLine
```
public void drawLine(int x0,
 int y0,
 int x1,
 int y1,
 Q col)
```
 Draw a line from the coordinates specified by (x0,y0) to (x1,y1) using the given colour. The line thickness will be 1 pixel. Side-affects this image.
 This is a convenience method that calls createRenderer() to get the default renderer to do the actual drawing. Create the renderer yourself and use it to draw if you need more control.
 
 Parameters:
 x0 - The x-ordinate at the start of the line.
 y0 - The y-ordinate at the start of the line.
 x1 - The x-ordinate at the end of the line.
 y1 - The y-ordinate at the end of the line.
 col - The colour in which to draw the line.
 - drawLine
```
public void drawLine(Point2d p1,
 Point2d p2,
 Q col)
```
 Draw a line from the coordinates specified using the given colour. The line thickness will be 1 pixel. Side-affects this image.
 This is a convenience method that calls createRenderer() to get the default renderer to do the actual drawing. Create the renderer yourself and use it to draw if you need more control.
 
 Parameters:
 p1 - The coordinate of the start of the line.
 p2 - The coordinate of the end of the line.
 col - The colour in which to draw the line.
 - drawLine
```
public void drawLine(Point2d p1,
 Point2d p2,
 int thickness,
 Q col)
```
 Draw a line from the coordinates specified using the given colour and thickness. Side-affects this image.
 This is a convenience method that calls createRenderer() to get the default renderer to do the actual drawing. Create the renderer yourself and use it to draw if you need more control.
 
 Parameters:
 p1 - The coordinate of the start of the line.
 p2 - The coordinate of the end of the line.
 thickness - the stroke width
 col - The colour in which to draw the line.
 - drawLine
```
public void drawLine(Line2d line,
 int thickness,
 Q col)
```
 Draw a line from the specified Line2d object
 This is a convenience method that calls createRenderer() to get the default renderer to do the actual drawing. Create the renderer yourself and use it to draw if you need more control.
 
 Parameters:
 line - the line
 thickness - the stroke width
 col - The colour in which to draw the line.
 - drawLines
```
public void drawLines(Iterable<? extends Line2d> lines,
 int thickness,
 Q col)
```
 Draw the given list of lines using drawLine(Line2d, int, Object) with the given colour and thickness. Side-affects this image.
 This is a convenience method that calls createRenderer() to get the default renderer to do the actual drawing. Create the renderer yourself and use it to draw if you need more control.
 
 Parameters:
 lines - The list of lines to draw.
 thickness - the stroke width
 col - The colour to draw each point.
 - drawPoint
```
public void drawPoint(Point2d p,
 Q col,
 int size)
```
 Draw a dot centered on the given location (rounded to nearest integer location) at the given size and with the given color. Side-affects this image.
 This is a convenience method that calls createRenderer() to get the default renderer to do the actual drawing. Create the renderer yourself and use it to draw if you need more control.
 
 Parameters:
 p - The coordinates at which to draw the point
 col - The colour to draw the point
 size - The size at which to draw the point.
 - drawPoints
```
public void drawPoints(Iterable<? extends Point2d> pts,
 Q col,
 int size)
```
 Draw the given list of points using drawPoint(Point2d, Object, int) with the given colour and size. Side-affects this image.
 This is a convenience method that calls createRenderer() to get the default renderer to do the actual drawing. Create the renderer yourself and use it to draw if you need more control.
 
 Parameters:
 pts - The list of points to draw.
 col - The colour to draw each point.
 size - The size to draw each point.
 - drawPolygon
```
public void drawPolygon(Polygon p,
 int thickness,
 Q col)
```
 Draw the given polygon in the specified colour with the given thickness lines. Side-affects this image.
 This is a convenience method that calls createRenderer() to get the default renderer to do the actual drawing. Create the renderer yourself and use it to draw if you need more control.
 
 Parameters:
 p - The polygon to draw.
 thickness - The thickness of the lines to use
 col - The colour to draw the lines in
 - drawPolygon
```
public void drawPolygon(Polygon p,
 Q col)
```
 Draw the given polygon in the specified colour. Uses drawPolygon(Polygon, int, Object) with line thickness 1. Side-affects this image.
 This is a convenience method that calls createRenderer() to get the default renderer to do the actual drawing. Create the renderer yourself and use it to draw if you need more control.
 
 Parameters:
 p - The polygon to draw.
 col - The colour to draw the polygon in.
 - drawPolygonFilled
```
public void drawPolygonFilled(Polygon p,
 Q col)
```
 Draw the given polygon, filled with the specified colour. Side-affects this image.
 This is a convenience method that calls createRenderer() to get the default renderer to do the actual drawing. Create the renderer yourself and use it to draw if you need more control.
 
 Parameters:
 p - The polygon to draw.
 col - The colour to fill the polygon with.
 - drawShape
```
public void drawShape(Shape s,
 int thickness,
 Q col)
```
 Draw the given shape in the specified colour with the given thickness lines. Side-affects this image.
 This is a convenience method that calls createRenderer() to get the default renderer to do the actual drawing. Create the renderer yourself and use it to draw if you need more control.
 
 Parameters:
 s - The shape to draw.
 thickness - The thickness of the lines to use
 col - The colour to draw the lines in
 - drawShape
```
public void drawShape(Shape p,
 Q col)
```
 Draw the given shape in the specified colour. Uses drawPolygon(Polygon, int, Object) with line thickness 1. Side-affects this image.
 This is a convenience method that calls createRenderer() to get the default renderer to do the actual drawing. Create the renderer yourself and use it to draw if you need more control.
 
 Parameters:
 p - The shape to draw.
 col - The colour to draw the polygon in.
 - drawShapeFilled
```
public void drawShapeFilled(Shape s,
 Q col)
```
 Draw the given shape, filled with the specified colour. Side-affects this image.
 This is a convenience method that calls createRenderer() to get the default renderer to do the actual drawing. Create the renderer yourself and use it to draw if you need more control.
 
 Parameters:
 s - The shape to draw.
 col - The colour to fill the polygon with.
 - drawText
```
public void drawText(AttributedString text,
 int x,
 int y)
```
 Render the text using its attributes.
 This is a convenience method that calls createRenderer() to get the default renderer to do the actual drawing. Create the renderer yourself and use it to draw if you need more control.
 
 Parameters:
 text - the text
 x - the x-ordinate
 y - the y-ordinate
 - drawText
```
public void drawText(AttributedString text,
 Point2d pt)
```
 Render the text using its attributes.
 This is a convenience method that calls createRenderer() to get the default renderer to do the actual drawing. Create the renderer yourself and use it to draw if you need more control.
 
 Parameters:
 text - the text
 pt - the coordinate to render at
 - drawText
```
public <F extends Font<F>> void drawText(String text,
 int x,
 int y,
 F f,
 int sz)
```
 Render the text in the given font with the default style.
 This is a convenience method that calls createRenderer() to get the default renderer to do the actual drawing. Create the renderer yourself and use it to draw if you need more control.
 
 Type Parameters:
 F - the font
 Parameters:
 text - the text
 x - the x-ordinate
 y - the y-ordinate
 f - the font
 sz - the size
 - drawText
```
public <F extends Font<F>> void drawText(String text,
 int x,
 int y,
 F f,
 int sz,
 Q col)
```
 Render the text in the given font in the given colour with the default style.
 This is a convenience method that calls createRenderer() to get the default renderer to do the actual drawing. Create the renderer yourself and use it to draw if you need more control.
 
 Type Parameters:
 F - the font
 Parameters:
 text - the text
 x - the x-ordinate
 y - the y-ordinate
 f - the font
 sz - the size
 col - the font color
 - drawText
```
public void drawText(String text,
 int x,
 int y,
 FontStyle<Q> f)
```
 Render the text with the given FontStyle.
 This is a convenience method that calls createRenderer() to get the default renderer to do the actual drawing. Create the renderer yourself and use it to draw if you need more control.
 
 Parameters:
 text - the text
 x - the x-ordinate
 y - the y-ordinate
 f - the font style
 - drawText
```
public <F extends Font<F>> void drawText(String text,
 Point2d pt,
 F f,
 int sz)
```
 Render the text in the given font with the default style.
 This is a convenience method that calls createRenderer() to get the default renderer to do the actual drawing. Create the renderer yourself and use it to draw if you need more control.
 
 Type Parameters:
 F - the font
 Parameters:
 text - the text
 pt - the coordinate to render at
 f - the font
 sz - the size
 - drawText
```
public <F extends Font<F>> void drawText(String text,
 Point2d pt,
 F f,
 int sz,
 Q col)
```
 Render the text in the given font in the given colour with the default style.
 This is a convenience method that calls createRenderer() to get the default renderer to do the actual drawing. Create the renderer yourself and use it to draw if you need more control.
 
 Type Parameters:
 F - the font
 Parameters:
 text - the text
 pt - the coordinate to render at
 f - the font
 sz - the size
 col - the font colour
 - drawText
```
public void drawText(String text,
 Point2d pt,
 FontStyle<Q> f)
```
 Render the text with the given FontStyle.
 This is a convenience method that calls createRenderer() to get the default renderer to do the actual drawing. Create the renderer yourself and use it to draw if you need more control.
 
 Parameters:
 text - the text
 pt - the coordinate to render at
 f - the font style
 - extractCenter
```
public I extractCenter(int w,
 int h)
```
 Extract a rectangular region about the centre of the image with the given width and height. The method will return a box that extends width/2 and height/2 from the centre point so that the centre point of the extracted box is also the centre point of the image.
 
 Parameters:
 w - The width of the box to extract
 h - The height of the box to extract
 
 Returns:
 A new image centred around the centre of the image.
 - extractCenter
```
public I extractCenter(int x,
 int y,
 int w,
 int h)
```
 Extract a rectangular region centred on a given point. The method will return a box that extends width/2 and height/2 from the given point (x,y) such that the centre point of the extracted box is the same as the point (x,y) in this image.
 
 Parameters:
 x - Center point of the rectangle to extract
 y - center point of the rectangle to extract
 w - The width of the rectangle to extract
 h - The height of the rectangle to extract
 
 Returns:
 A new image centred around the centre of the image.
 - extractROI
```
public abstract I extractROI(int x,
 int y,
 I img)
```
 Extract a rectangular region of interest from this image and put it in the given image. Coordinate (0,0) is the top-left corner. The width and height of the extracted image should be determined from the given image's width and height.
 
 Parameters:
 x - The leftmost coordinate of the rectangle to extract
 y - The topmost coordinate of the rectangle to extract
 img - The destination image
 
 Returns:
 A reference to the destination image containing the result
 - extractROI
```
public abstract I extractROI(int x,
 int y,
 int w,
 int h)
```
 Extract a rectangular region of interest of the given width and height. Coordinate (0,0) is the top-left corner. Returns a new image.
 
 Parameters:
 x - The leftmost coordinate of the rectangle to extract
 y - The topmost coordinate of the rectangle to extract
 w - The width of the rectangle to extract
 h - The height of the rectangle to extract
 
 Returns:
 A new image representing the selected region
 - extractROI
```
public I extractROI(Rectangle r)
```
 Extract a rectangular region of interest of the given width and height. Coordinate (0,0) is the top-left corner. Returns a new image.
 
 Parameters:
 r - the rectangle
 
 Returns:
 A new image representing the selected region
 - fill
```
public abstract I fill(Q colour)
```
 Fill this image with the given colour. Should overwrite all other data stored in this image. Side-affects this image.
 
 Parameters:
 colour - the colour to fill the image with
 
 Returns:
 A reference to this image.
 - flipX
```
public abstract I flipX()
```
 Flips the content horizontally. Side-affects this image.
 
 Returns:
 A reference to this image.
 - flipY
```
public abstract I flipY()
```
 Flips the content vertically. Side-affects this image.
 
 Returns:
 A reference to this image.
 - getBounds
```
public Rectangle getBounds()
```
 Get a rectangle representing the image, with the top-left at 0,0 and the bottom-right at width,height
 
 Returns:
 the bounding rectangle of the image
 - getCols
```
public int getCols()
```
 Get the image width in pixels. This is syntactic sugar for getWidth();
 
 Returns:
 The image width in pixels.
 - getContentArea
```
public abstract Rectangle getContentArea()
```
 Get bounding box of non-zero-valued pixels around the outside of the image. Used by trim().
 
 Returns:
 A rectangle of the boundaries of the non-zero-valued image
 - getField
```
public abstract I getField(Image.Field f)
```
 Get the given field of this image. Used for deinterlacing video, this should return a new image containing the deinterlaced image. The returned image will be half the height of this image.
 
 Parameters:
 f - The Image.Field to extract from this image
 
 Returns:
 An image containing only the odd or even fields.
 - getFieldCopy
```
public abstract I getFieldCopy(Image.Field f)
```
 Get the given field of this image, maintaining the image's aspect ratio by doubling the fields. Used for deinterlacing video, this should return a new image containing the deinterlaced image. The returned image should be the same size as this image.
 
 Parameters:
 f - The Image.Field to extract from this image
 
 Returns:
 An image containing the odd or even fields doubled.
 - getFieldInterpolate
```
public abstract I getFieldInterpolate(Image.Field f)
```
 Get the given field of this image, maintaining the image's aspect ratio by interpolating between the fields. Used for deinterlacing video, this should return a new image containing the detinterlaced image. The returned image should be the same size as this image.
 
 Parameters:
 f - The Image.Field to extract from this image.
 
 Returns:
 An image containing the odd or even fields with interpolated rows between.
 - getHeight
```
public abstract int getHeight()
```
 Returns the image height in pixels.
 
 Returns:
 The image height in pixels.
 - getPixel
```
public abstract Q getPixel(int x,
 int y)
```
 Get the value of the pixel at coordinate (x, y).
 
 Parameters:
 x - The x-ordinate to get
 y - The y-ordinate to get
 
 Returns:
 The pixel value at (x, y)
 - getPixel
```
public Q getPixel(Pixel p)
```
 Get the value of the pixel at coordinate p
 
 Parameters:
 p - The coordinate to get
 
 Returns:
 The pixel value at (x, y)
 - getPixelComparator
```
public abstract Comparator<? super Q> getPixelComparator()
```
 Returns a pixel comparator that is able to compare equality of pixels in the given image type.
 
 Returns:
 A Comparator that compares pixels.
 - getPixelInterp
```
public abstract Q getPixelInterp(double x,
 double y)
```
 Get the value of a sub-pixel using linear-interpolation.
 
 Parameters:
 x - The x-ordinate to get
 y - The y-ordinate to get
 
 Returns:
 The value of the interpolated point at (x,y)
 - getPixelInterp
```
public abstract Q getPixelInterp(double x,
 double y,
 Q backgroundColour)
```
 Get the value of a sub-pixel using linear-interpolation. Also specify the colour of the background (for interpolation at the edge)
 
 Parameters:
 x - The x-ordinate to get.
 y - The y-ordinate to get.
 backgroundColour - The colour of the background pixel.
 
 Returns:
 The value of the interpolated point at (x,y)
 - getPixelVector
```
public Q[] getPixelVector(Q[] f)
```
 Returns the pixels in this image as a vector (an array of the pixel type).
 
 Parameters:
 f - The array into which to place the data
 
 Returns:
 The pixels in the image as a vector (a reference to the given array).
 - getRows
```
public int getRows()
```
 Get the height of this image. This is a syntactic sugar method for getHeight().
 
 Returns:
 The image height in pixels.
 - getWidth
```
public abstract int getWidth()
```
 Get the width (number of columns) in this image.
 
 Returns:
 the image width
 - internalCopy
```
public abstract I internalCopy(I im)
```
 Copy the internal state from another image of the same type. This method is designed to be FAST. This means that bounds checking WILL NOT be performed, so it is important that the images are the SAME size.
 
 Parameters:
 im - The source image to make a copy of.
 
 Returns:
 A reference to this image.
 - internalAssign
```
public abstract I internalAssign(I im)
```
 Assign the internal state from another image of the same type.
 
 Parameters:
 im - The source image to make a copy of.
 
 Returns:
 A reference to this image.
 - internalAssign
```
public abstract I internalAssign(int[] pixelData,
 int width,
 int height)
```
 Copy pixels from given ARGB buffer image into this image. Side-affects this image.
 
 Parameters:
 pixelData - buffer of ARGB packed integer pixels
 width - the width of the buffer
 height - the height of the buffer
 
 Returns:
 A reference to this image.
 - inverse
```
public abstract I inverse()
```
 Invert the image pixels by finding the maximum value and subtracting each pixel value from that maximum.
 
 Returns:
 A reference to this image.
 - max
```
public abstract Q max()
```
 Find the maximum pixel value.
 
 Returns:
 The maximum pixel value
 - min
```
public abstract Q min()
```
 Find the minimum pixel value.
 
 Returns:
 The minimum pixel value
 - multiply
```
public I multiply(Image<?,?> im)
```
 Multiply the pixel values in this image with the corresponding pixel values in the given image. This method returns a new image.
 
 Parameters:
 im - The image to multiply with this one
 
 Returns:
 A new image containing the result.
 - multiply
```
public I multiply(Q num)
```
 Multiply each pixel of this by the given scalar and return new image.
 
 Parameters:
 num - The scalar which to multiply the image by
 
 Returns:
 A new image containing the result
 - multiplyInplace
```
public abstract I multiplyInplace(Image<?,?> im)
```
 Multiply each pixel in this image by the corresponding pixel in the given image. This method side-affects this image.
 
 Parameters:
 im - The image to multiply with this image.
 
 Returns:
 A reference to this image.
 - multiplyInplace
```
public abstract I multiplyInplace(Q num)
```
 Multiply each pixel of this by the given scalar. This method side-affects this image.
 
 Parameters:
 num - The scalar to multiply this image by.
 
 Returns:
 A reference to this image.
 - newInstance
```
public abstract I newInstance(int width,
 int height)
```
 Create a new instance of this image subclass with given dimensions.
 
 Parameters:
 width - The image width
 height - The image height
 
 Returns:
 A new instance of an image of type I
 - normalise
```
public abstract I normalise()
```
 Normalise all pixel values to fall within the range 0.0 - 1.0. This should be scaled by both the maximum and minimum values. This method side-affects this image.
 
 Returns:
 A reference to this image.
 - padding
```
public I padding(int paddingWidth,
 int paddingHeight)
```
 Adds padding as in padding(int, int, Object). The padding colour is the colour of the closest border pixel.
 
 Parameters:
 paddingWidth - padding in the x direction
 paddingHeight - padding in the y direction
 
 Returns:
 padded image
 - padding
```
public I padding(int paddingWidth,
 int paddingHeight,
 Q paddingColour)
```
 Adds this many pixels to both sides of the image such that the new image width = padding + width + padding with the original image in the middle
 
 Parameters:
 paddingWidth - left and right padding width
 paddingHeight - top and bottom padding width
 paddingColour - colour of padding, if null the closes border pixel is used
 
 Returns:
 padded image
 - paddingSymmetric
```
public I paddingSymmetric(int paddingLeft,
 int paddingRight,
 int paddingTop,
 int paddingBottom)
```
 Adds pixels to around the image such that the new image width = paddingLeft + width + paddingRight with the original image in the middle. The values of the padding pixels are formed from repeated symmetric reflections of the original image.
 
 Parameters:
 paddingLeft - left padding width
 paddingRight - right padding width
 paddingTop - top padding width
 paddingBottom - bottom padding width
 
 Returns:
 padded image
 - process
```
public I process(GridProcessor<Q,I> p)
```
 Process this image with the given GridProcessor and return new image containing the result.
 
 Parameters:
 p - GridProcessor to apply to this image.
 
 Returns:
 A new image containing the result.
 - process
```
public I process(ImageProcessor p)
```
 Process this image with an ImageProcessor and return new image containing the result.
 
 Parameters:
 p - The ImageProcessor to apply to this image.
 
 Returns:
 A new image containing the result.
 - process
```
public I process(KernelProcessor<Q,I> p)
```
 Process this image with the given KernelProcessor and return new image containing the result.
 
 Parameters:
 p - The KernelProcessor to apply.
 
 Returns:
 A new image containing the result.
 - process
```
public I process(KernelProcessor<Q,I> p,
 boolean pad)
```
 Process this image with the given KernelProcessor and return new image containing the result.
 
 Parameters:
 p - The KernelProcessor to apply.
 pad - Should the image be zero padded so the kernel reaches the edges of the output
 
 Returns:
 A new image containing the result.
 - process
```
public I process(PixelProcessor<Q> p)
```
 Process this image with the given PixelProcessor and return a new image containing the result.
 
 Parameters:
 p - The PixelProcessor to apply.
 
 Returns:
 A new image containing the result.
 - process
```
public I process(Processor p)
```
 Process this image with an Processor and return new image containing the result.
 
 Parameters:
 p - The Processor to apply to this image.
 
 Returns:
 A new image containing the result.
 - processInplace
```
public I processInplace(Processor p)
```
 Process this image with the given Processor side-affecting this image.
 
 Parameters:
 p - The Processor to apply.
 
 Returns:
 A reference to this image containing the result.
 - processInplace
```
public I processInplace(ImageProcessor p)
```
 Process this image with the given ImageProcessor side-affecting this image.
 
 Parameters:
 p - The ImageProcessor to apply.
 
 Returns:
 A reference to this image containing the result.
 - processInplace
```
public I processInplace(KernelProcessor<Q,I> p)
```
 Process this image with the given KernelProcessor side-affecting this image.
 
 Parameters:
 p - The KernelProcessor to apply.
 
 Returns:
 A reference to this image containing the result.
 - processInplace
```
public I processInplace(KernelProcessor<Q,I> p,
 boolean pad)
```
 Process this image with the given KernelProcessor side-affecting this image.
 
 Parameters:
 p - The KernelProcessor to apply.
 pad - Should the image be zero padded so the kernel reaches the edges of the output
 
 Returns:
 A reference to this image containing the result.
 - processInplace
```
public I processInplace(PixelProcessor<Q> p)
```
 Process this image with the given PixelProcessor side-affecting this image.
 
 Parameters:
 p - The PixelProcessor to apply.
 
 Returns:
 A reference to this image containing the result.
 - processMasked
```
public I processMasked(FImage mask,
 PixelProcessor<Q> p)
```
 Process this image with the given PixelProcessor only affecting those pixels where the mask is non-zero. Returns a new image.
 
 Parameters:
 mask - The mask to apply to the processing.
 p - The PixelProcessor to apply.
 
 Returns:
 A new image containing the result.
 - processMaskedInplace
```
public I processMaskedInplace(FImage mask,
 PixelProcessor<Q> p)
```
 Process this image with the given PixelProcessor, only affecting those pixels where the mask is non-zero. Side-affects this image.
 
 Parameters:
 mask - The mask to apply to the processor.
 p - The PixelProcessor to apply.
 
 Returns:
 A reference to this image containing the result.
 - setPixel
```
public abstract void setPixel(int x,
 int y,
 Q val)
```
 Sets the pixel at (x,y) to the given value. Side-affects this image.
 
 Parameters:
 x - The x-ordinate of the pixel to set
 y - The y-ordinate of the pixel to set
 val - The value to set the pixel to.
 - subtract
```
public I subtract(Image<?,?> im)
```
 Subtract the corresponding pixel value from the given image from the pixel values in this image. Returns a new image.
 
 Parameters:
 im - The image to subtract from this image.
 
 Returns:
 A new image containing the result.
 - subtract
```
public I subtract(Q num)
```
 Subtract a scalar from every pixel value in this image and return new image.
 
 Parameters:
 num - A value to subtract from each pixel.
 
 Returns:
 A new image containing the result.
 - subtractInplace
```
public abstract I subtractInplace(Image<?,?> im)
```
 Subtract the corresponding pixel value from the given image from the pixel values in this image. Side-affects this image.
 
 Parameters:
 im - The image to subtract from this image.
 
 Returns:
 A reference to this containing the result.
 - subtractInplace
```
public abstract I subtractInplace(Q num)
```
 Subtract a scalar from every pixel value in this image. Side-affects this image.
 
 Parameters:
 num - A value to subtract from each pixel.
 
 Returns:
 A reference to this image containing the result.
 - threshold
```
public abstract I threshold(Q thresh)
```
 Set all values less than the given threshold to 0 and all others to 1. Side-affects this image.
 
 Parameters:
 thresh - The threshold value
 
 Returns:
 A reference to this image containing the result.
 - toByteImage
```
public abstract byte[] toByteImage()
```
 Convert the image to a byte representation suitable for writing to a pnm type format. Each byte should represent a single pixel. Multiband images should interleave the data; e.g. [R1,G1,B1,R2,G2,B2...etc.]
 
 Returns:
 This image as a byte array
 - toPackedARGBPixels
```
public abstract int[] toPackedARGBPixels()
```
 Returns a 1D array representation of this image with each pixel represented as a packed ARGB integer.
 
 Returns:
 An array of ARGB pixels.
 - transform
```
public I transform(Jama.Matrix transform)
```
 Apply a transform matrix to the image and returns the result as a new image.
 
 Parameters:
 transform - The transform matrix to apply.
 
 Returns:
 A new image containing the result.
 - trim
```
public I trim()
```
 Removes zero-valued pixels from around the outside of the image. Analagous to String.trim().
 
 Returns:
 A new image containing the trimmed image.
 - zero
```
public abstract I zero()
```
 Set all pixels in the image to zero. Side-affects this image.
 
 Returns:
 A reference to this image containing the result.
 - shiftLeftInplace
```
public I shiftLeftInplace()
```
 Shifts all the pixels to the left by one pixel
 
 Returns:
 A reference to this image.
 - shiftRightInplace
```
public I shiftRightInplace()
```
 Shifts all the pixels to the right by one pixel
 
 Returns:
 A reference to this image.
 - shiftLeftInplace
```
public I shiftLeftInplace(int count)
```
 Shifts all the pixels to the left by count pixel
 
 Parameters:
 count - The number of pixels
 
 Returns:
 A reference to this image.
 - shiftRightInplace
```
public I shiftRightInplace(int count)
```
 Shifts all the pixels to the right by count pixel
 
 Parameters:
 count - The number of pixels
 
 Returns:
 A reference to this image.
 - shiftLeft
```
public I shiftLeft()
```
 Returns a new image that is it shifted around the x-ordinates by one pixel
 
 Returns:
 A new image shifted around to the left by one pixel
 - shiftLeft
```
public I shiftLeft(int nPixels)
```
 Returns a new image that is it shifted around the x-ordinates by the number of pixels given.
 
 Parameters:
 nPixels - The number of pixels
 
 Returns:
 A new image shifted around to the left by the number of pixels
 - shiftRight
```
public I shiftRight()
```
 Returns a new image that is it shifted around the x-ordinates by one pixel
 
 Returns:
 A new image shifted around to the right by one pixel
 - shiftRight
```
public I shiftRight(int nPixels)
```
 Returns a new image that is it shifted around the x-ordinates by the number of pixels given.
 
 Parameters:
 nPixels - the number of pixels
 
 Returns:
 A new image shifted around to the right by the number of pixels
 - shiftUpInplace
```
public I shiftUpInplace()
```
 Shifts all the pixels up by one pixel
 
 Returns:
 A reference to this image.
 - shiftDownInplace
```
public I shiftDownInplace()
```
 Shifts all the pixels down by one pixels
 
 Returns:
 A reference to this image.
 - shiftUpInplace
```
public I shiftUpInplace(int count)
```
 Shifts all the pixels up by count pixels
 
 Parameters:
 count - The number of pixels
 
 Returns:
 A reference to this image.
 - shiftDownInplace
```
public I shiftDownInplace(int count)
```
 Shifts all the pixels down by count pixels
 
 Parameters:
 count - The number of pixels
 
 Returns:
 A reference to this image.
 - shiftUp
```
public I shiftUp()
```
 Returns a new image that is it shifted around the x-ordinates by one pixel
 
 Returns:
 A new image shifted around up by one pixel
 - shiftUp
```
public I shiftUp(int nPixels)
```
 Returns a new image that is it shifted around the x-ordinates by the number of pixels given.
 
 Parameters:
 nPixels - The number of pixels
 
 Returns:
 A new image shifted around up by the number of pixels
 - shiftDown
```
public I shiftDown()
```
 Returns a new image that is it shifted around the x-ordinates by one pixel
 
 Returns:
 A new image shifted around down by one pixel
 - shiftDown
```
public I shiftDown(int nPixels)
```
 Returns a new image that is it shifted around the x-ordinates by the number of pixels given.
 
 Parameters:
 nPixels - the number of pixels
 
 Returns:
 A new image shifted around down by the number of pixels
 - overlay
```
public I overlay(I image,
 int x,
 int y)
```
 Overlays the given image on this image and returns a new image containing the result.
 
 Parameters:
 image - The image to overlay on this image.
 x - The location at which to overlay the image
 y - The location at which to overlay the image
 
 Returns:
 A new image containing the result
 - overlayInplace
```
public abstract I overlayInplace(I image,
 int x,
 int y)
```
 Overlays the given image on this image directly. The method returns this image for chaining.
 
 Parameters:
 image - The image to overlay
 x - The location at which to overlay the image
 y - The location at which to overlay the image
 
 Returns:
 Returns this image
 - getImage
```
public I getImage()
```
 Description copied from interface: ImageProvider
 
 Get the image that this provider provides.
 
 Specified by:
 
 getImage in interface ImageProvider>
 
 Returns:
 the image
 - replace
```
public abstract I replace(Q target,
 Q replacement)
```
 Replace pixels of a certain colour with another colour. Side-affects this image.
 
 Parameters:
 target - the colour to fill the image with
 replacement - the colour to fill the image with
 
 Returns:
 A reference to this image.
 - extractCentreSubPix
```
public I extractCentreSubPix(Point2d centre,
 int width,
 int height)
```
 Sub-pixel sampling of a centred rectangular region such that dst(x, y) = src(x + center.x (width(dst) 1) ⇤ 0.5, y + center.y (height(dst) 1) ⇤ 0.5) . Sub-pixels values are estimated using bilinear interpolation.
 
 Parameters:
 centre - the centre
 width - the region width
 height - the region height
 
 Returns:
 the extracted sub-pixel region
 See Also:
 getPixelInterp(double, double)
 - extractCentreSubPix
```
public I extractCentreSubPix(float cx,
 float cy,
 int width,
 int height)
```
 Sub-pixel sampling of a centred rectangular region such that dst(x, y) = src(x + center.x (width(dst) 1) ⇤ 0.5, y + center.y (height(dst) 1) ⇤ 0.5) . Sub-pixels values are estimated using bilinear interpolation.
 
 Parameters:
 cx - the x-ordinate of the centre
 cy - the y-ordinate of the centre
 width - the region width
 height - the region height
 
 Returns:
 the extracted sub-pixel region
 See Also:
 getPixelInterp(double, double)
 - extractCentreSubPix
```
public I extractCentreSubPix(Point2d centre,
 I out)
```
 Sub-pixel sampling of a centred rectangular region such that dst(x, y) = src(x + center.x (width(dst) 1) ⇤ 0.5, y + center.y (height(dst) 1) ⇤ 0.5) . Sub-pixels values are estimated using bilinear interpolation.
 
 Parameters:
 centre - the centre
 out - the output image (also defines the size of the extracted region)
 
 Returns:
 out
 See Also:
 getPixelInterp(double, double)
 - extractCentreSubPix
```
public abstract I extractCentreSubPix(float cx,
 float cy,
 I out)
```
 Sub-pixel sampling of a centred rectangular region such that dst(x, y) = src(x + center.x (width(dst) 1) ⇤ 0.5, y + center.y (height(dst) 1) ⇤ 0.5) . Sub-pixels values are estimated using bilinear interpolation.
 
 Parameters:
 cx - the x-ordinate of the centre
 cy - the y-ordinate of the centre
 out - the output image (also defines the size of the extracted region)
 
 Returns:
 out
 See Also:
 getPixelInterp(double, double)

Class Image<Q,I extends Image<Q,I>>

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

Image

Method Detail

accumulateWith

abs

add

add

addInplace

addInplace

analyseWith

analyseWith

analyseWithMasked

clip

clipMax

clipMin

clone

createRenderer

createRenderer

combineWith

defaultBackgroundColour

defaultForegroundColour

divide

divide

divideInplace

divideInplace

drawConnectedPoints

drawCubicBezier

drawImage

drawImage

drawImage

drawLine

drawLine

drawLine

drawLine

drawLine

drawLine

drawLine

drawLines

drawPoint

drawPoints

drawPolygon

drawPolygon

drawPolygonFilled

drawShape

drawShape

drawShapeFilled

drawText

drawText

drawText

drawText

drawText

drawText

drawText

drawText

extractCenter

extractCenter

extractROI

extractROI

extractROI

fill

flipX

flipY

getBounds

getCols

getContentArea

getField

getFieldCopy

getFieldInterpolate

getHeight

getPixel

getPixel

getPixelComparator

getPixelInterp

getPixelInterp

getPixelVector