| java.lang.Object
 java.awt.image.ColorModel
java.awt.image.IndexColorModel
| IndexColorModel | | public class IndexColorModel extends ColorModel (Code) | | The 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 transparency of an IndexColorModel object is
determined by examining the alpha components of the colors in the
colormap and choosing the most specific value after considering
the optional alpha values and any transparent index specified.
The transparency value is Transparency.OPAQUE
only if all valid colors in
the colormap are opaque and there is no valid transparent pixel.
If all valid colors
in the colormap are either completely opaque (alpha = 1.0) or
completely transparent (alpha = 0.0), which typically occurs when
a valid transparent pixel is specified,
the value is Transparency.BITMASK.
Otherwise, the value is Transparency.TRANSLUCENT, indicating
that some valid color has an alpha component that is
neither completely transparent nor completely opaque (0.0 < alpha < 1.0).
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.
See Also: ColorModel
See Also: ColorSpace
See Also: DataBuffer
version:
10 Feb 1997 |
| Constructor Summary | |
| public | IndexColorModel(int bits, int size, byte r, byte g, byte b)
Constructs an IndexColorModel from the specified
arrays of red, green, and blue components. | | public | 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. | | public | 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. | | public | 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. | | public | 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. |
| Method Summary | |
| public void | finalize()
Disposes of system resources associated with this
ColorModel once this ColorModel is no
longer referenced. | | final public int | getAlpha(int pixel)
Returns the alpha component for the specified pixel, scaled
from 0 to 255. | | final public void | getAlphas(byte a)
Copies the array of alpha transparency components into the
specified array. | | final public int | getBlue(int pixel)
Returns the blue color component for the specified pixel, scaled
from 0 to 255 in the default RGB ColorSpace, sRGB. | | final public void | getBlues(byte b)
Copies the array of blue color components into the specified array. | | final public int | getGreen(int pixel)
Returns the green color component for the specified pixel, scaled
from 0 to 255 in the default RGB ColorSpace, sRGB. | | final public void | getGreens(byte g)
Copies the array of green color components into the specified array. | | final public int | getMapSize()
Returns the size of the color/alpha component arrays in this
IndexColorModel. | | final public int | getRGB(int pixel)
Returns the color/alpha components of the pixel in the default
RGB color model format. | | final public int | getRed(int pixel)
Returns the red color component for the specified pixel, scaled
from 0 to 255 in the default RGB ColorSpace, sRGB. | | final public void | getReds(byte r)
Copies the array of red color components into the specified array. | | final public int | getTransparentPixel()
Returns the index of the transparent pixel in this
IndexColorModel or -1 if there is no transparent pixel. | | public String | toString()
Returns the String representation of the contents of
this ColorModelobject. |
| IndexColorModel | | public IndexColorModel(int bits, int size, byte r, byte g, byte b)(Code) | | Constructs an 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.
Parameters:
bits - the number of bits each pixel occupies
Parameters:
size - the size of the color component arrays
Parameters:
r - the array of red color components
Parameters:
g - the array of green color components
Parameters:
b - the array of blue color components
throws:
IllegalArgumentException - if bits is lessthan 1 or greater than 16
throws:
IllegalArgumentException - if size is lessthan 1 |
| IndexColorModel | | public IndexColorModel(int bits, int size, byte r, byte g, byte b, int trans)(Code) | | Constructs an 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.
Parameters:
bits - the number of bits each pixel occupies
Parameters:
size - the size of the color component arrays
Parameters:
r - the array of red color components
Parameters:
g - the array of green color components
Parameters:
b - the array of blue color components
Parameters:
trans - the index of the transparent pixel
throws:
IllegalArgumentException - if bits is less than1 or greater than 16
throws:
IllegalArgumentException - if size is less than1 |
| IndexColorModel | | public IndexColorModel(int bits, int size, byte r, byte g, byte b, byte a)(Code) | | Constructs an 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.
Parameters:
bits - the number of bits each pixel occupies
Parameters:
size - the size of the color component arrays
Parameters:
r - the array of red color components
Parameters:
g - the array of green color components
Parameters:
b - the array of blue color components
Parameters:
a - the array of alpha value components
throws:
IllegalArgumentException - if bits is lessthan 1 or greater than 16
throws:
IllegalArgumentException - if size is lessthan 1 |
| IndexColorModel | | public IndexColorModel(int bits, int size, byte cmap, int start, boolean hasalpha)(Code) | | Constructs an 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.
Parameters:
bits - the number of bits each pixel occupies
Parameters:
size - the size of the color component arrays
Parameters:
cmap - the array of color components
Parameters:
start - the starting offset of the first color component
Parameters:
hasalpha - indicates whether alpha values are contained inthe cmap array
throws:
IllegalArgumentException - if bits is lessthan 1 or greater than 16
throws:
IllegalArgumentException - if size is lessthan 1 |
| IndexColorModel | | public IndexColorModel(int bits, int size, byte cmap, int start, boolean hasalpha, int trans)(Code) | | Constructs an 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.
Parameters:
bits - the number of bits each pixel occupies
Parameters:
size - the size of the color component arrays
Parameters:
cmap - the array of color components
Parameters:
start - the starting offset of the first color component
Parameters:
hasalpha - indicates whether alpha values are contained inthe cmap array
Parameters:
trans - the index of the fully transparent pixel
throws:
IllegalArgumentException - if bits is less than1 or greater than 16
throws:
IllegalArgumentException - if size is less than1 |
| finalize | | public void finalize()(Code) | | Disposes of system resources associated with this
ColorModel once this ColorModel is no
longer referenced.
|
| getAlpha | | final public int getAlpha(int pixel)(Code) | | Returns the alpha component for the specified pixel, scaled
from 0 to 255. The pixel value is specified as an int.
Parameters:
pixel - the specified pixel the value of the alpha component for the specified pixel |
| getAlphas | | final public void getAlphas(byte a)(Code) | | Copies the array of alpha transparency components into the
specified array. Only the initial entries of the array as specified
by getMapSize are written.
Parameters:
a - the specified array into which the elements of the array of alpha components are copied |
| getBlue | | final public int getBlue(int pixel)(Code) | | Returns the blue color component for the specified pixel, scaled
from 0 to 255 in the default RGB ColorSpace, sRGB. The pixel value
is specified as an int. The returned value is a
non pre-multiplied value.
Parameters:
pixel - the specified pixel the value of the blue color component for the specified pixel |
| getBlues | | final public void getBlues(byte b)(Code) | | Copies the array of blue color components into the specified array.
Only the initial entries of the array as specified by
getMapSize are written.
Parameters:
b - the specified array into which the elements of the array of blue color components are copied |
| getGreen | | final public int getGreen(int pixel)(Code) | | Returns the green color component for the specified pixel, scaled
from 0 to 255 in the default RGB ColorSpace, sRGB. The pixel value
is specified as an int. The returned value is a
non pre-multiplied value.
Parameters:
pixel - the specified pixel the value of the green color component for the specified pixel |
| getGreens | | final public void getGreens(byte g)(Code) | | Copies the array of green color components into the specified array.
Only the initial entries of the array as specified by
getMapSize are written.
Parameters:
g - the specified array into which the elements of the array of green color components are copied |
| getMapSize | | final public int getMapSize()(Code) | | Returns the size of the color/alpha component arrays in this
IndexColorModel.
the size of the color and alpha component arrays. |
| getRGB | | final public int getRGB(int pixel)(Code) | | Returns the color/alpha components of the pixel in the default
RGB color model format. The pixel value is specified as an int.
The returned value is in a non pre-multiplied format.
Parameters:
pixel - the specified pixel the color and alpha components of the specified pixel
See Also: ColorModel.getRGBdefault |
| getRed | | final public int getRed(int pixel)(Code) | | Returns the red color component for the specified pixel, scaled
from 0 to 255 in the default RGB ColorSpace, sRGB. The pixel value
is specified as an int. The returned value is a
non pre-multiplied value.
Parameters:
pixel - the specified pixel the value of the red color component for the specified pixel |
| getReds | | final public void getReds(byte r)(Code) | | Copies the array of red color components into the specified array.
Only the initial entries of the array as specified by
IndexColorModel.getMapSize() getMapSize are written.
Parameters:
r - the specified array into which the elements of the array of red color components are copied |
| getTransparentPixel | | final public int getTransparentPixel()(Code) | | Returns the index of the transparent pixel in this
IndexColorModel or -1 if there is no transparent pixel.
the index of this IndexColorModel object'stransparent pixel, or -1 if there is no such pixel. |
| toString | | public String toString()(Code) | | Returns the String representation of the contents of
this ColorModelobject.
a String representing the contents of thisColorModel object. |
|
|