Image64 (GRIP)

java.lang.Object
- net.grelf.image.ImageBase
- - net.grelf.image.Image64

All Implemented Interfaces:

java.lang.Cloneable, java.lang.Comparable<ImageBase>, Image

Direct Known Subclasses:

Accumulator64
```
public class Image64
extends ImageBase
implements Image, java.lang.Cloneable
```
This is used as an alternative to BufferedImage for holding 64-bits-per-channel (double floating point) images, any number of channels. It needs a lot of memory of course: width x height x (12 + 8n) bytes for n-channel images.
Its behaviour differs from BufferedImages in that the maximum level available is not automatically increased to 2 to the power 32. A 16-bit BufferedImage would always be considered to have a maximum level of 65535 but the maximum level of an Image64 is the maximum level actually reached in the data (across all channels). The range of values held must be updated by every operation that modifies the data, so it is then available as getRangeDouble () without rescanning the image. A rescan can always be done, by getRangeDoubleByRescanning () or getChannelRangesDouble (), but that can be time consuming.

The data can be saved on disc and reloaded in FITS format.

Field Summary

Fields
Modifier and Type Field and Description

protected double[][] data
- Fields inherited from class net.grelf.image.ImageBase
  metadata

Fields
Modifier and Type	Field and Description
`protected double[][]`	`data`

Constructor Summary

Constructors
Constructor and Description
`Image64(java.awt.image.BufferedImage bim)` Use the BufferedImage to set the width, height and number of bands (channels) in this Image.
`Image64(int width, int height, int nBands)` Creates image without setting any pixels.
`Image64(int width, int height, int nBands, boolean fillWithZeroes)` Creates image with pixels optionally set to zero.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`add(java.awt.image.BufferedImage bim)` Add pixel values from bim into the image data array.
`void`	`add(double offset)` Offset all pixel values by the given amount.
`void`	`add(Image other)` Add pixel values from another Image into the 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 image 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 image data array, offset by vector (dx, dy).
`void`	`addTranslated(Image im, double dx, double dy)` Add pixel values from bim into the image data array, offset by vector (dx, dy).
`void`	`applyCurveDouble(java.util.List<java.awt.Point> points)` Apply a look-up curve to this Image64.
`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 this image with 1D profiles of width nx (horizontal) and ny (vertical).
`protected void`	`checkCompatibility(java.lang.String opName, java.awt.image.BufferedImage bim)`
`protected void`	`checkCompatibility(java.lang.String opName, Image otherImage)`
`Image`	`clone()` Returns a new Image64 object with the same data, or null if there is not enough memory for it.
`Image16`	`convertToImage16()`
`Image32`	`convertToImage32()` Scale linearly to create an Image32 having only positive levels.
`Image64`	`convertToImage64()` Simply returns this (not a clone).
`Image8`	`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.
`ComplexImage64`	`createTransformedGaussian(double fullWidthAtHalfMaximum)` Create a Fourier transform of a monochrome Gaussian profile of given FWHM, at the size of the current image, ready for use in (de-)convolution.
`ComplexImage64`	`createTransformedKernel(Kernel kernel)` Create a Fourier transform of a net.grelf.image.Kernel, at the size of the current image, ready for use in (de-)convolution.
`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
`ComplexImage64`	`fft()` Fast Fourier Transform; creates a pair of 64-bit images, real [0] and imaginary [1] parts from a single real input image (this).
`ComplexImage64`	`fft(Image64 other)` Fast Fourier Transform; creates a pair of 64-bit images, real [0] and imaginary [1] parts.
`ComplexImage64`	`fftInverse(Image64 other)` Inverse Fast Fourier Transform; creates a pair of 64-bit images, real [0] and imaginary [1] parts.
`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; currently always returns 64.
`int`	`getBytesPerChannel()` Always returns 8 for this kind of image.
`RangeInt[]`	`getChannelRanges()` Find the range of values in each channel, as pairs of int values - NB: MAY OVERFLOW.
`RangeDouble[]`	`getChannelRangesDouble()` Find the range of values in each channel, as pairs of double values.
`int`	`getHeight()` Get the height, in pixels, of the image.
`double[]`	`getHorizontalSamplesDouble(int x0, int y, int band, int n)`
`java.lang.String`	`getImageTypeAsString()` For displaying image information, get its java.awt.image.BufferedImage type constant name.
`int`	`getMaxLevel()` Get highest level that can occur in each channel.
`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.
`RangeInt`	`getRangeByRescanning()` Get overall range of values across all channels, as a pair of int values, and also set it in the data of this image - NB: MAY OVERFLOW.
`RangeDouble`	`getRangeByRescanningDouble()` Get overall range of values across all channels, as a pair of double values, and also set it in the data of this image.
`RangeDouble`	`getRangeDouble()` Get the minimum and maximum values occurring, across all channels.
`double[]`	`getVerticalSamplesDouble(int x, int y0, int band, int n)`
`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.
`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`	`multiplyWeighted(double f)` Multiply all pixel values (in all bands) in the image by factor f * (g - gMin) / (gMax - gMin)
`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.
`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 intensityAcc, Image colourAcc)` 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`	`save(java.lang.String filePath)` Save on disc: 64-bit images can only be saved as FITS, so saveAsFITS() is called directly.
`void`	`save(java.lang.String filePath, RangeDouble range)` Save on disc: 64-bit images can only be saved as FITS, so saveAsFITS() is called directly.
`void`	`save(java.lang.String filePath, RangeInt range)` Save on disc: 64-bit images can only be saved as FITS, so saveAsFITS() is called directly.
`void`	`saveAsFITS(java.lang.String filePath)` Saves as a 64-bit double floating point FITS file with BZERO = 0.0 and BSCALE = 1.0.
`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 image data array.
`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.
`protected void`	`setRange(RangeInt range)`
`protected void`	`setRangeDouble(RangeDouble range)`
`void`	`showInfo()` Display information about the current image in a dialogue.
`Image[]`	`splitChannels()` Convert image to any 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 other)` Subtract pixel values of other image from this image data array.
`void`	`subtractToZero(Image other)` 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 (in which case the image width and height are powers of 2).
`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()` Get a simple description : width x height x channels
`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.
`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.

Methods inherited from class net.grelf.image.ImageBase
applyCurve, compareTo, createImage, createImage, getCalibration, getEv, getFilePath, getGraphicsConfiguration, getMetadata, pixelBrighter, pixelBrighter, pixelsDiffer, pixelsDiffer, plotResponseCurve, recombine, rotate, rotate180, rotate270, rotate90, sameBitsAndBands, sameSizeBitsAndBands, saturate, setCalibration, setEv, setFilePath, setMetadata, showInfo

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

Methods inherited from interface net.grelf.image.Image
applyCurve, getCalibration, getEv, getFilePath, getMetadata, plotResponseCurve, rotate, rotate180, rotate270, rotate90, saturate, setCalibration, setEv, setFilePath, setMetadata

- Field Detail
  - data
```
protected double[][] data
```
- Constructor Detail
  - Image64
```
public Image64(int width,
               int height,
               int nBands)
