FImage (OpenIMAJ master project 1.3.1 API)

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

All Implemented Interfaces:

Serializable, Cloneable, ImageProvider<FImage>, SinglebandImageProcessor.Processable<Float,FImage,FImage>, SinglebandKernelProcessor.Processable<Float,FImage,FImage>
```
public class FImage
extends SingleBandImage<Float,FImage>
```
Class representing a single-band floating-point image; that is an image where each pixel is represented by a floating-point number.
FImages can be created from PGM files or from pixel arrays. If you wish to read other types of files then use the ImageUtilities class that provides read/write functions for Image objects.

Author:

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

See Also:
Serialized Form

Nested Class Summary
- Nested classes/interfaces inherited from class org.openimaj.image.Image
  Image.Field

Field Summary

Fields
Modifier and Type	Field and Description
`protected static float`	`DEFAULT_GAUSS_TRUNCATE` The default number of sigmas at which the Gaussian function is truncated when building a kernel
`protected static org.apache.log4j.Logger`	`logger` The logging class
`float[][]`	`pixels` The underlying pixels

Fields inherited from class org.openimaj.image.SingleBandImage
height, width

Constructor Summary

Constructors
Constructor and Description
`FImage(float[][] array)` Create an `FImage` from an array of floating point values.
`FImage(float[] array, int width, int height)` Create an `FImage` from an array of floating point values with the given width and height.
`FImage(int[] data, int width, int height)` Construct an `FImage` from an array of packed ARGB integers.
`FImage(int[] data, int width, int height, ARGBPlane plane)` Construct an `FImage` from an array of packed ARGB integers using the specified plane.
`FImage(int width, int height)` Create an empty `FImage` of the given size.

Method Summary

