The ColorModel abstract class encapsulates the
methods for translating a pixel value to color components
(for example, red, green, and blue) and an alpha component.
In order to render an image to the screen, a printer, or another
image, pixel values must be converted to color and alpha components.
As arguments to or return values from methods of this class,
pixels are represented as 32-bit ints or as arrays of primitive types.
The number, order, and interpretation of color components for a
ColorModel is specified by its ColorSpace.
A ColorModel used with pixel data that does not include
alpha information treats all pixels as opaque, which is an alpha
value of 1.0.

Methods in the ColorModel class use two different
representations of color and alpha components - a normalized form
and an unnormalized form. In the normalized form, each component is a
float value between
0.0 and 1.0.
Normalized color component values are not premultiplied.
All ColorModels must support the normalized form.

In the unnormalized
form, each component is an unsigned integral value between 0 and
2n - 1, where n is the number of significant bits for a
particular component. If pixel values for a particular
ColorModel represent color samples premultiplied by
the alpha sample, unnormalized color component values are
also premultiplied. The unnormalized form is used only with instances
of ColorModel whose ColorSpace has minimum
component values of 0.0 for all components and maximum values of
1.0 for all components.
The unnormalized form for color and alpha components can be a convenient
representation for ColorModels whose normalized component
values all lie
between 0.0 and 1.0. In such cases the integral value 0 maps to 0.0 and
the value 2n - 1 maps to 1.0. In other cases, such as
when the normalized component values can be either negative or positive,
the unnormalized form is not convenient. Such ColorModel
objects throw an IllegalArgumentException when methods involving
an unnormalized argument are called. Subclasses of ColorModel
must specify the conditions under which this occurs.

pixel_bits

protected int pixel_bits

The total number of bits in the pixel.

Constructor Detail

ColorModel

public ColorModel(int bits)

Constructs a ColorModel that translates pixels of the
specified number of bits to color/alpha components. The color
space is the default RGB ColorSpace, which is sRGB.
Pixel values are assumed to include alpha information. If color
and alpha information are represented in the pixel value as
separate spatial bands, the color bands are assumed not to be
premultiplied with the alpha value. The transparency type is
java.awt.Transparency.TRANSLUCENT. The transfer type will be the
smallest of DataBuffer.TYPE_BYTE, DataBuffer.TYPE_USHORT,
or DataBuffer.TYPE_INT that can hold a single pixel
(or DataBuffer.TYPE_UNDEFINED if bits is greater
than 32). Since this constructor has no information about the
number of bits per color and alpha component, any subclass calling
this constructor should override any method that requires this
information.

ColorModel

Constructs a ColorModel that translates pixel values
to color/alpha components. Color components will be in the
specified ColorSpace. pixel_bits is the
number of bits in the pixel values. The bits array
specifies the number of significant bits per color and alpha component.
Its length should be the number of components in the
ColorSpace if there is no alpha information in the
pixel values, or one more than this number if there is alpha
information. hasAlpha indicates whether or not alpha
information is present. The booleanisAlphaPremultiplied specifies how to interpret pixel
values in which color and alpha information are represented as
separate spatial bands. If the boolean
is true, color samples are assumed to have been
multiplied by the alpha sample. The transparency
specifies what alpha values can be represented by this color model.
The transfer type is the type of primitive array used to represent
pixel values. Note that the bits array contains the number of
significant bits per color/alpha component after the translation
from pixel values. For example, for an
IndexColorModel with pixel_bits equal to
16, the bits array might have four elements with each element set
to 8.

Parameters:

pixel_bits - the number of bits in the pixel values

bits - array that specifies the number of significant bits
per color and alpha component

cspace - the specified ColorSpace

hasAlpha - true if alpha information is present;
false otherwise

isAlphaPremultiplied - true if color samples are
assumed to be premultiplied by the alpha samples;
false otherwise

transparency - what alpha values can be represented by this
color model

transferType - the type of the array used to represent pixel
values

Throws:

IllegalArgumentException - if the length of
the bit array is less than the number of color or alpha
components in this ColorModel, or if the
transparency is not a valid value.

IllegalArgumentException - if the sum of the number
of bits in bits is less than 1 or if
any of the elements in bits is less than 0.

getRGBdefault

Returns a DirectColorModel that describes the default
format for integer RGB values used in many of the methods in the
AWT image interfaces for the convenience of the programmer.
The color space is the default ColorSpace, sRGB.
The format for the RGB values is an integer with 8 bits
each of alpha, red, green, and blue color components ordered
correspondingly from the most significant byte to the least
significant byte, as in: 0xAARRGGBB. Color components are
not premultiplied by the alpha component. This format does not
necessarily represent the native or the most efficient
ColorModel for a particular device or for all images.
It is merely used as a common color model format.