```
    Creates image without setting any pixels.
  - Image64
```
public Image64(int width,
               int height,
               int nBands,
               boolean fillWithZeroes)
```
    Creates image with pixels optionally set to zero.
  - Image64
```
public Image64(java.awt.image.BufferedImage bim)
        throws IncompatibleImageException
```
    Use the BufferedImage to set the width, height and number of bands (channels) in this Image. Populate the pixel values in the image data array from the BufferedImage also.
    
    Throws:
    
    IncompatibleImageException
- Method Detail
  - getBitsPerChannel
```
public int getBitsPerChannel()
```
    Get the number of bits per channel; currently always returns 64.
    
    Specified by:
    
    getBitsPerChannel in interface Image
    
    Specified by:
    
    getBitsPerChannel in class ImageBase
  - getBytesPerChannel
```
public int getBytesPerChannel()
```
    Always returns 8 for this kind of image.
    
    Specified by:
    
    getBytesPerChannel in interface Image
  - getWidth
```
public int getWidth()
```
    Get the width, in pixels, of the image.
    
    Specified by:
    
    getWidth in interface Image
    
    Specified by:
    
    getWidth in class ImageBase
  - getHeight
```
public int getHeight()
```
    Get the height, in pixels, of the image.
    
    Specified by:
    
    getHeight in interface Image
    
    Specified by:
    
    getHeight in class ImageBase
  - getImageTypeAsString
```
public java.lang.String getImageTypeAsString()
```
    For displaying image information, get its java.awt.image.BufferedImage type constant name.
    
    Specified by:
    
    getImageTypeAsString in interface Image
  - getMaxLevel
```
public int getMaxLevel()
```
    Description copied from interface: Image
    
    Get highest level that can occur in each channel.
    
    Specified by:
    
    getMaxLevel in interface Image
  - getNBands
```
public int getNBands()
```
    Get the number of bands (channels) in the image.
    
    Specified by:
    
    getNBands in interface Image
    
    Specified by:
    
    getNBands in class ImageBase
  - getRange
```
public RangeInt getRange()
```
    Get the minimum and maximum values occurring, across all channels. May not make sense due to casting to int.
    
    Specified by:
    
    getRange in interface Image
    
    Specified by:
    
    getRange in class ImageBase
  - getRangeDouble
```
public RangeDouble getRangeDouble()
```
    Get the minimum and maximum values occurring, across all channels.
    
    Specified by:
    
    getRangeDouble in interface Image
  - setRangeDouble
```
protected void setRangeDouble(RangeDouble range)
```
  - setRange
```
protected void setRange(RangeInt range)
```
    Specified by:
    
    setRange in class ImageBase
  - checkCompatibility
```
protected void checkCompatibility(java.lang.String opName,
                                  java.awt.image.BufferedImage bim)
                           throws IncompatibleImageException