Methods
Modifier and Type	Method and Description
`FImage`	`abs()` Set all pixels to their absolute values, so that all pixel values in the image will be greater than zero.
`FImage`	`add(FImage im)` Adds the pixel values of the given `FImage` to the pixels of this image.
`FImage`	`add(Float num)` Returns a new `FImage` that contains the pixels of this image increased by the given value.
`FImage`	`add(Image<?,?> im)` Adds the given image to this image and return new image.
`FImage`	`addInplace(FImage im)` Adds the given image pixel values to the pixel values of this image.
`FImage`	`addInplace(Float num)` Add a scalar to each pixel in this image (side-affects this image).
`FImage`	`addInplace(Image<?,?> im)` Add the given image to this image (side-affects this image).
`void`	`analyseWith(PixelAnalyser<Float> p)` Analyse this image with a `PixelAnalyser`.
`FImage`	`clip(Float min, Float 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).
`FImage`	`clipMax(Float thresh)` Set all values greater than the given value to the highest normal value that the image allows (usually 1 for floating-point images).
`FImage`	`clipMin(Float thresh)` Set all values less than the given value to zero.
`FImage`	`clone()` Deep copy of an image (internal image buffers copied).
`static FImage[]`	`createArray(int num, int width, int height)` Convenience method to initialise an array of FImages
`FImageRenderer`	`createRenderer()` Create a `ImageRenderer` capable of drawing into this image.
`FImageRenderer`	`createRenderer(RenderHints options)` Create a `ImageRenderer` capable of drawing into this image.
`FImage`	`divide(FImage im)` Divides the pixels values of this image with the values from the given image.
`FImage`	`divideInplace(FImage im)` Divides the pixel values of this image with the values from the given image.
`FImage`	`divideInplace(float fval)` Divide all pixels by a given value
`FImage`	`divideInplace(Float val)` Divide each pixel of the image by the given scalar value.
`FImage`	`divideInplace(Image<?,?> im)` Divide each pixel in this image by the corresponding pixel value in the given image.
`boolean`	`equals(Object o)`
`boolean`	`equalsThresh(FImage o, float thresh)` Compare this image against another using a threshold on the absolute difference between pixel values in order to determine equality.
`FImage`	`extractCentreSubPix(float cx, float cy, FImage 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)` .
`FImage`	`extractROI(int x, int y, FImage out)` Extract a rectangular region of interest from this image and put it in the given image.
`FImage`	`extractROI(int x, int y, int w, int h)` Extract a rectangular region of interest of the given width and height.
`FImage`	`fill(float colour)` Fill an image with the given colour
`FImage`	`fill(Float colour)` Fill this image with the given colour.
`FImage`	`flipX()` Flips the content horizontally.
`FImage`	`flipY()` Flips the content vertically.
`Rectangle`	`getContentArea()` Get bounding box of non-zero-valued pixels around the outside of the image.
`double[]`	`getDoublePixelVector()` Returns the pixels of the image as a vector (array) of doubles.
`FImage`	`getField(Image.Field f)` Get the given field of this image.
`FImage`	`getFieldCopy(Image.Field f)` Get the given field of this image, maintaining the image's aspect ratio by doubling the fields.
`FImage`	`getFieldInterpolate(Image.Field f)` Get the given field of this image, maintaining the image's aspect ratio by interpolating between the fields.
`float[]`	`getFloatPixelVector()` Returns the pixels of the image as a vector (array) of doubles.
`Float`	`getPixel(int x, int y)` Get the value of the pixel at coordinate `(x, y)`.
`Comparator<? super Float>`	`getPixelComparator()` Returns a pixel comparator that is able to compare equality of pixels in the given image type.
`Float`	`getPixelInterp(double x, double y)` Get the value of a sub-pixel using linear-interpolation.
`Float`	`getPixelInterp(double x, double y, Float background)` Get the value of a sub-pixel using linear-interpolation.
`float`	`getPixelInterpNative(float x, float y, float background)` Interpolate the value of a pixel at the given coordinates
`float`	`getPixelNative(int x, int y)` Get the value of the pixel at coordinate `(x, y)`.
`float`	`getPixelNative(Pixel p)` Get the value of the pixel at coordinate p
`float[]`	`getPixelVectorNative(float[] f)` Returns the pixels in this image as a vector (an array of the pixel type).
`FImage`	`internalAssign(FImage im)` Assign the internal state from another image of the same type.
`FImage`	`internalAssign(int[] data, int width, int height)` Copy pixels from given ARGB buffer image into this image.
`FImage`	`internalCopy(FImage im)` Copy the internal state from another image of the same type.
`FImage`	`inverse()` Invert the image pixels by finding the maximum value and subtracting each pixel value from that maximum.
`Float`	`max()` Find the maximum pixel value.
`FValuePixel`	`maxPixel()` Get the pixel with the maximum value.
`Float`	`min()` Find the minimum pixel value.
`FValuePixel`	`minPixel()` Get the pixel with the minimum value.
`FImage`	`multiply(Float num)` Multiply each pixel of this by the given scalar and return new image.
`FImage`	`multiplyInplace(FImage im)` Multiplies this image's pixel values by the corresponding pixel values in the given image side-affecting this image.
`FImage`	`multiplyInplace(float fnum)` Multiply all pixel values by the given value
`FImage`	`multiplyInplace(Float num)` Multiply each pixel of this by the given scalar.
`FImage`	`multiplyInplace(Image<?,?> im)` Multiply each pixel in this image by the corresponding pixel in the given image.
`FImage`	`newInstance(int width, int height)` Create a new instance of this image subclass with given dimensions.
`FImage`	`normalise()` Normalise all pixel values to fall within the range 0.0 - 1.0.
`FImage`	`overlayInplace(FImage img, FImage alpha, int x, int y)` Overlay the given image on this image with the given alpha channel at the given location.
`FImage`	`overlayInplace(FImage image, int x, int y)` Overlays the given image on this image directly.
`FImage`	`process(KernelProcessor<Float,FImage> p)` Process this image with the given `KernelProcessor` and return new image containing the result.
`FImage`	`process(KernelProcessor<Float,FImage> p, boolean pad)` Process this image with the given `KernelProcessor` and return new image containing the result.
`FImage`	`processInplace(PixelProcessor<Float> p)` Process this image with the given `PixelProcessor` side-affecting this image.
`static FImage`	`randomImage(int width, int height)` Create a random image of the given size.
`FImage`	`replace(float target, float replacement)` Replace pixels of a certain colour with another colour.
`FImage`	`replace(Float target, Float replacement)` Replace pixels of a certain colour with another colour.
`void`	`setPixel(int x, int y, Float val)` Sets the pixel at `(x,y)` to the given value.
`void`	`setPixelNative(int x, int y, float val)` Sets the pixel at `(x,y)` to the given value.
`FImage`	`subtract(FImage im)` Subtracts the given `FImage` from this image returning a new image containing the result.
`FImage`	`subtract(Float num)` Subtract a scalar from every pixel value in this image and return new image.
`FImage`	`subtract(Image<?,?> input)` Subtract the corresponding pixel value from the given image from the pixel values in this image.
`FImage`	`subtractInplace(FImage im)` Subtracts (pixel-by-pixel) the given `FImage` from this image.
`FImage`	`subtractInplace(Float num)` Subtract a scalar from every pixel value in this image.
`FImage`	`subtractInplace(Image<?,?> im)` Subtract the corresponding pixel value from the given image from the pixel values in this image.
`float`	`sum()`
`FImage`	`threshold(Float thresh)` Set all values less than the given threshold to 0 and all others to 1.
`byte[]`	`toByteImage()` Convert the image to a byte representation suitable for writing to a pnm type format.
`int[]`	`toPackedARGBPixels()` Returns a 1D array representation of this image with each pixel represented as a packed ARGB integer.
`MBFImage`	`toRGB()` Convert this `FImage` to an RGB `MBFImage`.
`String`	`toString()`
`String`	`toString(String format)` Returns a string representation of every pixel in this image using the format string (see `String.format(String, Object...)`) to format each pixel value.
`FImage`	`transform(Jama.Matrix transform)` Apply a transform matrix to the image and returns the result as a new image.
`FImage`	`zero()` Set all pixels in the image to zero.

Methods inherited from class org.openimaj.image.SingleBandImage
getHeight, getWidth, process, process, process, processInplace, processInplace, processInplace

Methods inherited from class org.openimaj.image.Image
accumulateWith, analyseWith, analyseWithMasked, combineWith, defaultBackgroundColour, defaultForegroundColour, divide, divide, 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, extractCentreSubPix, extractCentreSubPix, extractCentreSubPix, extractROI, getBounds, getCols, getImage, getPixel, getPixelVector, getRows, multiply, overlay, padding, padding, paddingSymmetric, process, process, process, process, processInplace, processInplace, processInplace, processInplace, processMasked, processMaskedInplace, shiftDown, shiftDown, shiftDownInplace, shiftDownInplace, shiftLeft, shiftLeft, shiftLeftInplace, shiftLeftInplace, shiftRight, shiftRight, shiftRightInplace, shiftRightInplace, shiftUp, shiftUp, shiftUpInplace, shiftUpInplace, trim

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

- Field Detail
  - logger
```
protected static org.apache.log4j.Logger logger
```
    The logging class
  - DEFAULT_GAUSS_TRUNCATE
```
protected static final float DEFAULT_GAUSS_TRUNCATE
```
    The default number of sigmas at which the Gaussian function is truncated when building a kernel
    
    See Also:
    Constant Field Values
  - pixels
```
public float[][] pixels
```
    The underlying pixels
- Constructor Detail
  - FImage
```
public FImage(float[] array,
      int width,
      int height)
