The BufferedImage subclass describes an Image with an accessible buffer of image data.
A BufferedImage is comprised of a ColorModel and a
Raster of image data.
The number and types of bands in the SampleModel of the
Raster must match the number and types required by the
ColorModel to represent its color and alpha components.
All BufferedImage objects have an upper left corner
coordinate of (0, 0). Any Raster used to construct a
BufferedImage must therefore have minX=0 and minY=0.

This class relies on the data fetching and setting methods
of Raster,
and on the color characterization methods of ColorModel.

Returns a WritableRaster representing the alpha
channel for BufferedImage objects
with ColorModel objects that support a separate
spatial alpha channel, such as ComponentColorModel and
DirectColorModel.

TYPE_CUSTOM

TYPE_INT_RGB

public static final int TYPE_INT_RGB

Represents an image with 8-bit RGB color components packed into
integer pixels. The image has a DirectColorModel without
alpha.
When data with non-opaque alpha is stored
in an image of this type,
the color data must be adjusted to a non-premultiplied form
and the alpha discarded,
as described in the
AlphaComposite documentation.

TYPE_INT_ARGB

public static final int TYPE_INT_ARGB

Represents an image with 8-bit RGBA color components packed into
integer pixels. The image has a DirectColorModel
with alpha. The color data in this image is considered not to be
premultiplied with alpha. When this type is used as the
imageType argument to a BufferedImage
constructor, the created image is consistent with images
created in the JDK1.1 and earlier releases.

TYPE_INT_BGR

public static final int TYPE_INT_BGR

Represents an image with 8-bit RGB color components, corresponding
to a Windows- or Solaris- style BGR color model, with the colors
Blue, Green, and Red packed into integer pixels. There is no alpha.
The image has a DirectColorModel.
When data with non-opaque alpha is stored
in an image of this type,
the color data must be adjusted to a non-premultiplied form
and the alpha discarded,
as described in the
AlphaComposite documentation.

TYPE_3BYTE_BGR

public static final int TYPE_3BYTE_BGR

Represents an image with 8-bit RGB color components, corresponding
to a Windows-style BGR color model) with the colors Blue, Green,
and Red stored in 3 bytes. There is no alpha. The image has a
ComponentColorModel.
When data with non-opaque alpha is stored
in an image of this type,
the color data must be adjusted to a non-premultiplied form
and the alpha discarded,
as described in the
AlphaComposite documentation.

TYPE_4BYTE_ABGR

public static final int TYPE_4BYTE_ABGR

Represents an image with 8-bit RGBA color components with the colors
Blue, Green, and Red stored in 3 bytes and 1 byte of alpha. The
image has a ComponentColorModel with alpha. The
color data in this image is considered not to be premultiplied with
alpha. The byte data is interleaved in a single
byte array in the order A, B, G, R
from lower to higher byte addresses within each pixel.

TYPE_4BYTE_ABGR_PRE

public static final int TYPE_4BYTE_ABGR_PRE

Represents an image with 8-bit RGBA color components with the colors
Blue, Green, and Red stored in 3 bytes and 1 byte of alpha. The
image has a ComponentColorModel with alpha. The color
data in this image is considered to be premultiplied with alpha.
The byte data is interleaved in a single byte array in the order
A, B, G, R from lower to higher byte addresses within each pixel.

TYPE_USHORT_565_RGB

public static final int TYPE_USHORT_565_RGB

Represents an image with 5-6-5 RGB color components (5-bits red,
6-bits green, 5-bits blue) with no alpha. This image has
a DirectColorModel.
When data with non-opaque alpha is stored
in an image of this type,
the color data must be adjusted to a non-premultiplied form
and the alpha discarded,
as described in the
AlphaComposite documentation.

TYPE_USHORT_555_RGB

public static final int TYPE_USHORT_555_RGB

Represents an image with 5-5-5 RGB color components (5-bits red,
5-bits green, 5-bits blue) with no alpha. This image has
a DirectColorModel.
When data with non-opaque alpha is stored
in an image of this type,
the color data must be adjusted to a non-premultiplied form
and the alpha discarded,
as described in the
AlphaComposite documentation.

TYPE_BYTE_GRAY

public static final int TYPE_BYTE_GRAY

Represents a unsigned byte grayscale image, non-indexed. This
image has a ComponentColorModel with a CS_GRAY
ColorSpace.
When data with non-opaque alpha is stored
in an image of this type,
the color data must be adjusted to a non-premultiplied form
and the alpha discarded,
as described in the
AlphaComposite documentation.