```
    Throws:
    
    IncompatibleImageException
  - checkCompatibility
```
protected void checkCompatibility(java.lang.String opName,
                                  Image otherImage)
                           throws IncompatibleImageException
```
    Throws:
    
    IncompatibleImageException
  - add
```
public void add(double offset)
```
    Offset all pixel values by the given amount. This will be necessary before obtaining a histogram if the range is found to have a negative low value.
  - addPixel
```
public int[] addPixel(int x,
                      int y,
                      int[] px)
```
    More efficient than the sequence getPixel, add for each band, setPixel. Does nothing if x or y are outside this image, and returns null in that case.
    
    Specified by:
    
    addPixel in interface Image
  - addProportion
```
public 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.
    
    Specified by:
    
    addProportion in interface Image
    
    Throws:
    
    IncompatibleImageException
  - add
```
public void add(Image other)
         throws IncompatibleImageException
```
    Add pixel values from another Image into the data array. If the other Image is larger than this one then the rectangle starting at the top left corner which overlaps will be used.
    
    Specified by:
    
    add in interface Image
    
    Throws:
    
    IncompatibleImageException
  - add
```
public void add(java.awt.image.BufferedImage bim)
         throws IncompatibleImageException
```
    Add pixel values from bim into the image data array. If bim is larger than this Image then the rectangle starting at the top left corner of bim which overlaps the Image will be used.
    
    Specified by:
    
    add in interface Image
    
    Throws:
    
    IncompatibleImageException
  - addTranslated
```
public void addTranslated(java.awt.image.BufferedImage bim,
                          int dx,
                          int dy)
                   throws IncompatibleImageException
```
    Add pixel values from bim into the image data array, offset by vector (dx, dy). Only those pixels of the offset bim which overlap this Image are used. Using integer coordinates, this version is fast but does not interpolate from the source image.
    10.10.22: Major bug fixed.
    
    Specified by:
    
    addTranslated in interface Image
    
    Throws:
    
    IncompatibleImageException
  - addTranslated
```
public void addTranslated(java.awt.image.BufferedImage bim,
                          double dx,
                          double dy)
                   throws IncompatibleImageException
```
    Add pixel values from bim into the image data array, offset by vector (dx, dy). Only those pixels of the offset bim which overlap this Image are used. Using double coordinates, this version is slower but does interpolate from the source image.
    10.10.22: Major bug fixed.
    
    Specified by:
    
    addTranslated in interface Image
    
    Throws:
    
    IncompatibleImageException
  - addTranslated
```
public void addTranslated(Image im,
                          double dx,
                          double dy)
                   throws IncompatibleImageException
```
    Add pixel values from bim into the image data array, offset by vector (dx, dy). Only those pixels of the offset bim which overlap this Image are used. Using double coordinates, this version is slower but does interpolate from the source image.
    10.10.22: Major bug fixed.
    
    Throws:
    
    IncompatibleImageException
  - applyCurveDouble