Returns:

a DirectColorModelobject describing default
RGB values.

hasAlpha

public final boolean hasAlpha()

Returns whether or not alpha is supported in this
ColorModel.

Returns:

true if alpha is supported in this
ColorModel; false otherwise.

isAlphaPremultiplied

public final boolean isAlphaPremultiplied()

Returns whether or not the alpha has been premultiplied in the
pixel values to be translated by this ColorModel.
If the boolean is true, this ColorModel
is to be used to interpret pixel values in which color and alpha
information are represented as separate spatial bands, and color
samples are assumed to have been multiplied by the
alpha sample.

Returns:

true if the alpha values are premultiplied
in the pixel values to be translated by this
ColorModel; false otherwise.

getTransferType

public final int getTransferType()

Returns the transfer type of this ColorModel.
The transfer type is the type of primitive array used to represent
pixel values as arrays.

Returns:

the transfer type.

getPixelSize

public int getPixelSize()

Returns the number of bits per pixel described by this
ColorModel.

Returns:

the number of bits per pixel.

getComponentSize

public int getComponentSize(int componentIdx)

Returns the number of bits for the specified color/alpha component.
Color components are indexed in the order specified by the
ColorSpace. Typically, this order reflects the name
of the color space type. For example, for TYPE_RGB, index 0
corresponds to red, index 1 to green, and index 2
to blue. If this ColorModel supports alpha, the alpha
component corresponds to the index following the last color
component.

Parameters:

componentIdx - the index of the color/alpha component

Returns:

the number of bits for the color/alpha component at the
specified index.

getRed

public abstract int getRed(int pixel)

Returns the red color component for the specified pixel, scaled
from 0 to 255 in the default RGB ColorSpace, sRGB. A color conversion
is done if necessary. The pixel value is specified as an int.
An IllegalArgumentException is thrown if pixel
values for this ColorModel are not conveniently
representable as a single int. The returned value is not a
pre-multiplied value. For example, if the
alpha is premultiplied, this method divides it out before returning
the value. If the alpha value is 0, the red value is 0.

Parameters:

pixel - a specified pixel

Returns:

the value of the red component of the specified pixel.

getGreen

public abstract int getGreen(int pixel)

Returns the green color component for the specified pixel, scaled
from 0 to 255 in the default RGB ColorSpace, sRGB. A color conversion
is done if necessary. The pixel value is specified as an int.
An IllegalArgumentException is thrown if pixel
values for this ColorModel are not conveniently
representable as a single int. The returned value is a non
pre-multiplied value. For example, if the alpha is premultiplied,
this method divides it out before returning
the value. If the alpha value is 0, the green value is 0.

Parameters:

pixel - the specified pixel

Returns:

the value of the green component of the specified pixel.

getBlue

public abstract int getBlue(int pixel)

Returns the blue color component for the specified pixel, scaled
from 0 to 255 in the default RGB ColorSpace, sRGB. A color conversion
is done if necessary. The pixel value is specified as an int.
An IllegalArgumentException is thrown if pixel values
for this ColorModel are not conveniently representable
as a single int. The returned value is a non pre-multiplied
value, for example, if the alpha is premultiplied, this method
divides it out before returning the value. If the alpha value is
0, the blue value is 0.

Parameters:

pixel - the specified pixel

Returns:

the value of the blue component of the specified pixel.

getAlpha

public abstract int getAlpha(int pixel)

Returns the alpha component for the specified pixel, scaled
from 0 to 255. The pixel value is specified as an int.
An IllegalArgumentException is thrown if pixel
values for this ColorModel are not conveniently
representable as a single int.

Parameters:

pixel - the specified pixel

Returns:

the value of alpha component of the specified pixel.

getRGB

public int getRGB(int pixel)

Returns the color/alpha components of the pixel in the default
RGB color model format. A color conversion is done if necessary.
The pixel value is specified as an int.
An IllegalArgumentException thrown if pixel values
for this ColorModel are not conveniently representable
as a single int. The returned value is in a non
pre-multiplied format. For example, if the alpha is premultiplied,
this method divides it out of the color components. If the alpha
value is 0, the color values are 0.

A script enabled browser is required for this page to function properly.A script enabled browser is required for this page to function properly.A script enabled browser is required for this page to function properly.A script enabled browser is required for this page to function properly.A script enabled browser is required for this page to function properly.