TYPE_USHORT_GRAY

public static final int TYPE_USHORT_GRAY

Represents an unsigned short grayscale image, non-indexed). This
image has a ComponentColorModel with a CS_GRAY
ColorSpace.
When data with non-opaque alpha is stored
in an image of this type,
the color data must be adjusted to a non-premultiplied form
and the alpha discarded,
as described in the
AlphaComposite documentation.

TYPE_BYTE_BINARY

public static final int TYPE_BYTE_BINARY

Represents an opaque byte-packed 1, 2, or 4 bit image. The
image has an IndexColorModel without alpha. When this
type is used as the imageType argument to the
BufferedImage constructor that takes an
imageType argument but no ColorModel
argument, a 1-bit image is created with an
IndexColorModel with two colors in the default
sRGB ColorSpace: {0, 0, 0} and
{255, 255, 255}.

Images with 2 or 4 bits per pixel may be constructed via
the BufferedImage constructor that takes a
ColorModel argument by supplying a
ColorModel with an appropriate map size.

Images with 8 bits per pixel should use the image types
TYPE_BYTE_INDEXED or TYPE_BYTE_GRAY
depending on their ColorModel.

When color data is stored in an image of this type,
the closest color in the colormap is determined
by the IndexColorModel and the resulting index is stored.
Approximation and loss of alpha or color components
can result, depending on the colors in the
IndexColorModel colormap.

TYPE_BYTE_INDEXED

public static final int TYPE_BYTE_INDEXED

Represents an indexed byte image. When this type is used as the
imageType argument to the BufferedImage
constructor that takes an imageType argument
but no ColorModel argument, an
IndexColorModel is created with
a 256-color 6/6/6 color cube palette with the rest of the colors
from 216-255 populated by grayscale values in the
default sRGB ColorSpace.

When color data is stored in an image of this type,
the closest color in the colormap is determined
by the IndexColorModel and the resulting index is stored.
Approximation and loss of alpha or color components
can result, depending on the colors in the
IndexColorModel colormap.

BufferedImage

Constructs a BufferedImage of one of the predefined
image types:
TYPE_BYTE_BINARY or TYPE_BYTE_INDEXED.

If the image type is TYPE_BYTE_BINARY, the number of
entries in the color model is used to determine whether the
image should have 1, 2, or 4 bits per pixel. If the color model
has 1 or 2 entries, the image will have 1 bit per pixel. If it
has 3 or 4 entries, the image with have 2 bits per pixel. If
it has between 5 and 16 entries, the image will have 4 bits per
pixel. Otherwise, an IllegalArgumentException will be thrown.

Parameters:

width - width of the created image

height - height of the created image

imageType - type of the created image

cm - IndexColorModel of the created image

Throws:

IllegalArgumentException - if the imageType is not
TYPE_BYTE_BINARY or TYPE_BYTE_INDEXED or if the imageType is
TYPE_BYTE_BINARY and the color map has more than 16 entries.

BufferedImage

Constructs a new BufferedImage with a specified
ColorModel and Raster. If the number and
types of bands in the SampleModel of the
Raster do not match the number and types required by
the ColorModel to represent its color and alpha
components, a RasterFormatException is thrown. This
method can multiply or divide the color Raster data by
alpha to match the alphaPremultiplied state
in the ColorModel. Properties for this
BufferedImage can be established by passing
in a Hashtable of String/Object
pairs.

Parameters:

cm - ColorModel for the new image

raster - Raster for the image data

isRasterPremultiplied - if true, the data in
the raster has been premultiplied with alpha.

properties - Hashtable of
String/Object pairs.

Throws:

RasterFormatException - if the number and
types of bands in the SampleModel of the
Raster do not match the number and types required by
the ColorModel to represent its color and alpha
components.

getRaster

getAlphaRaster

Returns a WritableRaster representing the alpha
channel for BufferedImage objects
with ColorModel objects that support a separate
spatial alpha channel, such as ComponentColorModel and
DirectColorModel. Returns null if there
is no alpha channel associated with the ColorModel in
this image. This method assumes that for all
ColorModel objects other than
IndexColorModel, if the ColorModel
supports alpha, there is a separate alpha channel
which is stored as the last band of image data.
If the image uses an IndexColorModel that
has alpha in the lookup table, this method returns
null since there is no spatially discrete alpha
channel. This method creates a new
WritableRaster, but shares the data array.