```
public void applyCurveDouble(java.util.List<java.awt.Point> points)
```
    Apply a look-up curve to this Image64. The curve is a set of points with x and y ranges of 0..255 but the image axes have much wider ranges.
  - autoCrop
```
public 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.
    
    Specified by:
    
    autoCrop in interface Image
  - autoStretch
```
public void autoStretch(boolean allChannelsSame)
```
    Stretch the contrast in the image so the full range of levels is used.
    
    Specified by:
    
    autoStretch in interface Image
  - autoStretch
```
public 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.
    
    Specified by:
    
    autoStretch in interface Image
  - autoThreshold
```
public 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.
    
    Specified by:
    
    autoThreshold in interface Image
  - averageVertically
```
public 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.
    
    Specified by:
    
    averageVertically in interface Image
  - averageVertically
```
public 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.
    
    Specified by:
    
    averageVertically in interface Image
  - blurGaussian
```
public void blurGaussian(int nx,
                         int ny,
                         javax.swing.ProgressMonitor monitor)
```
    Do Gaussian blurring of this image with 1D profiles of width nx (horizontal) and ny (vertical).
    
    Specified by:
    
    blurGaussian in interface Image
  - clone
```
public Image clone()
```
    Returns a new Image64 object with the same data, or null if there is not enough memory for it.
    
    Specified by:
    
    clone in interface Image
    
    Overrides:
    
    clone in class java.lang.Object
  - convertToImage8
```
public Image8 convertToImage8()
```
    Specified by:
    
    convertToImage8 in interface Image
  - convertToImage16
```
public Image16 convertToImage16()
```
    Specified by:
    
    convertToImage16 in interface Image
  - convertToImage32
```
public Image32 convertToImage32()
```
    Scale linearly to create an Image32 having only positive levels.
    
    Specified by:
    
    convertToImage32 in interface Image
  - convertToImage64
```
public Image64 convertToImage64()
```
    Simply returns this (not a clone).
    
    Specified by:
    
    convertToImage64 in interface Image
  - convertToMonochrome
```
public 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.
    
    Specified by:
    
    convertToMonochrome in interface Image
  - convertToMonochrome
```
public 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.
    
    Specified by:
    
    convertToMonochrome in interface Image
  - convolve
```
public void convolve(Kernel kernel,
                     javax.swing.ProgressMonitor monitor)
```
    Perform a 2D linear convolution with the given kernel. The monitor may be null.
    
    Specified by:
    
    convolve in interface Image
  - convolve
```
public 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.
    
    Specified by:
    
    convolve in interface Image
  - correctBackground
```
public 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.
    
    Specified by:
    
    correctBackground in interface Image
  - createTransformedGaussian
```
public ComplexImage64 createTransformedGaussian(double fullWidthAtHalfMaximum)
```
    Create a Fourier transform of a monochrome Gaussian profile of given FWHM, at the size of the current image, ready for use in (de-)convolution. Disposes intermediate images. May return null if images cannot be allocated in memory.
  - createTransformedKernel
```
public ComplexImage64 createTransformedKernel(Kernel kernel)
```
    Create a Fourier transform of a net.grelf.image.Kernel, at the size of the current image, ready for use in (de-)convolution. Disposes intermediate images. May return null if images cannot be allocated in memory.
  - crop
```
public 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.
    
    Specified by:
    
    crop in interface Image
  - deconvolve
```
public 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.
    
    Specified by:
    
    deconvolve in interface Image
  - dispose
```
public void dispose()
```
    Description copied from interface: Image
    
    Release all resources.
    
    Specified by:
    
    dispose in interface Image
  - divide
```
public void divide(int n)
```
    Divide all pixel values (in all bands) in the image by n.
    
    Specified by:
    
    divide in interface Image
  - divideByFlatField
```
public void divideByFlatField(Image flat)
```
    Divide by a flat field image.
    
    Specified by:
    
    divideByFlatField in interface Image
  - drawRim
```
public void drawRim(int width,
                    java.awt.Color colour)
```
    Draw a rim around the image, of the given width and colour
    
    Specified by:
    
    drawRim in interface Image
  - fft
```
public ComplexImage64 fft()
                   throws IncompatibleImageException
