public class IndexColorModel extends ColorModel
IndexColorModel class is a ColorModel
class that works with pixel values consisting of a
single sample that is an index into a fixed colormap in the default
sRGB color space. The colormap specifies red, green, blue, and
optional alpha components corresponding to each index. All components
are represented in the colormap as 8-bit unsigned integral values.
Some constructors allow the caller to specify "holes" in the colormap
by indicating which colormap entries are valid and which represent
unusable colors via the bits set in a BigInteger object.
This color model is similar to an X11 PseudoColor visual.
Some constructors provide a means to specify an alpha component
for each pixel in the colormap, while others either provide no
such means or, in some cases, a flag to indicate whether the
colormap data contains alpha values. If no alpha is supplied to
the constructor, an opaque alpha component (alpha = 1.0) is
assumed for each entry.
An optional transparent pixel value can be supplied that indicates a
completely transparent pixel, regardless of any alpha component
supplied or assumed for that pixel value.
Note that the color components in the colormap of an
IndexColorModel objects are never pre-multiplied with
the alpha components.
The index represented by a pixel value is stored in the least
significant n bits of the pixel representations passed to the
methods of this class, where n is the pixel size specified to the
constructor for a particular IndexColorModel object;
n must be between 1 and 16, inclusive.
Higher order bits in pixel representations are assumed to be zero.
For those methods that use a primitive array pixel representation of
type transferType, the array length is always one.
The transfer types supported are DataBuffer.TYPE_BYTE and
DataBuffer.TYPE_USHORT. A single int pixel
representation is valid for all objects of this class, since it is
always possible to represent pixel values used with this class in a
single int. Therefore, methods that use this representation do
not throw an IllegalArgumentException due to an invalid
pixel value.
Many of the methods in this class are final. The reason for this is that the underlying native graphics code makes assumptions about the layout and operation of this class and those assumptions are reflected in the implementations of the methods here that are marked final. You can subclass this class for other reaons, but you cannot override or modify the behaviour of those methods.
ColorModel,
ColorSpace,
DataBufferpixel_bitsBITMASK, OPAQUE, TRANSLUCENT| Constructor and Description |
|---|
IndexColorModel(int bits,
int size,
byte[] r,
byte[] g,
byte[] b)
Constructs an
IndexColorModel from the specified
arrays of red, green, and blue components. |
IndexColorModel(int bits,
int size,
byte[] r,
byte[] g,
byte[] b,
byte[] a)
Constructs an
IndexColorModel from the given
arrays of red, green, blue and alpha components. |
IndexColorModel(int bits,
int size,
byte[] r,
byte[] g,
byte[] b,
int trans)
Constructs an
IndexColorModel from the given arrays
of red, green, and blue components. |
IndexColorModel(int bits,
int size,
byte[] cmap,
int start,
boolean hasalpha)
Constructs an
IndexColorModel from a single
array of interleaved red, green, blue and optional alpha
components. |
IndexColorModel(int bits,
int size,
byte[] cmap,
int start,
boolean hasalpha,
int trans)
Constructs an
IndexColorModel from a single array of
interleaved red, green, blue and optional alpha components. |
| Modifier and Type | Method and Description |
|---|---|
void |
finalize()
Disposes of system resources associated with this
ColorModel once this ColorModel is no
longer referenced. |
int |
getAlpha(int pixel)
Returns the alpha component for the specified pixel, scaled
from 0 to 255.
|
void |
getAlphas(byte[] a)
Copies the array of alpha transparency components into the
specified array.
|
int |
getBlue(int pixel)
Returns the blue color component for the specified pixel, scaled
from 0 to 255 in the default RGB ColorSpace, sRGB.
|
void |
getBlues(byte[] b)
Copies the array of blue color components into the specified array.
|
int |
getGreen(int pixel)
Returns the green color component for the specified pixel, scaled
from 0 to 255 in the default RGB ColorSpace, sRGB.
|
void |
getGreens(byte[] g)
Copies the array of green color components into the specified array.
|
int |
getMapSize()
Returns the size of the color/alpha component arrays in this
IndexColorModel. |
int |
getRed(int pixel)
Returns the red color component for the specified pixel, scaled
from 0 to 255 in the default RGB ColorSpace, sRGB.
|
void |
getReds(byte[] r)
Copies the array of red color components into the specified array.
|
int |
getRGB(int pixel)
Returns the color/alpha components of the pixel in the default
RGB color model format.
|
int |
getTransparentPixel()
Returns the index of the transparent pixel in this
IndexColorModel or -1 if there is no transparent pixel. |
String |
toString()
Returns the
String representation of the contents of
this ColorModelobject. |
equals, getColorSpace, getComponentSize, getComponentSize, getNumColorComponents, getNumComponents, getPixelSize, getRGBdefault, getTransferType, getTransparency, hasAlpha, hashCode, isAlphaPremultipliedpublic IndexColorModel(int bits,
int size,
byte[] r,
byte[] g,
byte[] b)
IndexColorModel from the specified
arrays of red, green, and blue components. Pixels described
by this color model all have alpha components of 255
unnormalized (1.0 normalized), which means they
are fully opaque. All of the arrays specifying the color
components must have at least the specified number of entries.
The ColorSpace is the default sRGB space.
Since there is no alpha information in any of the arguments
to this constructor, the transparency value is always
Transparency.OPAQUE.
The transfer type is the smallest of DataBuffer.TYPE_BYTE
or DataBuffer.TYPE_USHORT that can hold a single pixel.bits - the number of bits each pixel occupiessize - the size of the color component arraysr - the array of red color componentsg - the array of green color componentsb - the array of blue color componentsIllegalArgumentException - if bits is less
than 1 or greater than 16IllegalArgumentException - if size is less
than 1public IndexColorModel(int bits,
int size,
byte[] r,
byte[] g,
byte[] b,
int trans)
IndexColorModel from the given arrays
of red, green, and blue components. Pixels described by this color
model all have alpha components of 255 unnormalized
(1.0 normalized), which means they are fully opaque, except
for the indicated transparent pixel. All of the arrays
specifying the color components must have at least the specified
number of entries.
The ColorSpace is the default sRGB space.
The transparency value may be Transparency.OPAQUE or
Transparency.BITMASK depending on the arguments, as
specified in the class description above.
The transfer type is the smallest of DataBuffer.TYPE_BYTE
or DataBuffer.TYPE_USHORT that can hold a
single pixel.bits - the number of bits each pixel occupiessize - the size of the color component arraysr - the array of red color componentsg - the array of green color componentsb - the array of blue color componentstrans - the index of the transparent pixelIllegalArgumentException - if bits is less than
1 or greater than 16IllegalArgumentException - if size is less than
1public IndexColorModel(int bits,
int size,
byte[] r,
byte[] g,
byte[] b,
byte[] a)
IndexColorModel from the given
arrays of red, green, blue and alpha components. All of the
arrays specifying the components must have at least the specified
number of entries.
The ColorSpace is the default sRGB space.
The transparency value may be any of Transparency.OPAQUE,
Transparency.BITMASK,
or Transparency.TRANSLUCENT
depending on the arguments, as specified
in the class description above.
The transfer type is the smallest of DataBuffer.TYPE_BYTE
or DataBuffer.TYPE_USHORT that can hold a single pixel.bits - the number of bits each pixel occupiessize - the size of the color component arraysr - the array of red color componentsg - the array of green color componentsb - the array of blue color componentsa - the array of alpha value componentsIllegalArgumentException - if bits is less
than 1 or greater than 16IllegalArgumentException - if size is less
than 1public IndexColorModel(int bits,
int size,
byte[] cmap,
int start,
boolean hasalpha)
IndexColorModel from a single
array of interleaved red, green, blue and optional alpha
components. The array must have enough values in it to
fill all of the needed component arrays of the specified
size. The ColorSpace is the default sRGB space.
The transparency value may be any of Transparency.OPAQUE,
Transparency.BITMASK,
or Transparency.TRANSLUCENT
depending on the arguments, as specified
in the class description above.
The transfer type is the smallest of
DataBuffer.TYPE_BYTE or DataBuffer.TYPE_USHORT
that can hold a single pixel.bits - the number of bits each pixel occupiessize - the size of the color component arrayscmap - the array of color componentsstart - the starting offset of the first color componenthasalpha - indicates whether alpha values are contained in
the cmap arrayIllegalArgumentException - if bits is less
than 1 or greater than 16IllegalArgumentException - if size is less
than 1public IndexColorModel(int bits,
int size,
byte[] cmap,
int start,
boolean hasalpha,
int trans)
IndexColorModel from a single array of
interleaved red, green, blue and optional alpha components. The
specified transparent index represents a pixel that is considered
entirely transparent regardless of any alpha value specified
for it. The array must have enough values in it to fill all
of the needed component arrays of the specified size.
The ColorSpace is the default sRGB space.
The transparency value may be any of Transparency.OPAQUE,
Transparency.BITMASK,
or Transparency.TRANSLUCENT
depending on the arguments, as specified
in the class description above.
The transfer type is the smallest of
DataBuffer.TYPE_BYTE or DataBuffer.TYPE_USHORT
that can hold a single pixel.bits - the number of bits each pixel occupiessize - the size of the color component arrayscmap - the array of color componentsstart - the starting offset of the first color componenthasalpha - indicates whether alpha values are contained in
the cmap arraytrans - the index of the fully transparent pixelIllegalArgumentException - if bits is less than
1 or greater than 16IllegalArgumentException - if size is less than
1public final int getMapSize()
IndexColorModel.public final int getTransparentPixel()
IndexColorModel or -1 if there is no transparent pixel.IndexColorModel object's
transparent pixel, or -1 if there is no such pixel.public final void getReds(byte[] r)
getMapSize are written.r - the specified array into which the elements of the
array of red color components are copiedpublic final void getGreens(byte[] g)
getMapSize are written.g - the specified array into which the elements of the
array of green color components are copiedpublic final void getBlues(byte[] b)
getMapSize are written.b - the specified array into which the elements of the
array of blue color components are copiedpublic final void getAlphas(byte[] a)
getMapSize are written.a - the specified array into which the elements of the
array of alpha components are copiedpublic final int getRed(int pixel)
getRed in class ColorModelpixel - the specified pixelpublic final int getGreen(int pixel)
getGreen in class ColorModelpixel - the specified pixelpublic final int getBlue(int pixel)
getBlue in class ColorModelpixel - the specified pixelpublic final int getAlpha(int pixel)
getAlpha in class ColorModelpixel - the specified pixelpublic final int getRGB(int pixel)
getRGB in class ColorModelpixel - the specified pixelColorModel.getRGBdefault()public void finalize()
ColorModel once this ColorModel is no
longer referenced.finalize in class ColorModelpublic String toString()
String representation of the contents of
this ColorModelobject.toString in class ColorModelString representing the contents of this
ColorModel object.Copyright © 2013 CableLabs. All rights reserved.