```
    Create an FImage from an array of floating point values with the given width and height. The length of the array must equal the width multiplied by the height.
    
    Parameters:
    array - An array of floating point values.
    width - The width of the resulting image.
    height - The height of th resulting image.
  - FImage
```
public FImage(float[][] array)
```
    Create an FImage from an array of floating point values.
    
    Parameters:
    array - the array representing pixel values to copy data from.
  - FImage
```
public FImage(int width,
      int height)
```
    Create an empty FImage of the given size.
    
    Parameters:
    width - image width (number of columns)
    height - image height (number of rows)
  - FImage
```
public FImage(int[] data,
      int width,
      int height)
```
    Construct an FImage from an array of packed ARGB integers.
    
    Parameters:
    data - array of packed ARGB pixels
    width - the image width
    height - the image height
  - FImage
```
public FImage(int[] data,
      int width,
      int height,
      ARGBPlane plane)
```
    Construct an FImage from an array of packed ARGB integers using the specified plane.
    
    Parameters:
    data - array of packed ARGB pixels
    width - the image width
    height - the image height
    plane - The ARGBPlane to copy data from
- Method Detail
  - abs
```
public FImage abs()
```
    Set all pixels to their absolute values, so that all pixel values in the image will be greater than zero.
    
    Specified by:
    
    abs in class Image<Float,FImage>
    
    Returns:
    The image with absolute values
    See Also:
    Image.abs()
  - add
```
public FImage add(FImage im)
```
    Adds the pixel values of the given FImage to the pixels of this image. Returns a new FImage and does not affect this image or the given image. This is a version of Image.add(Image) which takes an FImage. This method directly accesses the underlying float[][] and is therefore fast. This function returns a new FImage.
    
    Parameters:
    im - FImage to add into this one.
    
    Returns:
    A new FImage
    See Also:
    Image.add(Image)
  - add
```
public FImage add(Float num)
```
    Returns a new FImage that contains the pixels of this image increased by the given value. Add a value to each pixel and return new image.
    
    Overrides:
    
    add in class Image<Float,FImage>
    
    Parameters:
    num - The value to add to each pixel
    
    Returns:
    A new image that is the sum of this image and the given value.
    See Also:
    Image.add(java.lang.Object)
  - add
```
public FImage add(Image<?,?> im)
```
    Adds the given image to this image and return new image. This method throws an UnsupportedOperationException if the given image is not an FImage.
    
    Overrides:
    
    add in class Image<Float,FImage>
    
    Parameters:
    im - The image to add
    
    Returns:
    a reference to this FImage
    
    Throws:
    
    UnsupportedOperationException - if an unsupported type is added
    See Also:
    Image.add(org.openimaj.image.Image)
  - addInplace
```
public FImage addInplace(FImage im)
```
    Adds the given image pixel values to the pixel values of this image. Version of Image.addInplace(Image) which takes an FImage. This directly accesses the underlying float[][] and is therefore fast. This function side-affects the pixels in this FImage.
    
    Parameters:
    im - the FImage to add
    
    Returns:
    a reference to this
    See Also:
    Image.addInplace(Image)
  - addInplace
```
public FImage addInplace(Float num)
```
    Add a scalar to each pixel in this image (side-affects this image).
    
    Specified by:
    
    addInplace in class Image<Float,FImage>
    
    Parameters:
    num - The value to add to every pixel in this image.
    
    Returns:
    A reference to this image.
    See Also:
    Image.addInplace(java.lang.Object)
  - addInplace
```
public FImage addInplace(Image<?,?> im)
```
    Add the given image to this image (side-affects this image). This method throws an UnsupportedOperationException if the given image is not an FImage.
    
    Specified by:
    
    addInplace in class Image<Float,FImage>
    
    Parameters:
    im - The image to add to this image
    
    Returns:
    a reference to this FImage
    
    Throws:
    
    UnsupportedOperationException - if an unsupported type is added
    See Also:
    Image.addInplace(org.openimaj.image.Image)
  - clip
```
public FImage clip(Float min,
          Float 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.
    
    Specified by:
    
    clip in class Image<Float,FImage>
    
    Parameters:
    min - The minimum value
    max - The maximum value
    
    Returns:
    The clipped image.
    See Also:
    Image.clip(java.lang.Object, java.lang.Object)
  - clipMax
```
public FImage clipMax(Float 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.
    
    Specified by:
    
    clipMax in class Image<Float,FImage>
    
    Parameters:
    thresh - The value over which pixels are clipped to zero.
    
    Returns:
    The clipped image.
    See Also:
    Image.clipMax(java.lang.Object)
  - clipMin
```
public FImage clipMin(Float thresh)
```
    Set all values less than the given value to zero. This method may side-affect this image.
    
    Specified by:
    
    clipMin in class Image<Float,FImage>
    
    Parameters:
    thresh - The value below which pixels are clipped to zero.
    
    Returns:
    The clipped image.
    See Also:
    Image.clipMin(java.lang.Object)
  - clone
```
public FImage clone()
```
    Deep copy of an image (internal image buffers copied).
    
    Specified by:
    
    clone in class SingleBandImage<Float,FImage>
    
    Returns:
    A copy of this image.
    See Also:
    SingleBandImage.clone()
  - createRenderer
```
public FImageRenderer createRenderer()
```
    Description copied from class: Image
    
    Create a ImageRenderer capable of drawing into this image.
    
    Specified by:
    
    createRenderer in class Image<Float,FImage>
    
    Returns:
    the renderer
  - createRenderer
```
public FImageRenderer createRenderer(RenderHints options)
```
    Description copied from class: Image
    
    Create a ImageRenderer capable of drawing into this image.
    
    Specified by:
    
    createRenderer in class Image<Float,FImage>
    
    Parameters:
    options - Options for the renderer
    
    Returns:
    the renderer
  - divide
```
public FImage divide(FImage im)
```
    Divides the pixels values of this image with the values from the given image. This is a version of Image.divide(Image) which takes an FImage. This directly accesses the underlying float[][] and is therefore fast. This function returns a new FImage.
    
    Parameters:
    im - the FImage to be the denominator.
    
    Returns:
    A new FImage
    See Also:
    Image.divide(Image)
  - divideInplace
```
public FImage divideInplace(FImage im)
```
    Divides the pixel values of this image with the values from the given image. This is a version of Image.divideInplace(Image) which takes an FImage. This directly accesses the underlying float[][] and is therefore fast. This function side-affects this image.
    
    Parameters:
    im - the FImage to be the denominator
    
    Returns:
    a reference to this FImage
    See Also:
    Image.divideInplace(Image)
  - divideInplace
```
public FImage divideInplace(Float val)
```
    Divide each pixel of the image by the given scalar value. This method should side-affect this image.
    
    Specified by:
    
    divideInplace in class Image<Float,FImage>
    
    Parameters:
    val - The value to divide each pixel by.
    
    Returns:
    A reference to this image containing the result.
    See Also:
    Image.divideInplace(java.lang.Object)
  - divideInplace
```
public FImage divideInplace(float fval)
```
    Divide all pixels by a given value
    
    Parameters:
    fval - the value
    
    Returns:
    this image
    See Also:
    Image.divideInplace(java.lang.Object)
  - divideInplace
```
public FImage 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.
    
    Specified by:
    
    divideInplace in class Image<Float,FImage>
    
    Parameters:
    im - image The image to divide this image by.
    
    Returns:
    A reference to this image containing the result.
    See Also:
    Image.divideInplace(org.openimaj.image.Image)
  - extractROI
```
public FImage extractROI(int x,
                int y,
                FImage out)
```
    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.
    
    Specified by:
    
    extractROI in class Image<Float,FImage>
    
    Parameters:
    x - The leftmost coordinate of the rectangle to extract
    y - The topmost coordinate of the rectangle to extract
    out - The destination image
    
    Returns:
    A reference to the destination image containing the result
    See Also:
    Image.extractROI(int, int, org.openimaj.image.Image)
  - extractROI
```
public FImage 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.
    
    Specified by:
    
    extractROI in class Image<Float,FImage>
    
    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
    See Also:
    Image.extractROI(int, int, int, int)
  - fill
```
public FImage fill(Float colour)
```
    Fill this image with the given colour. Should overwrite all other data stored in this image. Side-affects this image.
    
    Overrides:
    
    fill in class SingleBandImage<Float,FImage>
    
    Parameters:
    colour - the colour to fill the image with
    
    Returns:
    A reference to this image.
    See Also:
    SingleBandImage.fill(java.lang.Comparable)
  - fill
```
public FImage fill(float colour)
```
    Fill an image with the given colour
    
    Parameters:
    colour - the colour
    
    Returns:
    the image
    See Also:
    SingleBandImage.fill(java.lang.Comparable)
  - getContentArea
```
public Rectangle getContentArea()
```
    Get bounding box of non-zero-valued pixels around the outside of the image. Used by Image.trim().
    
    Specified by:
    
    getContentArea in class Image<Float,FImage>
    
    Returns:
    A rectangle of the boundaries of the non-zero-valued image
    See Also:
    Image.getContentArea()
  - getDoublePixelVector
```
public double[] getDoublePixelVector()
```
    Returns the pixels of the image as a vector (array) of doubles.
    
    Returns:
    the pixels of the image as a vector (array) of doubles.
  - getField
```
public FImage 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.
    
    Specified by:
    
    getField in class Image<Float,FImage>
    
    Parameters:
    f - The Image.Field to extract from this image
    
    Returns:
    An image containing only the odd or even fields.
    See Also:
    Image.getField(org.openimaj.image.Image.Field)
  - getFieldCopy
```
public FImage 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.
    
    Specified by:
    
    getFieldCopy in class Image<Float,FImage>
    
    Parameters:
    f - The Image.Field to extract from this image
    
    Returns:
    An image containing the odd or even fields doubled.
    See Also:
    Image.getFieldCopy(org.openimaj.image.Image.Field)
  - getFieldInterpolate
```
public FImage 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.
    
    Specified by:
    
    getFieldInterpolate in class Image<Float,FImage>
    
    Parameters:
    f - The Image.Field to extract from this image.
    
    Returns:
    An image containing the odd or even fields with interpolated rows between.
    See Also:
    Image.getFieldInterpolate(org.openimaj.image.Image.Field)
  - getFloatPixelVector
```
public float[] getFloatPixelVector()
```
    Returns the pixels of the image as a vector (array) of doubles.
    
    Returns:
    the pixels of the image as a vector (array) of doubles.
  - getPixel
```
public Float getPixel(int x,
             int y)
```
    Get the value of the pixel at coordinate (x, y).
    
    Specified by:
    
    getPixel in class Image<Float,FImage>
    
    Parameters:
    x - The x-ordinate to get
    y - The y-ordinate to get
    
    Returns:
    The pixel value at (x, y)
    See Also:
    Image.getPixel(int, int)
  - getPixelComparator
```
public Comparator<? super Float> getPixelComparator()
```
    Returns a pixel comparator that is able to compare equality of pixels in the given image type.
    
    Specified by:
    
    getPixelComparator in class Image<Float,FImage>
    
    Returns:
    A Comparator that compares pixels.
    See Also:
    Image.getPixelComparator()
  - getPixelInterp
```
public Float getPixelInterp(double x,
                   double y)
```
    Get the value of a sub-pixel using linear-interpolation.
    
    Specified by:
    
    getPixelInterp in class Image<Float,FImage>
    
    Parameters:
    x - The x-ordinate to get
    y - The y-ordinate to get
    
    Returns:
    The value of the interpolated point at (x,y)
    See Also:
    Image.getPixelInterp(double, double), Interpolation.bilerp(double, double, double, double, double, double)
  - getPixelInterp
```
public Float getPixelInterp(double x,
                   double y,
                   Float background)
```
    Get the value of a sub-pixel using linear-interpolation. Also specify the colour of the background (for interpolation at the edge)
    
    Specified by:
    
    getPixelInterp in class Image<Float,FImage>
    
    Parameters:
    x - The x-ordinate to get.
    y - The y-ordinate to get.
    background - The colour of the background pixel.
    
    Returns:
    The value of the interpolated point at (x,y)
    See Also:
    Image.getPixelInterp(double, double), Interpolation.bilerp(double, double, double, double, double, double)
  - getPixelInterpNative
```
public float getPixelInterpNative(float x,
                         float y,
                         float background)
```
    Interpolate the value of a pixel at the given coordinates
    
    Parameters:
    x - the x-ordinate
    y - the y-ordinate
    background - the background colour
    
    Returns:
    the interpolated pixel value
    See Also:
    Image.getPixelInterp(double, double), Interpolation.bilerp(double, double, double, double, double, double)
  - internalCopy
```
public FImage internalCopy(FImage 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.
    
    Specified by:
    
    internalCopy in class Image<Float,FImage>
    
    Parameters:
    im - The source image to make a copy of.
    
    Returns:
    A reference to this image.
    See Also:
    Image.internalAssign(org.openimaj.image.Image)
  - internalAssign
```
public FImage internalAssign(FImage im)
```
    Assign the internal state from another image of the same type.
    
    Specified by:
    
    internalAssign in class Image<Float,FImage>
    
    Parameters:
    im - The source image to make a copy of.
    
    Returns:
    A reference to this image.
    See Also:
    Image.internalAssign(org.openimaj.image.Image)
  - internalAssign
```
public FImage internalAssign(int[] data,
                    int width,
                    int height)
```
    Copy pixels from given ARGB buffer image into this image. Side-affects this image.
    
    Specified by:
    
    internalAssign in class Image<Float,FImage>
    
    Parameters:
    data - buffer of ARGB packed integer pixels
    width - the width of the buffer
    height - the height of the buffer
    
    Returns:
    A reference to this image.
    See Also:
    Image.internalAssign(int [] data, int width, int height)
  - inverse
```
public FImage inverse()
```
    Invert the image pixels by finding the maximum value and subtracting each pixel value from that maximum.
    
    Specified by:
    
    inverse in class Image<Float,FImage>
    
    Returns:
    A reference to this image.
    See Also:
    Image.inverse()
  - max
```
public Float max()
```
    Find the maximum pixel value.
    
    Specified by:
    
    max in class Image<Float,FImage>
    
    Returns:
    The maximum pixel value
    See Also:
    Image.max()
  - maxPixel
```
public FValuePixel maxPixel()
```
    Get the pixel with the maximum value. Returns an FValuePixel which contains the location and value of the pixel. If there are multiple pixels with the same value then the first is returned. Note that this method assumes all pixel values are greater than 0.
    
    Returns:
    the maximum pixel as an FValuePixel.
  - min
```
public Float min()
```
    Find the minimum pixel value.
    
    Specified by:
    
    min in class Image<Float,FImage>
    
    Returns:
    The minimum pixel value
    See Also:
    Image.min()
  - minPixel
```
public FValuePixel minPixel()
```
    Get the pixel with the minimum value. Returns an FValuePixel which contains the location and value of the pixel. If there are multiple pixels with the same value then the first is returned. Note that this method assumes all pixel values are greater than 0.
    
    Returns:
    The minimum pixel as an FValuePixel.
  - multiply
```
public FImage multiply(Float num)
```
    Multiply each pixel of this by the given scalar and return new image.
    
    Overrides:
    
    multiply in class Image<Float,FImage>
    
    Parameters:
    num - The scalar which to multiply the image by
    
    Returns:
    A new image containing the result
    See Also:
    Image.multiply(java.lang.Object)
  - multiplyInplace
```
public FImage multiplyInplace(FImage im)
```
    Multiplies this image's pixel values by the corresponding pixel values in the given image side-affecting this image. This is a version of Image.multiplyInplace(Image) which takes an FImage. This directly accesses the underlying float[][] and is therefore fast. This function works inplace.
    
    Parameters:
    im - the FImage to multiply with this image
    
    Returns:
    a reference to this image
    See Also:
    Image.multiplyInplace(Image)
  - multiplyInplace
```
public FImage multiplyInplace(Float num)
```
    Multiply each pixel of this by the given scalar. This method side-affects this image.
    
    Specified by:
    
    multiplyInplace in class Image<Float,FImage>
    
    Parameters:
    num - The scalar to multiply this image by.
    
    Returns:
    A reference to this image.
    See Also:
    Image.multiplyInplace(java.lang.Object)
  - multiplyInplace
```
public FImage multiplyInplace(float fnum)
```
    Multiply all pixel values by the given value
    
    Parameters:
    fnum - the value
    
    Returns:
    this image
    See Also:
    Image.multiplyInplace(java.lang.Object)
  - multiplyInplace
```
public FImage multiplyInplace(Image<?,?> im)
```
    Multiply each pixel in this image by the corresponding pixel in the given image. This method side-affects this image. This method will throw an UnsupportedOperationException if the input input is not an FImage.
    
    Specified by:
    
    multiplyInplace in class Image<Float,FImage>
    
    Parameters:
    im - The image to multiply with this image.
    
    Returns:
    A reference to this image.
    
    Throws:
    
    UnsupportedOperationException - if the given image is not an FImage
    See Also:
    Image.multiplyInplace(org.openimaj.image.Image)
  - newInstance
```
public FImage newInstance(int width,
                 int height)
```
    Create a new instance of this image subclass with given dimensions.
    
    Specified by:
    
    newInstance in class Image<Float,FImage>
    
    Parameters:
    width - The image width
    height - The image height
    
    Returns:
    A new FImage
    See Also:
    Image.newInstance(int, int)
  - normalise
```
public FImage 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.
    
    Specified by:
    
    normalise in class Image<Float,FImage>
    
    Returns:
    A reference to this image.
    See Also:
    Image.normalise()
  - process
```
public FImage process(KernelProcessor<Float,FImage> p)
```
    Process this image with the given KernelProcessor and return new image containing the result.
    
    Overrides:
    
    process in class SingleBandImage<Float,FImage>
    
    Parameters:
    p - The KernelProcessor to apply.
    
    Returns:
    A new image containing the result.
    See Also:
    SingleBandImage.process(org.openimaj.image.processor.KernelProcessor)
  - process
```
public FImage process(KernelProcessor<Float,FImage> p,
             boolean pad)
```
    Process this image with the given KernelProcessor and return new image containing the result. This method has been overridden in FImage for performance.
    
    Overrides:
    
    process in class SingleBandImage<Float,FImage>
    
    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.
    See Also:
    SingleBandImage.process(org.openimaj.image.processor.KernelProcessor, boolean)
  - processInplace
```
public FImage processInplace(PixelProcessor<Float> p)
```
    Process this image with the given PixelProcessor side-affecting this image. This method has been overridden in FImage for performance.
    
    Overrides:
    
    processInplace in class Image<Float,FImage>
    
    Parameters:
    p - The PixelProcessor to apply.
    
    Returns:
    A reference to this image containing the result.
    See Also:
    Image.processInplace(org.openimaj.image.processor.PixelProcessor)
  - analyseWith
```
public void analyseWith(PixelAnalyser<Float> p)
```
    Analyse this image with a PixelAnalyser. This method has been overridden in FImage for performance.
    
    Overrides:
    
    analyseWith in class Image<Float,FImage>
    
    Parameters:
    p - The analyser to analyse with.
    See Also:
    Image.analyseWith(org.openimaj.image.analyser.PixelAnalyser)
  - setPixel
```
public void setPixel(int x,
            int y,
            Float val)
```
    Sets the pixel at (x,y) to the given value. Side-affects this image.
    
    Specified by:
    
    setPixel in class Image<Float,FImage>
    
    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.
    See Also:
    Image.setPixel(int, int, java.lang.Object)
  - subtract
```
public FImage subtract(FImage im)
```
    Subtracts the given FImage from this image returning a new image containing the result.
    
    Parameters:
    im - The image to subtract from this image.
    
    Returns:
    A new image containing the result.
  - subtract
```
public FImage subtract(Float num)
```
    Subtract a scalar from every pixel value in this image and return new image.
    
    Overrides:
    
    subtract in class Image<Float,FImage>
    
    Parameters:
    num - A value to subtract from each pixel.
    
    Returns:
    A new image containing the result.
    See Also:
    Image.subtract(java.lang.Object)
  - subtract
```
public FImage subtract(Image<?,?> input)
```
    Subtract the corresponding pixel value from the given image from the pixel values in this image. Returns a new image. Throws an UnsupportedOperationException if the given image is not an FImage.
    
    Overrides:
    
    subtract in class Image<Float,FImage>
    
    Parameters:
    input - The image to subtract from this image.
    
    Returns:
    A new image containing the result.
    
    Throws:
    
    UnsupportedOperationException - if the given image is not an FImage.
    See Also:
    Image.subtract(org.openimaj.image.Image)
  - subtractInplace
```
public FImage subtractInplace(FImage im)
```
    Subtracts (pixel-by-pixel) the given FImage from this image. Side-affects this image.
    
    Parameters:
    im - The FImage to subtract from this image.
    
    Returns:
    A reference to this image containing the result.
  - subtractInplace
```
public FImage subtractInplace(Float num)
```
    Subtract a scalar from every pixel value in this image. Side-affects this image.
    
    Specified by:
    
    subtractInplace in class Image<Float,FImage>
    
    Parameters:
    num - A value to subtract from each pixel.
    
    Returns:
    A reference to this image containing the result.
    See Also:
    Image.subtractInplace(java.lang.Object)
  - subtractInplace
```
public FImage subtractInplace(Image<?,?> im)
```
    Subtract the corresponding pixel value from the given image from the pixel values in this image. Side-affects this image.
    
    Specified by:
    
    subtractInplace in class Image<Float,FImage>
    
    Parameters:
    im - The image to subtract from this image.
    
    Returns:
    A reference to this containing the result.
    See Also:
    Image.subtractInplace(org.openimaj.image.Image)
  - threshold
```
public FImage threshold(Float thresh)
```
    Set all values less than the given threshold to 0 and all others to 1. Side-affects this image.
    
    Specified by:
    
    threshold in class Image<Float,FImage>
    
    Parameters:
    thresh - The threshold value
    
    Returns:
    A reference to this image containing the result.
    See Also:
    Image.threshold(java.lang.Object)
  - toByteImage
```
public 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.]
    
    Specified by:
    
    toByteImage in class Image<Float,FImage>
    
    Returns:
    This image as a byte array
    See Also:
    Image.toByteImage()
  - toPackedARGBPixels
```
public int[] toPackedARGBPixels()
```
    Returns a 1D array representation of this image with each pixel represented as a packed ARGB integer.
    
    Specified by:
    
    toPackedARGBPixels in class Image<Float,FImage>
    
    Returns:
    An array of ARGB pixels.
    See Also:
    Image.toPackedARGBPixels()
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
    
    See Also:
    Object.toString()
  - toString
```
public String toString(String format)
```
    Returns a string representation of every pixel in this image using the format string (see String.format(String, Object...)) to format each pixel value.
    
    Parameters:
    format - The format string to use for each pixel output
    
    Returns:
    A string representation of the image
    See Also:
    String.format(String, Object...)
  - transform
```
public FImage transform(Jama.Matrix transform)
```
    Apply a transform matrix to the image and returns the result as a new image.
    
    Overrides:
    
    transform in class Image<Float,FImage>
    
    Parameters:
    transform - The transform matrix to apply.
    
    Returns:
    A new image containing the result.
    See Also:
    Image.transform(Jama.Matrix)
  - zero
```
public FImage zero()
```
    Set all pixels in the image to zero. Side-affects this image.
    
    Specified by:
    
    zero in class Image<Float,FImage>
    
    Returns:
    A reference to this image containing the result.
    See Also:
    Image.zero()
  - equals
```
public boolean equals(Object o)
```
    Overrides:
    
    equals in class SingleBandImage<Float,FImage>
  - equalsThresh
```
public boolean equalsThresh(FImage o,
                   float thresh)
```
    Compare this image against another using a threshold on the absolute difference between pixel values in order to determine equality.
    
    Parameters:
    o - the image to compare against
    thresh - the threshold for determining equality
    
    Returns:
    true images are the same size and if all pixel values have a difference less than threshold; false otherwise.
  - getPixelNative
```
public float getPixelNative(Pixel p)
```
    Get the value of the pixel at coordinate p
    
    Parameters:
    p - The coordinate to get
    
    Returns:
    The pixel value at (x, y)
  - getPixelNative
```
public float getPixelNative(int x,
                   int y)
```
    Get the value of the pixel at coordinate (x, y).
    
    Parameters:
    x - The x-coordinate to get
    y - The y-coordinate to get
    
    Returns:
    The pixel value at (x, y)
  - getPixelVectorNative
```
public float[] getPixelVectorNative(float[] 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).
  - setPixelNative
```
public void setPixelNative(int x,
                  int y,
                  float val)
```
    Sets the pixel at (x,y) to the given value. Side-affects this image.
    
    Parameters:
    x - The x-coordinate of the pixel to set
    y - The y-coordinate of the pixel to set
    val - The value to set the pixel to.
  - createArray
```
public static FImage[] createArray(int num,
                   int width,
                   int height)
```
    Convenience method to initialise an array of FImages
    
    Parameters:
    num - array length
    width - width of images
    height - height of images
    
    Returns:
    array of newly initialised images
  - sum
```
public float sum()
```
    Returns:
    The sum of all the pixels in the image
  - toRGB
```
public MBFImage toRGB()
```
    Convert this FImage to an RGB MBFImage.
    
    Returns:
    a new RGB colour image.
  - flipX
```
public FImage flipX()
```
    Description copied from class: Image
    
    Flips the content horizontally. Side-affects this image.
    
    Specified by:
    
    flipX in class Image<Float,FImage>
    
    Returns:
    A reference to this image.
  - flipY
```
public FImage flipY()
```
    Description copied from class: Image
    
    Flips the content vertically. Side-affects this image.
    
    Specified by:
    
    flipY in class Image<Float,FImage>
    
    Returns:
    A reference to this image.
  - overlayInplace
```
public FImage overlayInplace(FImage img,
                    FImage alpha,
                    int x,
                    int y)
```
    Overlay the given image on this image with the given alpha channel at the given location.
    
    Parameters:
    img - The image to overlay
    alpha - The alpha channel to use
    x - The location to draw the image
    y - The location to draw the image
    
    Returns:
    This image with the overlay on it
  - overlayInplace
```
public FImage overlayInplace(FImage image,
                    int x,
                    int y)
```
    Overlays the given image on this image directly. The method returns this image for chaining.
    This method will overlay the given image at the given location with full opacity.
    
    Specified by:
    
    overlayInplace in class Image<Float,FImage>
    
    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
    See Also:
    Image.overlayInplace(org.openimaj.image.Image, int, int)
  - randomImage
```
public static FImage randomImage(int width,
                 int height)
```
    Create a random image of the given size.
    
    Parameters:
    width - the width
    height - the height
    
    Returns:
    the image
  - replace
```
public FImage replace(Float target,
             Float replacement)
```
    Description copied from class: Image
    
    Replace pixels of a certain colour with another colour. Side-affects this image.
    
    Specified by:
    
    replace in class Image<Float,FImage>
    
    Parameters:
    target - the colour to fill the image with
    replacement - the colour to fill the image with
    
    Returns:
    A reference to this image.
  - replace
```
public FImage replace(float target,
             float 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 FImage extractCentreSubPix(float cx,
                         float cy,
                         FImage out)
```
    Description copied from class: Image
    
    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.
    
    Specified by:
    
    extractCentreSubPix in class Image<Float,FImage>
    
    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:
    Image.getPixelInterp(double, double)

Class FImage

Nested Class Summary

Nested classes/interfaces inherited from class org.openimaj.image.Image

Field Summary

Fields inherited from class org.openimaj.image.SingleBandImage

Constructor Summary

Method Summary

Methods inherited from class org.openimaj.image.SingleBandImage

Methods inherited from class org.openimaj.image.Image

Methods inherited from class java.lang.Object

Field Detail

logger

DEFAULT_GAUSS_TRUNCATE

pixels

Constructor Detail

FImage

FImage

FImage

FImage

FImage

Method Detail

abs

add

add

add

addInplace

addInplace

addInplace

clip

clipMax

clipMin

clone

createRenderer

createRenderer

divide

divideInplace

divideInplace

divideInplace

divideInplace

extractROI

extractROI

fill

fill

getContentArea

getDoublePixelVector

getField

getFieldCopy

getFieldInterpolate

getFloatPixelVector

getPixel

getPixelComparator

getPixelInterp

getPixelInterp

getPixelInterpNative

internalCopy

internalAssign

internalAssign

inverse

max

maxPixel

min

minPixel

multiply

multiplyInplace

multiplyInplace

multiplyInplace

multiplyInplace

newInstance

normalise

process

process

processInplace

analyseWith

setPixel

subtract

subtract

subtract

subtractInplace

subtractInplace

subtractInplace