```
    Fast Fourier Transform; creates a pair of 64-bit images, real [0] and imaginary [1] parts from a single real input image (this). Throws an IncompatibleImage exception if the width or height of the image is not a power of 2.
    
    Throws:
    
    IncompatibleImageException
  - fft
```
public ComplexImage64 fft(Image64 other)
                   throws IncompatibleImageException
```
    Fast Fourier Transform; creates a pair of 64-bit images, real [0] and imaginary [1] parts. Requires a second Image64 as input: this and the other image are the real and imaginary parts, created by a previous FFT and perhaps modified. This method finds out which is which of the 2 parts by examining their metadata. Throws an IncompatibleImage exception if the width or height of the images is not a power of 2 or if their widths and heights differ or if the required metadata are not present.
    
    Throws:
    
    IncompatibleImageException
  - fftInverse
```
public ComplexImage64 fftInverse(Image64 other)
                          throws IncompatibleImageException
```
    Inverse Fast Fourier Transform; creates a pair of 64-bit images, real [0] and imaginary [1] parts. Requires a second Image64 as input: this and the other image are the real and imaginary parts, created by a previous FFT and perhaps modified. This method finds out which is which of the 2 parts by examining their metadata. Throws an IncompatibleImage exception if the width or height of either image is not a power of 2, if they are of different sizes, or if the required metadata are absent (see net.grelf.image.Metadata).
    
    Throws:
    
    IncompatibleImageException
  - fit
```
public 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.
    
    Specified by:
    
    fit in interface Image
  - flipHorizontal
```
public void flipHorizontal()
```
    Flip the image horizontally.
    
    Specified by:
    
    flipHorizontal in interface Image
  - flipVertical
```
public void flipVertical()
```
    Flip the image vertically.
    
    Specified by:
    
    flipVertical in interface Image
  - getChannelRanges
```
public RangeInt[] getChannelRanges()
```
    Find the range of values in each channel, as pairs of int values - NB: MAY OVERFLOW.
    
    Specified by:
    
    getChannelRanges in interface Image
  - getChannelRangesDouble
```
public RangeDouble[] getChannelRangesDouble()
```
    Find the range of values in each channel, as pairs of double values.
    
    Specified by:
    
    getChannelRangesDouble in interface Image
  - getRangeByRescanning
```
public RangeInt getRangeByRescanning()
```
    Get overall range of values across all channels, as a pair of int values, and also set it in the data of this image - NB: MAY OVERFLOW.
    
    Specified by:
    
    getRangeByRescanning in interface Image
  - getRangeByRescanningDouble
```
public RangeDouble getRangeByRescanningDouble()
```
    Get overall range of values across all channels, as a pair of double values, and also set it in the data of this image. Ignore any infinities.
    
    Specified by:
    
    getRangeByRescanningDouble in interface Image
  - getPixel
```
public 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 image. NB: MAY OVERFLOW.
    
    Specified by:
    
    getPixel in interface Image
    
    Specified by:
    
    getPixel in class ImageBase
  - getPixelDouble
```
public 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 image.
    
    Specified by:
    
    getPixelDouble in interface Image
  - getPixelInterpolated
```
public 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 image.
    
    Specified by:
    
    getPixelInterpolated in interface Image
  - getPixelDoubleInterpolated
```
public 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 image.
    
    Specified by:
    
    getPixelDoubleInterpolated in interface Image
  - getHorizontalSamplesDouble
```
public double[] getHorizontalSamplesDouble(int x0,
                                           int y,
                                           int band,
                                           int n)
```
  - getVerticalSamplesDouble
```
public double[] getVerticalSamplesDouble(int x,
                                         int y0,
                                         int band,
                                         int n)
```
  - gnomonicProjection
```
public Image gnomonicProjection(int focalLength_mm,
                                double detectorWidth_mm,
                                double detectorHeight_mm)
```
    Project from sphere to plane.
    
    Specified by:
    
    gnomonicProjection in interface Image
  - inverseGnomonicProjection
```
public Image inverseGnomonicProjection(int focalLength_mm,
                                       double detectorWidth_mm,
                                       double detectorHeight_mm)
```
    Project from plane to sphere.
    
    Specified by:
    
    inverseGnomonicProjection in interface Image
  - invert
```
public void invert()
```
    Invert the colour at every pixel in the image.
    
    Specified by:
    
    invert in interface Image
  - isRaw