Returns:

a WritableRaster or null if this
BufferedImage has no alpha channel associated
with its ColorModel.

getRGB

public int getRGB(int x,
int y)

Returns an integer pixel in the default RGB color model
(TYPE_INT_ARGB) and default sRGB colorspace. Color
conversion takes place if this default model does not match
the image ColorModel. There are only 8-bits of
precision for each color component in the returned data when using
this method.

An ArrayOutOfBoundsException may be thrown
if the coordinates are not in bounds.
However, explicit bounds checking is not guaranteed.

Parameters:

x - the X coordinate of the pixel from which to get
the pixel in the default RGB color model and sRGB
color space

y - the Y coordinate of the pixel from which to get
the pixel in the default RGB color model and sRGB
color space

Returns:

an integer pixel in the default RGB color model and
default sRGB colorspace.

getRGB

Returns an array of integer pixels in the default RGB color model
(TYPE_INT_ARGB) and default sRGB color space,
from a portion of the image data. Color conversion takes
place if the default model does not match the image
ColorModel. There are only 8-bits of precision for
each color component in the returned data when
using this method. With a specified coordinate (x, y) in the
image, the ARGB pixel can be accessed in this way:

pixel = rgbArray[offset + (y-startY)*scansize + (x-startX)];

An ArrayOutOfBoundsException may be thrown
if the region is not in bounds.
However, explicit bounds checking is not guaranteed.

setRGB

public void setRGB(int x,
int y,
int rgb)

Sets a pixel in this BufferedImage to the specified
RGB value. The pixel is assumed to be in the default RGB color
model, TYPE_INT_ARGB, and default sRGB color space. For images
with an IndexColorModel, the index with the nearest
color is chosen.

An ArrayOutOfBoundsException may be thrown
if the coordinates are not in bounds.
However, explicit bounds checking is not guaranteed.

setRGB

Sets an array of integer pixels in the default RGB color model
(TYPE_INT_ARGB) and default sRGB color space,
into a portion of the image data. Color conversion takes place
if the default model does not match the image
ColorModel. There are only 8-bits of precision for
each color component in the returned data when
using this method. With a specified coordinate (x, y) in the
this image, the ARGB pixel can be accessed in this way:

pixel = rgbArray[offset + (y-startY)*scansize + (x-startX)];

WARNING: No dithering takes place.

An ArrayOutOfBoundsException may be thrown
if the region is not in bounds.
However, explicit bounds checking is not guaranteed.

getProperty

Returns a property of the image by name. Individual property names
are defined by the various image formats. If a property is not
defined for a particular image, this method returns the
UndefinedProperty field. If the properties
for this image are not yet known, then this method returns
null and the ImageObserver object is
notified later. The property name "comment" should be used to
store an optional comment that can be presented to the user as a
description of the image, its source, or its author.

getSources

Returns a Vector of RenderedImage objects that are
the immediate sources, not the sources of these immediate sources,
of image data for this BufferedImage. This
method returns null if the BufferedImage
has no information about its immediate sources. It returns an
empty Vector if the BufferedImage has no
immediate sources.

a Vector containing immediate sources of
this BufferedImage object's image date, or
null if this BufferedImage has
no information about its immediate sources, or an empty
Vector if this BufferedImage
has no immediate sources.

getTile

Returns tile (tileX, tileY). Note
that tileX and tileY are indices
into the tile array, not pixel locations. The Raster
that is returned is live, which means that it is updated if the
image is changed.

copyData

Computes an arbitrary rectangular region of the
BufferedImage and copies it into a specified
WritableRaster. The region to be computed is
determined from the bounds of the specified
WritableRaster. The specified
WritableRaster must have a
SampleModel that is compatible with this image. If
outRaster is null,
an appropriate WritableRaster is created.

setData

Sets a rectangular region of the image to the contents of the
specified Rasterr, which is
assumed to be in the same coordinate space as the
BufferedImage. The operation is clipped to the bounds
of the BufferedImage.

a WritableRaster that is the tile, indicated by
the specified indices, to be checked out for writing.

releaseWritableTile

public void releaseWritableTile(int tileX,
int tileY)

Relinquishes permission to write to a tile. If the caller
continues to write to the tile, the results are undefined.
Calls to this method should only appear in matching pairs
with calls to getWritableTile(int, int). Any other leads
to undefined results. All registered TileObservers
are notified when a tile goes from having one writer to having no
writers.