Image (GRIP)

All Known Subinterfaces:

Accumulator

All Known Implementing Classes:

Accumulator32, Accumulator64, HdrImage, Image16, Image32, Image64, Image8, Image8or16Base
```
public interface Image
```
For holding images in a format that is not provided by java.awt.image.BufferedImage (eg, deeper than 16 bits per channel, or floating-point pixel values).
NB: The layout of the data is very important: bear in mind that every sub-array has an overhead of 12 bytes.

Method Summary

All Methods Instance Methods Abstract Methods
Modifier and Type	Method and Description
`void`	`add(java.awt.image.BufferedImage bim)` Add pixel values from bim into the data array.
`void`	`add(Image other)` Add pixel values from the other Image into the current data array.
`int[]`	`addPixel(int x, int y, int[] px)` More efficient than the sequence getPixel, add for each band, setPixel.
`void`	`addProportion(Image other, double fractionThis, double fractionOther)` Add proportion of pixel values from the other Image to a proportion of the current data array.
`void`	`addTranslated(java.awt.image.BufferedImage bim, double dx, double dy)` Add pixel values from bim into the data array, offset by vector (dx, dy).
`void`	`addTranslated(java.awt.image.BufferedImage bim, int dx, int dy)` Add pixel values from bim into the data array, offset by vector (dx, dy).
`void`	`applyCurve(java.util.List<java.awt.Point> points)` Apply a tone curve to all channels.
`void`	`autoCrop()` Automatically remove any rectangular margin of black (0, 0, 0) pixels from the image, thereby cropping it.
`void`	`autoStretch(boolean allChannelsSame)` Stretch the contrast in the image so the full range of levels is used.
`void`	`autoStretch(boolean allChannelsSame, java.awt.Point topLeft, java.awt.Point bottomRight)` Stretch the contrast in the image so the full range of levels is used.
`ByteMask`	`autoThreshold()` Threshold automatically.
`void`	`averageVertically()` Replace every pixel of every vertical line in the image by the average of the levels along the line.
`void`	`averageVertically(int yMin, int yMax)` Replace every pixel of every vertical line in the image by the average of the levels along the line, within two y coordinate limits.
`void`	`blurGaussian(int nx, int ny, javax.swing.ProgressMonitor monitor)` Do Gaussian blurring of the given image with 1D profiles of width nx (horizontal) and ny (vertical).
`Image`	`clone()`
`Image`	`convertToImage16()`
`Image`	`convertToImage32()`
`Image`	`convertToImage64()`
`Image`	`convertToImage8()`
`void`	`convertToMonochrome()` Reduce the number of bands from 3 to 1, converting RGB to monochrome, using 0.325 x red + 0.5 * green + 0.175 * blue.
`void`	`convertToMonochrome(double... f)` Reduce the number of bands to 1, combining channels, using sum_i (f[i]/I x px[i]), where I = sum_i (f[i]).
`void`	`convolve(double[] horz, double[] vert, javax.swing.ProgressMonitor monitor)` Convolve the given image with the given 1D arrays (horizontal and vertical - may be different).
`void`	`convolve(Kernel kernel, javax.swing.ProgressMonitor monitor)` Perform a 2D linear convolution with the given kernel.
`void`	`correctBackground(double scale, int cellFactor)` Level the background of the image by dividing the image into n x n cells and using the modal values of the histogram in every cell.
`void`	`crop(java.awt.Point pt1, java.awt.Point pt2)` Crop the Image by a rectangle defined by the diagonally opposite points.
`void`	`deconvolve(Kernel kernel, int nPasses, double weight, javax.swing.ProgressMonitor monitor)` Deconvolve this image with the given kernel, using van Cittert's method.
`void`	`dispose()` Release all resources.
`void`	`divide(int n)` Divide all pixel values (in all bands) in the Image by n.
`void`	`divideByFlatField(Image flat)` Divide by a flat field image.
`void`	`drawRim(int width, java.awt.Color colour)` Draw a rim around the image, of the given width and colour
`void`	`fit(int width, int height)` Scale the image so it fits into the given width and height (in pixels), without changing its proportions.
`void`	`flipHorizontal()` Flip the image horizontally.
`void`	`flipVertical()` Flip the image vertically.
`int`	`getBitsPerChannel()` Get the number of bits per channel.
`int`	`getBytesPerChannel()` Get the number of bytes per channel.
`Calibration`	`getCalibration()` Get a reference to the Calibration object for this image.
`RangeInt[]`	`getChannelRanges()` Find the range of values in each channel, as pairs of int values.
`RangeDouble[]`	`getChannelRangesDouble()` Find the range of values in each channel, as pairs of double values.
`double`	`getEv()` Exposure value, 0 if not set and this is the case when an image is first constructed: it is necessary to call setEv () to set the field.
`java.lang.String`	`getFilePath()` Get the path of the file from which this image was loaded or to which it was last saved.
`int`	`getHeight()` Get the height, in pixels, of the Image.
`java.lang.String`	`getImageTypeAsString()` For displaying image information.
`int`	`getMaxLevel()` Get highest level that can occur in each channel.
`Metadata`	`getMetadata()` Get metadata associated with the image.
`int`	`getNBands()` Get the number of bands (channels) in the Image.
`int[]`	`getPixel(int x, int y)` Get array of int pixel values for all bands at the given integer (x, y) position.
`double[]`	`getPixelDouble(int x, int y)` Get array of double pixel values for all bands at the given integer (x, y) position.
`double[]`	`getPixelDoubleInterpolated(double x, double y)` Get array of double pixel values for all bands at the given fractional (x, y) position.
`int[]`	`getPixelInterpolated(double x, double y)` Get array of int pixel values for all bands at the given fractional (x, y) position.
`RangeInt`	`getRange()` Get the minimum and maximum values occurring across all channels, as a pair of int values.
`RangeInt`	`getRangeByRescanning()` Get overall range of values across all channels, as a pair of int values.
`RangeDouble`	`getRangeByRescanningDouble()` Get overall range of values across all channels, as a pair of double values.
`RangeDouble`	`getRangeDouble()` Get the minimum and maximum values occurring across all channels, as a pair of double values.
`int`	`getWidth()` Get the width, in pixels, of the Image.
`Image`	`gnomonicProjection(int focalLength_mm, double detectorWidth_mm, double detectorHeight_mm)` Project from sphere to plane.
`Image`	`inverseGnomonicProjection(int focalLength_mm, double detectorWidth_mm, double detectorHeight_mm)` Project from plane to sphere.
`void`	`invert()` Invert the colour at every pixel in the image.
`boolean`	`isRaw()` Whether the image data are still in RAW format, as from a DSLR camera.
`void`	`keepOnlyDifferingPixels(Image other, int threshold)` Keep only pixels in this image which differ by more than the threshold amount (in at least one band) from pixels at the same position in the other image.
`void`	`meanFilter(int halfWidth, javax.swing.ProgressMonitor monitor)` Replace every pixel in the image by the mean value of its n x n neighbourhood, where n = 2.halfWidth + 1.
`void`	`medianFilter(int halfWidth, javax.swing.ProgressMonitor monitor)` Replace every pixel in the image by the median value of its n x n neighbourhood, where n = 2.halfWidth + 1.
`void`	`multiply(double f)` Multiply all pixel values (in all bands) in the Image by factor f, truncating the result if pixels contain integer values.
`void`	`multiply(Image other)` Multiply pixel values of current image by those of another.
`void`	`multiply(Image other, double f1, double f2)` Multiply fraction f1 of this image by f2 of the other.
`void`	`nearestExtremeFilter(int halfWidth, javax.swing.ProgressMonitor monitor)` Replace every pixel in the image by the nearest of the max and min of its n x n neighbourhood, where n = 2.halfWidth + 1.
`void`	`neutraliseBackground()` Equate the histogram modes of all channels by stretching from the overall maximum value.
`Image`	`plotResponseCurve(java.util.List<Image> images)` Uses the images to compute the camera response curve and display it as a graph, as described in "On Being ‘Undigital’ With Digital Cameras: Extending Dynamic Range By Combining Differently Exposed Pictures" by S.
`void`	`rankFilter(int halfWidth, javax.swing.ProgressMonitor monitor)` Replace every pixel in the image by its rank in its n x n neighbourhood, where n = 2.halfWidth + 1.
`void`	`reapplyColour(Image intensityImage, Image colourImage)` For combining a monochrome intensity image with a multi-band colour information image, the 2 images having been created by splitIntensity ().
`void`	`replaceBrighterPixels(Image source)` Assuming the source image has the same dimensions, replace in the present image any pixels which are brighter in the source (in all channels).
`void`	`rotate(Angle angle)` Rotate the image anticlockwise by the given angle about its centre.
`void`	`rotate(double angleDegs)` Rotate the image anticlockwise by the given angle (in degrees) about its centre.
`Image`	`rotate180()` Rotate the image by exactly 180 degrees - faster than the more general method because it requires no pixel interpolation.
`Image`	`rotate270()` Rotate the image by exactly 90 degrees clockwise - faster than the more general method because it requires no pixel interpolation.
`Image`	`rotate90()` Rotate the image by exactly 90 degrees anticlockwise - faster than the more general method because it requires no pixel interpolation.
`void`	`saturate(int amount)` Apply a given amount of saturation (arbitrary scale, -100 ..
`void`	`save(java.lang.String filePath)` Save on disc: slower version, has to work out the range of values occurring in the Image.
`void`	`save(java.lang.String filePath, RangeDouble range)` Save on disc: faster version if the range of values occurring in the Image is already known.
`void`	`save(java.lang.String filePath, RangeInt range)` Save on disc: faster version if the range of values occurring in the Image is already known.
`void`	`saveAsFITS(java.lang.String filePath)`
`void`	`scale(double factor, boolean interpolating)` Scale the image in x and y by the given factor
`void`	`scale(double factor, boolean interpolating, java.awt.Point centre)` Scale the image in x and y by the given factor, keeping the centre fixed.
`java.awt.image.BufferedImage`	`scaleDownForDisplay(int factor)` Create a BufferedImage compatible with the display and scale the current Image down into it by an integer factor (maximum speed).
`void`	`set(java.awt.image.BufferedImage bim)` Set pixel values from bim into the data array.
`void`	`setCalibration(Calibration calib)` Associate a Calibration object with this image.
`boolean`	`setEv()` Try to set exposure value (private field _Ev) from metadata, as 1/f-number-squared x exposure (s) x ISO.
`void`	`setFilePath(java.lang.String filePath)` Record the path to the file in which the image was last saved.
`void`	`setMetadata(Metadata theData)` Associate metadata with the image.
`void`	`setPixel(int x, int y, int[] px)` Does nothing if (x, y) is outside the image.
`void`	`setPixel(int x, int y, int band, int px)` Set value into a single band of a pixel without changing the other bands.
`void`	`setPixelDouble(int x, int y, double[] px)` Does nothing if (x, y) is outside the image.
`void`	`setPixelDouble(int x, int y, int band, double px)` Set value into a single band of a pixel without changing the other bands.
`void`	`showInfo()` Display information about the current image in a dialogue.
`Image[]`	`splitChannels()` Convert image to an array of monochrome images.
`Image[]`	`splitIntensity()` Create a monochrome image in which each pixel has the value I = sum of the band levels of the current image plus a colour image in which the pixel in each band has the value maxLevel * bandLevel / I.
`void`	`subtract(Image image)` Subtract pixel values of other image from this image data array, raising result by minimum possible so it is always positive.
`void`	`subtractToZero(Image image)` Subtract pixel values of other image from this image data array, clipping negative results to zero.
`void`	`swapQuadrants()` Rearrange the 4 quadrants of the image - useful for viewing Fourier Transform results.
`ByteMask`	`threshold(Threshold thresh)` Threshold the image to detect pixels in the range(s) specified by the given threshold.
`java.lang.String`	`toFoldedString(java.lang.String lineEnd)` Return complete metadata in a form suitable for display.
`java.lang.String`	`toString()`
`void`	`translate(double dx, double dy)` Displace the image content by the given offset vector, interpolating between pixels.
`void`	`translate(int dx, int dy)` Displace the image content by the given offset vector, a whole number of pixels.
`void`	`varianceFilter(int halfWidth, javax.swing.ProgressMonitor monitor)` Replace every pixel in the image by the variance of its n x n neighbourhood, where n = 2.halfWidth + 1.

- Method Detail
  - add
```
void add(Image other)
  throws IncompatibleImageException
```
    Add pixel values from the other Image into the current data array. If other is larger than the data then the rectangle starting at the top left corner of other which overlaps the data will be used.
    
    Throws:
    
    IncompatibleImageException
  - add
```
void add(java.awt.image.BufferedImage bim)
  throws IncompatibleImageException
```
    Add pixel values from bim into the data array. If bim is larger than the data then the rectangle starting at the top left corner of bim which overlaps the data will be used.
    
    Throws:
    
    IncompatibleImageException
  - addPixel
```
int[] addPixel(int x,
               int y,
               int[] px)
```
    More efficient than the sequence getPixel, add for each band, setPixel. Returns the new pixel value. Does nothing if x or y are outside this image and returns null in that case.
  - addProportion
```
void addProportion(Image other,
                   double fractionThis,
                   double fractionOther)
            throws IncompatibleImageException
```
    Add proportion of pixel values from the other Image to a proportion of the current data array. If other is larger than the data then the rectangle starting at the top left corner of other which overlaps the data will be used.
    
    Throws:
    
    IncompatibleImageException
  - addTranslated
```
void addTranslated(java.awt.image.BufferedImage bim,
                   int dx,
                   int dy)
            throws IncompatibleImageException
```
    Add pixel values from bim into the data array, offset by vector (dx, dy). Only those pixels of the offset bim which overlap the data are used. Using integer coordinates, this version is fast but does not interpolate from the source image.
    
    Throws:
    
    IncompatibleImageException
  - addTranslated
```
void addTranslated(java.awt.image.BufferedImage bim,
                   double dx,
                   double dy)
            throws IncompatibleImageException
```
    Add pixel values from bim into the data array, offset by vector (dx, dy). Only those pixels of the offset bim which overlap the data are used. Using double coordinates, this version is slower but does interpolate from the source image.
    
    Throws:
    
    IncompatibleImageException
  - applyCurve
```
void applyCurve(java.util.List<java.awt.Point> points)
```
    Apply a tone curve to all channels. The "curve" is a sequence of straight lines between points (x, y) in a list. The range of x and y is 0..255 representing a span across the actual range of this image. The range of the image is unaffected but in general the contrast will be.
  - autoCrop
```
void autoCrop()
```
    Automatically remove any rectangular margin of black (0, 0, 0) pixels from the image, thereby cropping it. Potentially replaces the data array inside this Image by a new smaller one.
  - autoStretch
```
void autoStretch(boolean allChannelsSame)
```
    Stretch the contrast in the image so the full range of levels is used.
  - autoStretch
```
void autoStretch(boolean allChannelsSame,
                 java.awt.Point topLeft,
                 java.awt.Point bottomRight)
```
    Stretch the contrast in the image so the full range of levels is used. This version only changes pixels in the rectangle defined by the two points as diagonal. The upper level of the data will not change but if the lower level was not zero a linear rescaling will make it so.
  - autoThreshold
```
ByteMask autoThreshold()
```
    Threshold automatically. First gets a histogram and finds the channel means. Sets the threshold for each channel: if the mean is lower than half-way up the brightness range the background is assumed to be dark so the threshold goes from half-way up to the top. Otherwise the background is assumed to be bright so the threshold goes from 0 to half-way. Then does the thresholding to set a mask in the GlassPane, suitable for blob detection.
    Not for segmenting stars: use StarSegmenter class instead.
  - averageVertically
```
void averageVertically()
```
    Replace every pixel of every vertical line in the image by the average of the levels along the line. This is for analysing profiles (particularly for spectroscopy). Rotate and crop the image appropriately before using this.
  - averageVertically
```
void averageVertically(int yMin,
                       int yMax)
```
    Replace every pixel of every vertical line in the image by the average of the levels along the line, within two y coordinate limits. This is for analysing profiles (particularly for spectroscopy). Rotate and crop the image appropriately before using this.
  - blurGaussian
```
void blurGaussian(int nx,
                  int ny,
                  javax.swing.ProgressMonitor monitor)
```
    Do Gaussian blurring of the given image with 1D profiles of width nx (horizontal) and ny (vertical).
  - clone
```
Image clone()
```
  - convertToImage8
```
Image convertToImage8()
```
  - convertToImage16
```
Image convertToImage16()
```
  - convertToImage32
```
Image convertToImage32()
```
  - convertToImage64
```
Image convertToImage64()
```
  - convertToMonochrome
```
void convertToMonochrome()
```
    Reduce the number of bands from 3 to 1, converting RGB to monochrome, using 0.325 x red + 0.5 * green + 0.175 * blue. Replaces the data array inside this Image by a new smaller one.
  - convertToMonochrome
```
void convertToMonochrome(double... f)
```
    Reduce the number of bands to 1, combining channels, using sum_i (f[i]/I x px[i]), where I = sum_i (f[i]). Replaces the data array inside this Image by a new smaller one.
  - convolve
```
void convolve(Kernel kernel,
              javax.swing.ProgressMonitor monitor)
```
    Perform a 2D linear convolution with the given kernel. The monitor may be null.
  - convolve
```
void convolve(double[] horz,
              double[] vert,
              javax.swing.ProgressMonitor monitor)
```
    Convolve the given image with the given 1D arrays (horizontal and vertical - may be different). All channels are convolved the same. If either array is null the convolution in that direction is skipped. This method is intended as a quicker way of doing certain useful convolutions, such as Gaussian blurring. The monitor may be null.
  - correctBackground
```
void correctBackground(double scale,
                       int cellFactor)
```
    Level the background of the image by dividing the image into n x n cells and using the modal values of the histogram in every cell.
  - crop
```
void crop(java.awt.Point pt1,
          java.awt.Point pt2)
```
    Crop the Image by a rectangle defined by the diagonally opposite points. Does not assume pt1 is above or to the left of pt2. Replaces the data array inside this Image by a new smaller one.
  - deconvolve
```
void deconvolve(Kernel kernel,
                int nPasses,
                double weight,
                javax.swing.ProgressMonitor monitor)
```
    Deconvolve this image with the given kernel, using van Cittert's method. The monitor may be null.
  - dispose
```
void dispose()
```
    Release all resources.
  - divide
```
void divide(int n)
```
    Divide all pixel values (in all bands) in the Image by n.
  - divideByFlatField
```
void divideByFlatField(Image flat)
```
    Divide by a flat field image.
  - drawRim
```
void drawRim(int width,
             java.awt.Color colour)
```
    Draw a rim around the image, of the given width and colour
  - fit
```
void fit(int width,
         int height)
```
    Scale the image so it fits into the given width and height (in pixels), without changing its proportions. Replaces the data array inside this Image by a new smaller one.
  - flipHorizontal
```
void flipHorizontal()
```
    Flip the image horizontally.
  - flipVertical
```
void flipVertical()
```
    Flip the image vertically.
  - getCalibration
```
Calibration getCalibration()
```
    Get a reference to the Calibration object for this image.
  - getBitsPerChannel
```
int getBitsPerChannel()
```
    Get the number of bits per channel.
  - getBytesPerChannel
```
int getBytesPerChannel()
```
    Get the number of bytes per channel.
  - getChannelRanges
```
RangeInt[] getChannelRanges()
```
    Find the range of values in each channel, as pairs of int values.
  - getChannelRangesDouble
```
RangeDouble[] getChannelRangesDouble()
```
    Find the range of values in each channel, as pairs of double values.
  - getEv
```
double getEv()
```
    Exposure value, 0 if not set and this is the case when an image is first constructed: it is necessary to call setEv () to set the field.
  - getFilePath
```
java.lang.String getFilePath()
```
    Get the path of the file from which this image was loaded or to which it was last saved.
  - getHeight
```
int getHeight()
```
    Get the height, in pixels, of the Image.
  - getImageTypeAsString
```
java.lang.String getImageTypeAsString()
```
    For displaying image information.
  - getMaxLevel
```
int getMaxLevel()
```
    Get highest level that can occur in each channel.
  - getMetadata
```
Metadata getMetadata()
```
    Get metadata associated with the image. Null if none.
  - getNBands
```
int getNBands()
```
    Get the number of bands (channels) in the Image.
  - getPixel
```
int[] getPixel(int x,
               int y)
```
    Get array of int pixel values for all bands at the given integer (x, y) position. Returns all zeroes if the position is outside the data array.
  - getPixelDouble
```
double[] getPixelDouble(int x,
                        int y)
```
    Get array of double pixel values for all bands at the given integer (x, y) position. Returns all zeroes if the position is outside the data array.
  - getPixelDoubleInterpolated
```
double[] getPixelDoubleInterpolated(double x,
                                    double y)
```
    Get array of double pixel values for all bands at the given fractional (x, y) position. Returns all zeroes if the position is outside the data array.
  - getPixelInterpolated
```
int[] getPixelInterpolated(double x,
                           double y)
```
    Get array of int pixel values for all bands at the given fractional (x, y) position. Returns all zeroes if the position is outside the data array.
  - getRange
```
RangeInt getRange()
```
    Get the minimum and maximum values occurring across all channels, as a pair of int values. Fast version, which does not scan the image.
  - getRangeDouble
```
RangeDouble getRangeDouble()
```
    Get the minimum and maximum values occurring across all channels, as a pair of double values. Fast version, which does not scan the image.
  - getRangeByRescanning
```
RangeInt getRangeByRescanning()
```
    Get overall range of values across all channels, as a pair of int values.
  - getRangeByRescanningDouble
```
RangeDouble getRangeByRescanningDouble()
```
    Get overall range of values across all channels, as a pair of double values.
  - getWidth
```
int getWidth()
```
    Get the width, in pixels, of the Image.
  - gnomonicProjection
```
Image gnomonicProjection(int focalLength_mm,
                         double detectorWidth_mm,
                         double detectorHeight_mm)
```
    Project from sphere to plane.
  - inverseGnomonicProjection
```
Image inverseGnomonicProjection(int focalLength_mm,
                                double detectorWidth_mm,
                                double detectorHeight_mm)
```
    Project from plane to sphere.
  - invert
```
void invert()
```
    Invert the colour at every pixel in the image.
  - isRaw
```
boolean isRaw()
```
    Whether the image data are still in RAW format, as from a DSLR camera. Only an Image16 is likely to return true for this.
  - keepOnlyDifferingPixels
```
void keepOnlyDifferingPixels(Image other,
                             int threshold)
```
    Keep only pixels in this image which differ by more than the threshold amount (in at least one band) from pixels at the same position in the other image. Set all other pixels in this image to zero. Both images must have the same size, number of bands and bit depth.
  - meanFilter
```
void meanFilter(int halfWidth,
                javax.swing.ProgressMonitor monitor)
```
    Replace every pixel in the image by the mean value of its n x n neighbourhood, where n = 2.halfWidth + 1.
  - medianFilter
```
void medianFilter(int halfWidth,
                  javax.swing.ProgressMonitor monitor)
```
    Replace every pixel in the image by the median value of its n x n neighbourhood, where n = 2.halfWidth + 1.
  - multiply
```
void multiply(double f)
```
    Multiply all pixel values (in all bands) in the Image by factor f, truncating the result if pixels contain integer values. May well saturate but will not overflow to negative values.
  - multiply
```
void multiply(Image other)
```
    Multiply pixel values of current image by those of another. May well saturate but will not overflow to negative values.
  - multiply
```
void multiply(Image other,
              double f1,
              double f2)
```
    Multiply fraction f1 of this image by f2 of the other.
  - nearestExtremeFilter
```
void nearestExtremeFilter(int halfWidth,
                          javax.swing.ProgressMonitor monitor)
```
    Replace every pixel in the image by the nearest of the max and min of its n x n neighbourhood, where n = 2.halfWidth + 1.
  - neutraliseBackground
```
void neutraliseBackground()
```
    Equate the histogram modes of all channels by stretching from the overall maximum value.
  - plotResponseCurve
```
Image plotResponseCurve(java.util.List<Image> images)
```
    Uses the images to compute the camera response curve and display it as a graph, as described in "On Being ‘Undigital’ With Digital Cameras: Extending Dynamic Range By Combining Differently Exposed Pictures" by S. Mann and R. W. Picard, MIT Media Lab Perceptual Computing Section, 1994. Available as PDF at http://wearcam.org/is_t95_myversion.pdf The list must contain at least 2 images. They must all have the same pixel size and bit depth and be of exactly the same scene but photographed with different exposure levels. It is up to the caller to check that the image sizes match. This is a step towards making HDR images, as described in the paper. NB: The current image (this) is also present as the 0 element of the list.
  - rankFilter
```
void rankFilter(int halfWidth,
                javax.swing.ProgressMonitor monitor)
```
    Replace every pixel in the image by its rank in its n x n neighbourhood, where n = 2.halfWidth + 1. The rank is scaled up so that its possible values span the grey level range of the image. Each channel is treated independently.
  - reapplyColour
```
void reapplyColour(Image intensityImage,
                   Image colourImage)
```
    For combining a monochrome intensity image with a multi-band colour information image, the 2 images having been created by splitIntensity (). The result fills the current Image, overwriting any previous contents.
  - replaceBrighterPixels
```
void replaceBrighterPixels(Image source)
```
    Assuming the source image has the same dimensions, replace in the present image any pixels which are brighter in the source (in all channels). This can be useful for stacking star trail images. The source is not changed.
  - rotate
```
void rotate(double angleDegs)
```
    Rotate the image anticlockwise by the given angle (in degrees) about its centre. NB: image size increases so that the corners are not croppped off, the new corners being filled with black.
  - rotate
```
void rotate(Angle angle)
```
    Rotate the image anticlockwise by the given angle about its centre. NB: image size increases so that the corners are not croppped off, the new corners being filled with black.
  - rotate180
```
Image rotate180()
```
    Rotate the image by exactly 180 degrees - faster than the more general method because it requires no pixel interpolation. Returns a new image.
  - rotate270
```
Image rotate270()
```
    Rotate the image by exactly 90 degrees clockwise - faster than the more general method because it requires no pixel interpolation. Returns a new image.
  - rotate90
```
Image rotate90()
```
    Rotate the image by exactly 90 degrees anticlockwise - faster than the more general method because it requires no pixel interpolation. Returns a new image.
  - saturate
```
void saturate(int amount)
```
    Apply a given amount of saturation (arbitrary scale, -100 .. +100).
  - save
```
void save(java.lang.String filePath)
```
    Save on disc: slower version, has to work out the range of values occurring in the Image.
  - save
```
void save(java.lang.String filePath,
          RangeInt range)
```
    Save on disc: faster version if the range of values occurring in the Image is already known.
  - save
```
void save(java.lang.String filePath,
          RangeDouble range)
```
    Save on disc: faster version if the range of values occurring in the Image is already known.
  - saveAsFITS
```
void saveAsFITS(java.lang.String filePath)
```
  - scale
```
void scale(double factor,
           boolean interpolating)
```
    Scale the image in x and y by the given factor
  - scale
```
void scale(double factor,
           boolean interpolating,
           java.awt.Point centre)
```
    Scale the image in x and y by the given factor, keeping the centre fixed.
  - scaleDownForDisplay
```
java.awt.image.BufferedImage scaleDownForDisplay(int factor)
```
    Create a BufferedImage compatible with the display and scale the current Image down into it by an integer factor (maximum speed).
  - set
```
void set(java.awt.image.BufferedImage bim)
  throws IncompatibleImageException
```
    Set pixel values from bim into the data array. If bim is larger than the data then the rectangle starting at the top left corner of bim which overlaps the data will be used.
    
    Throws:
    
    IncompatibleImageException
  - setCalibration
```
void setCalibration(Calibration calib)
```
    Associate a Calibration object with this image.
  - setEv
```
boolean setEv()
```
    Try to set exposure value (private field _Ev) from metadata, as 1/f-number-squared x exposure (s) x ISO. Does nothing if the 3 metadata values cannot be read. Returns boolean showing whether the metadata were used successfully.
  - setFilePath
```
void setFilePath(java.lang.String filePath)
```
    Record the path to the file in which the image was last saved.
  - setMetadata
```
void setMetadata(Metadata theData)
```
    Associate metadata with the image.
  - setPixel
```
void setPixel(int x,
              int y,
              int[] px)
```
    Does nothing if (x, y) is outside the image.
  - setPixel
```
void setPixel(int x,
              int y,
              int band,
              int px)
```
    Set value into a single band of a pixel without changing the other bands. Does nothing if (x, y) is outside the image.
  - setPixelDouble
```
void setPixelDouble(int x,
                    int y,
                    double[] px)
```
    Does nothing if (x, y) is outside the image.
  - setPixelDouble
```
void setPixelDouble(int x,
                    int y,
                    int band,
                    double px)
```
    Set value into a single band of a pixel without changing the other bands. Does nothing if (x, y) is outside the image.
  - showInfo
```
void showInfo()
```
    Display information about the current image in a dialogue.
  - splitChannels
```
Image[] splitChannels()
```
    Convert image to an array of monochrome images.
  - splitIntensity
```
Image[] splitIntensity()
```
    Create a monochrome image in which each pixel has the value I = sum of the band levels of the current image plus a colour image in which the pixel in each band has the value maxLevel * bandLevel / I. A 2-element array of the 2 images is returned (intensity in element 0), or null if the images could not both be created. This operation, along with reapplyColour(), implements the colour preservation scheme described at http://www.allthesky.com/articles/colorpreserve.html
  - subtract
```
void subtract(Image image)
       throws IncompatibleImageException
```
    Subtract pixel values of other image from this image data array, raising result by minimum possible so it is always positive. If other is larger than this image then the rectangle starting at the top left corner of other which overlaps this image will be used.
    
    Throws:
    
    IncompatibleImageException
  - subtractToZero
```
void subtractToZero(Image image)
             throws IncompatibleImageException
```
    Subtract pixel values of other image from this image data array, clipping negative results to zero. If other is larger than this image then the rectangle starting at the top left corner of other which overlaps this image will be used.
    
    Throws:
    
    IncompatibleImageException
  - swapQuadrants
```
void swapQuadrants()
```
    Rearrange the 4 quadrants of the image - useful for viewing Fourier Transform results.
  - threshold
```
ByteMask threshold(Threshold thresh)
```
    Threshold the image to detect pixels in the range(s) specified by the given threshold. Return a binary mask (values BlobMask.MASK_CLEAR or BlobMask.MASK_SET), suitable for setting into GlassPane. The image may have any number of bands.
  - translate
```
void translate(int dx,
               int dy)
```
    Displace the image content by the given offset vector, a whole number of pixels. Image size is unchanged. Margins exposed by the shift are filled with zeroes. Portions of the image shifted off the edge are lost. Shifting an image by a very small amount and then subtracting it from itself (eg, as previously cloned) is a way of detecting edges in the direction of the offset.
  - translate
```
void translate(double dx,
               double dy)
```
    Displace the image content by the given offset vector, interpolating between pixels. Image size is unchanged. Margins exposed by the shift are filled with zeroes. Portions of the image shifted off the edge are lost. Shifting an image by a very small amount and then subtracting it from itself (eg, as previously cloned) is a way of detecting edges in the direction of the offset.
  - toString
```
java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object
  - toFoldedString
```
java.lang.String toFoldedString(java.lang.String lineEnd)
```
    Return complete metadata in a form suitable for display. The lineEnd might be "\n" or "<br/>", depending on the intended output medium.
  - varianceFilter
```
void varianceFilter(int halfWidth,
                    javax.swing.ProgressMonitor monitor)
```
    Replace every pixel in the image by the variance of its n x n neighbourhood, where n = 2.halfWidth + 1.

Interface Image

Method Summary

Method Detail

add

add

addPixel

addProportion

addTranslated

addTranslated

applyCurve

autoCrop

autoStretch

autoStretch

autoThreshold

averageVertically

averageVertically

blurGaussian

clone

convertToImage8

convertToImage16

convertToImage32

convertToImage64

convertToMonochrome

convertToMonochrome

convolve

convolve

correctBackground

crop

deconvolve

dispose

divide

divideByFlatField

drawRim

fit

flipHorizontal

flipVertical

getCalibration

getBitsPerChannel

getBytesPerChannel

getChannelRanges

getChannelRangesDouble

getEv

getFilePath

getHeight

getImageTypeAsString

getMaxLevel

getMetadata

getNBands

getPixel

getPixelDouble

getPixelDoubleInterpolated

getPixelInterpolated

getRange

getRangeDouble

getRangeByRescanning

getRangeByRescanningDouble

getWidth

gnomonicProjection

inverseGnomonicProjection

invert

isRaw

keepOnlyDifferingPixels

meanFilter

medianFilter

multiply

multiply

multiply

nearestExtremeFilter

neutraliseBackground

plotResponseCurve

rankFilter

reapplyColour

replaceBrighterPixels

rotate

rotate

rotate180

rotate270

rotate90

saturate

save