```
public boolean isRaw()
```
    Description copied from interface: Image
    
    Whether the image data are still in RAW format, as from a DSLR camera. Only an Image16 is likely to return true for this.
    
    Specified by:
    
    isRaw in interface Image
  - keepOnlyDifferingPixels
```
public 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 number of bands and bit depth.
    
    Specified by:
    
    keepOnlyDifferingPixels in interface Image
  - meanFilter
```
public 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.
    
    Specified by:
    
    meanFilter in interface Image
  - medianFilter
```
public 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.
    
    Specified by:
    
    medianFilter in interface Image
  - multiply
```
public void multiply(double f)
```
    Multiply all pixel values (in all bands) in the image by factor f.
    
    Specified by:
    
    multiply in interface Image
  - multiplyWeighted
```
public void multiplyWeighted(double f)
```
    Multiply all pixel values (in all bands) in the image by factor f * (g - gMin) / (gMax - gMin)
  - multiply
```
public void multiply(Image other)
```
    Description copied from interface: Image
    
    Multiply pixel values of current image by those of another. May well saturate but will not overflow to negative values.
    
    Specified by:
    
    multiply in interface Image
  - multiply
```
public void multiply(Image other,
                     double f1,
                     double f2)
```
    Multiply fraction f1 of this image by f2 of the other.
    
    Specified by:
    
    multiply in interface Image
  - nearestExtremeFilter
```
public 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.
    
    Specified by:
    
    nearestExtremeFilter in interface Image
  - neutraliseBackground
```
public void neutraliseBackground()
```
    Description copied from interface: Image
    
    Equate the histogram modes of all channels by stretching from the overall maximum value.
    
    Specified by:
    
    neutraliseBackground in interface Image
  - rankFilter
```
public 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.
    
    Specified by:
    
    rankFilter in interface Image
  - reapplyColour
```
public void reapplyColour(Image intensityAcc,
                          Image colourAcc)
```
    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. This enables GRIP to implement the colour preservation scheme described at http://www.allthesky.com/articles/colorpreserve.html
    
    Specified by:
    
    reapplyColour in interface Image
  - replaceBrighterPixels
```
public 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.
    
    Specified by:
    
    replaceBrighterPixels in interface Image
  - rotate
```
public 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.
    
    Specified by:
    
    rotate in interface Image
    
    Specified by:
    
    rotate in class ImageBase
  - save
```
public void save(java.lang.String filePath)
```
    Save on disc: 64-bit images can only be saved as FITS, so saveAsFITS() is called directly.
    
    Specified by:
    
    save in interface Image
  - save
```
public void save(java.lang.String filePath,
                 RangeInt range)
```
    Save on disc: 64-bit images can only be saved as FITS, so saveAsFITS() is called directly. The range parameter is ignored.
    
    Specified by:
    
    save in interface Image
  - save
```
public void save(java.lang.String filePath,
                 RangeDouble range)
```
    Save on disc: 64-bit images can only be saved as FITS, so saveAsFITS() is called directly. The range parameter is ignored.
    
    Specified by:
    
    save in interface Image
  - saveAsFITS
```
public void saveAsFITS(java.lang.String filePath)
```
    Saves as a 64-bit double floating point FITS file with BZERO = 0.0 and BSCALE = 1.0.
    
    Specified by:
    
    saveAsFITS in interface Image
  - scale
```
public void scale(double factor,
                  boolean interpolating)
```
    Scale the image in x and y by the given factor
    
    Specified by:
    
    scale in interface Image
  - scale
```
public 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.
    
    Specified by:
    
    scale in interface Image
  - scaleDownForDisplay
```
public 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).
    
    Specified by:
    
    scaleDownForDisplay in interface Image
  - set
```
public final void set(java.awt.image.BufferedImage bim)
               throws IncompatibleImageException
```
    Set pixel values from bim into the image data array. If bim is larger than the image then the rectangle starting at the top left corner of bim which overlaps the image will be used.
    
    Specified by:
    
    set in interface Image
    
    Throws:
    
    IncompatibleImageException
  - setPixel
```
public void setPixel(int x,
                     int y,
                     int[] px)
```
    Does nothing if (x, y) is outside the image.
    
    Specified by:
    
    setPixel in interface Image
    
    Specified by:
    
    setPixel in class ImageBase
  - setPixel
```
public 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.
    
    Specified by:
    
    setPixel in interface Image
  - setPixelDouble
```
public void setPixelDouble(int x,
                           int y,
                           double[] px)
```
    Does nothing if (x, y) is outside the image.
    
    Specified by:
    
    setPixelDouble in interface Image
  - setPixelDouble
```
public 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.
    
    Specified by:
    
    setPixelDouble in interface Image
  - showInfo
```
public void showInfo()
```
    Display information about the current image in a dialogue.
    
    Specified by:
    
    showInfo in interface Image
  - splitChannels
```
public Image[] splitChannels()
```
    Convert image to any array of monochrome images. 11.10.23: ImFrame parameter removed and return type added, to reduce dependencies.
    
    Specified by:
    
    splitChannels in interface Image
  - splitIntensity
```
public 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
    
    Specified by:
    
    splitIntensity in interface Image
  - subtract
```
public void subtract(Image other)
              throws IncompatibleImageException
```
    Subtract pixel values of other image from this image data array. NB: DOES NOT raise result by minimum possible - negative values are allowed in 64-bit images. 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.
    
    Specified by:
    
    subtract in interface Image
    
    Throws:
    
    IncompatibleImageException
  - subtractToZero
```
public void subtractToZero(Image other)
                    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.
    
    Specified by:
    
    subtractToZero in interface Image
    
    Throws:
    
    IncompatibleImageException
  - swapQuadrants
```
public void swapQuadrants()
```
    Rearrange the 4 quadrants of the image - useful for viewing Fourier Transform results (in which case the image width and height are powers of 2).
    
    Specified by:
    
    swapQuadrants in interface Image
    
    Overrides:
    
    swapQuadrants in class ImageBase
  - threshold
```
public 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.
    
    Specified by:
    
    threshold in interface Image
  - toString
```
public java.lang.String toString()
```
    Get a simple description : width x height x channels
    
    Specified by:
    
    toString in interface Image
    
    Overrides:
    
    toString in class java.lang.Object
  - toFoldedString
```
public java.lang.String toFoldedString(java.lang.String lineEnd)
```
    Description copied from interface: Image
    
    Return complete metadata in a form suitable for display. The lineEnd might be "\n" or "<br/>", depending on the intended output medium.
    
    Specified by:
    
    toFoldedString in interface Image
  - translate
```
public void translate(int dx,
                      int dy)
```
    Displace the image content by the given offset vector. 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 from the image menu) is a way of detecting edges in the direction of the offset.
    
    Specified by:
    
    translate in interface Image
  - translate
```
public 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.
    
    Specified by:
    
    translate in interface Image
  - varianceFilter
```
public 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.
    
    Specified by:
    
    varianceFilter in interface Image

Class Image64

Field Summary

Fields inherited from class net.grelf.image.ImageBase

Constructor Summary

Method Summary

Methods inherited from class net.grelf.image.ImageBase

Methods inherited from class java.lang.Object

Methods inherited from interface net.grelf.image.Image

Field Detail

data

Constructor Detail

Image64

Image64

Image64

Method Detail

getBitsPerChannel

getBytesPerChannel

getWidth

getHeight

getImageTypeAsString

getMaxLevel

getNBands

getRange

getRangeDouble

setRangeDouble

setRange

checkCompatibility

checkCompatibility

add

addPixel

addProportion

add

add

addTranslated

addTranslated

addTranslated

applyCurveDouble

autoCrop

autoStretch

autoStretch

autoThreshold

averageVertically

averageVertically

blurGaussian

clone

convertToImage8

convertToImage16

convertToImage32

convertToImage64

convertToMonochrome

convertToMonochrome

convolve

convolve

correctBackground

createTransformedGaussian

createTransformedKernel

crop

deconvolve

dispose

divide

divideByFlatField

drawRim

fft

fft

fftInverse

fit

flipHorizontal

flipVertical

getChannelRanges

getChannelRangesDouble

getRangeByRescanning

getRangeByRescanningDouble

getPixel

getPixelDouble

getPixelInterpolated

getPixelDoubleInterpolated

getHorizontalSamplesDouble

getVerticalSamplesDouble

gnomonicProjection

inverseGnomonicProjection