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
pixel to be made completely transparent, 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.
If an IndexColorModel object has
a transparency value of Transparency.OPAQUE,
then the hasAlpha
and getNumComponents methods
(both inherited from ColorModel)
return false and 3, respectively.
For any other transparency value,
hasAlpha returns true
and getNumComponents returns 4.
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 reasons, but you cannot override or modify the behaviour of those methods.
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.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 pixel to be made transparent. 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.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.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.IndexColorModel from a single array of
interleaved red, green, blue and optional alpha components. The
specified transparent index represents a pixel that is made
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.IndexColorModel from an array of
ints where each int is comprised of red, green, blue, and
optional alpha components in the default RGB color model format.
The specified transparent index represents a pixel that is made
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.IndexColorModel from an
int array where each int is
comprised of red, green, blue, and alpha
components in the default RGB color model format.
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 must be one of DataBuffer.TYPE_BYTE
DataBuffer.TYPE_USHORT.
The BigInteger object specifies the valid/invalid pixels
in the cmap array. A pixel is valid if the
BigInteger value at that index is set, and is invalid
if the BigInteger bit at that index is not set.isAlphaPremultiplied variable, assuming the data is
currently correctly described by this ColorModel. It
may multiply or divide the color raster data by alpha, or do
nothing if the data is in the correct state. If the data needs to
be coerced, this method will also return an instance of this
ColorModel with the isAlphaPremultiplied
flag set appropriately. This method will throw a
UnsupportedOperationException if it is not supported
by this ColorModel.
Since ColorModel is an abstract class,
any instance is an instance of a subclass. Subclasses must
override this method since the implementation in this abstract
class throws an UnsupportedOperationException.BufferedImage of TYPE_INT_ARGB or
TYPE_INT_RGB that has a Raster with pixel data
computed by expanding the indices in the source Raster
using the color/alpha component arrays of this ColorModel.
If forceARGB is true, a TYPE_INT_ARGB image is
returned regardless of whether or not this ColorModel
has an alpha component array or a transparent pixel.SampleModel with the specified
width and height that has a data layout compatible with
this ColorModel.WritableRaster with the specified width
and height that has a data layout (SampleModel)
compatible with this ColorModel. This method
only works for color models with 16 or fewer bits per pixel.
Since IndexColorModel can be subclassed, any
subclass that supports greater than 16 bits per pixel must
override this method.
Object is an instance of
ColorModel and if it equals this
ColorModel.ColorModel once this ColorModel is no
longer referenced.ClassCastException is thrown. An
ArrayIndexOutOfBoundsException is thrown if
inData is not large enough to hold a pixel value for
this ColorModel.
If this transferType is not supported, a
UnsupportedOperationException will be
thrown. Since
ColorModel is an abstract class, any instance
must be an instance of a subclass. Subclasses inherit the
implementation of this method and if they don't override it, this
method throws an exception if the subclass uses a
transferType other than
DataBuffer.TYPE_BYTE,
DataBuffer.TYPE_USHORT, or
DataBuffer.TYPE_INT.Raster representing the alpha channel of an
image, extracted from the input Raster, provided that
pixel values of this ColorModel represent color and
alpha information as separate spatial bands (e.g.
ComponentColorModel
and DirectColorModel).
This method assumes that Raster objects associated
with such a ColorModel store the alpha band, if
present, as the last band of image data. Returns null
if there is no separate spatial alpha channel associated with this
ColorModel. If this is an
IndexColorModel which has alpha in the lookup table,
this method will return null since
there is no spatially discrete alpha channel.
This method will create a new Raster (but will share
the data array).
Since ColorModel is an abstract class, any instance
is an instance of a subclass. Subclasses must override this
method to get any behavior other than returning null
because the implementation in this abstract class returns
null.getMapSize are written.ColorSpace, sRGB. A
color conversion is done if necessary. The pixel value is
specified by an array of data elements of type transferType passed
in as an object reference. 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 will be 0. If
inData is not a primitive array of type transferType,
a ClassCastException is thrown. An
ArrayIndexOutOfBoundsException is
thrown if inData is not large enough to hold a pixel
value for this ColorModel.
If this transferType is not supported, a
UnsupportedOperationException will be
thrown. Since
ColorModel is an abstract class, any instance
must be an instance of a subclass. Subclasses inherit the
implementation of this method and if they don't override it, this
method throws an exception if the subclass uses a
transferType other than
DataBuffer.TYPE_BYTE,
DataBuffer.TYPE_USHORT, or
DataBuffer.TYPE_INT.getMapSize are written.ColorSpace associated with this
ColorModel.ColorModel. The pixel value
is specified as an int. If the components array is null,
a new array is allocated that contains
offset + getNumComponents() elements.
The components array is returned,
with the alpha component included
only if hasAlpha returns true.
Color/alpha components are stored in the components array starting
at offset even if the array is allocated by this method.
An ArrayIndexOutOfBoundsException
is thrown if the components array is not null and is
not large enough to hold all the color and alpha components
starting at offset.ColorModel. The pixel
value is specified by an array of data elements of type
transferType passed in as an object reference.
If pixel is not a primitive array of type
transferType, a ClassCastException
is thrown. An ArrayIndexOutOfBoundsException
is thrown if pixel is not large enough to hold
a pixel value for this ColorModel. If the
components array is null, a new array
is allocated that contains
offset + getNumComponents() elements.
The components array is returned,
with the alpha component included
only if hasAlpha returns true.
Color/alpha components are stored in the components
array starting at offset even if the array is
allocated by this method. An
ArrayIndexOutOfBoundsException is also
thrown if the components array is not
null and is not large enough to hold all the color
and alpha components starting at offset.
Since IndexColorModel can be subclassed, subclasses
inherit the implementation of this method and if they don't
override it then they throw an exception if they use an
unsupported transferType.
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.int in this
ColorModel, given an array of normalized color/alpha
components. This method will throw an
IllegalArgumentException if pixel values for this
ColorModel are not conveniently representable as a
single int. An
ArrayIndexOutOfBoundsException is thrown if the
normComponents array is not large enough to hold all the
color and alpha components (starting at normOffset).
Since ColorModel is an abstract class,
any instance is an instance of a subclass. The default implementation
of this method in this abstract class first converts from the
normalized form to the unnormalized form and then calls
getDataElement(int[], int). Subclasses which may
have instances which do not support the unnormalized form must
override this method.ColorModel given an array of unnormalized
color/alpha components. An
ArrayIndexOutOfBoundsException
is thrown if the components array is not large
enough to hold all of the color and alpha components starting
at offset. Since
ColorModel can be subclassed, subclasses inherit the
implementation of this method and if they don't override it then
they throw an exception if they use an unsupported transferType.ColorModel, given an array of normalized color/alpha
components. This array can then be passed to the
setDataElements method of a WritableRaster
object. An ArrayIndexOutOfBoundsException is thrown
if the normComponents array is not large enough to hold
all the color and alpha components (starting at
normOffset). If the obj variable is
null, a new array will be allocated. If
obj is not null, it must be a primitive
array of type transferType; otherwise, a
ClassCastException is thrown. An
ArrayIndexOutOfBoundsException is thrown if
obj is not large enough to hold a pixel value for this
ColorModel.
Since ColorModel is an abstract class,
any instance is an instance of a subclass. The default implementation
of this method in this abstract class first converts from the
normalized form to the unnormalized form and then calls
getDataElement(int[], int, Object). Subclasses which may
have instances which do not support the unnormalized form must
override this method.ColorModel given an array of unnormalized color/alpha
components. This array can then be passed to the
setDataElements method of a WritableRaster
object. An ArrayIndexOutOfBoundsException is
thrown if the
components array is not large enough to hold all of the
color and alpha components starting at offset.
If the pixel variable is null, a new array
is allocated. If pixel is not null,
it must be a primitive array of type transferType;
otherwise, a ClassCastException is thrown.
An ArrayIndexOutOfBoundsException is thrown if pixel
is not large enough to hold a pixel value for this
ColorModel.
Since IndexColorModel can be subclassed, subclasses
inherit the implementation of this method and if they don't
override it then they throw an exception if they use an
unsupported transferType
null, a new array is allocated. If pixel
is not null, it must be
a primitive array of type transferType; otherwise, a
ClassCastException is thrown. An
ArrayIndexOutOfBoundsException is
thrown if pixel is not large enough to hold a pixel
value for this ColorModel. The pixel array is returned.
Since IndexColorModel can be subclassed, subclasses
inherit the implementation of this method and if they don't
override it then they throw an exception if they use an
unsupported transferType.
ColorSpace, sRGB. A
color conversion is done if necessary. The pixel value is
specified by an array of data elements of type transferType passed
in as an object reference. The returned value will be 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. If inData is
not a primitive array of type transferType, a
ClassCastException is thrown. An
ArrayIndexOutOfBoundsException is thrown if
inData is not large enough to hold a pixel value for
this ColorModel.
If this transferType is not supported, a
UnsupportedOperationException will be
thrown. Since
ColorModel is an abstract class, any instance
must be an instance of a subclass. Subclasses inherit the
implementation of this method and if they don't override it, this
method throws an exception if the subclass uses a
transferType other than
DataBuffer.TYPE_BYTE,
DataBuffer.TYPE_USHORT, or
DataBuffer.TYPE_INT.getMapSize are written.IndexColorModel.ColorSpace object for this
ColorModel. An IllegalArgumentException
will be thrown if color component values for this
ColorModel are not conveniently representable in the
unnormalized form. If the
normComponents array is null, a new array
will be allocated. The normComponents array
will be returned. Color/alpha components are stored in the
normComponents array starting at
normOffset (even if the array is allocated by this
method). An ArrayIndexOutOfBoundsException is thrown
if the normComponents array is not null
and is not large enough to hold all the color and alpha components
(starting at normOffset). An
IllegalArgumentException is thrown if the
components array is not large enough to hold all the
color and alpha components starting at offset.
Since ColorModel is an abstract class,
any instance is an instance of a subclass. The default implementation
of this method in this abstract class assumes that component values
for this class are conveniently representable in the unnormalized
form. Therefore, subclasses which may
have instances which do not support the unnormalized form must
override this method.
ColorModel. The pixel
value is specified by an array of data elements of type transferType
passed in as an object reference. If pixel is not a primitive array
of type transferType, a ClassCastException is thrown.
An ArrayIndexOutOfBoundsException is thrown if
pixel is not large enough to hold a pixel value for this
ColorModel.
Normalized components are float values between a per component minimum
and maximum specified by the ColorSpace object for this
ColorModel. If the
normComponents array is null, a new array
will be allocated. The normComponents array
will be returned. Color/alpha components are stored in the
normComponents array starting at
normOffset (even if the array is allocated by this
method). An ArrayIndexOutOfBoundsException is thrown
if the normComponents array is not null
and is not large enough to hold all the color and alpha components
(starting at normOffset).
Since ColorModel is an abstract class,
any instance is an instance of a subclass. The default implementation
of this method in this abstract class first retrieves color and alpha
components in the unnormalized form using
getComponents(Object, int[], int) and then calls
getNormalizedComponents(int[], int, float[], int).
Subclasses which may
have instances which do not support the unnormalized form must
override this method.ColorModel.
This is the number of components returned by
ColorSpace#getNumComponents
.ColorModel. This is equal to the number of color
components, optionally plus one, if there is an alpha component.ColorModel.ColorSpace, sRGB. A
color conversion is done if necessary. The pixel value is
specified by an array of data elements of type transferType passed
in as an object reference. The returned value is a non
pre-multiplied value. For example, if alpha is premultiplied,
this method divides it out before returning
the value. If the alpha value is 0, the red value is 0.
If inData is not a primitive array of type
transferType, a ClassCastException is thrown. An
ArrayIndexOutOfBoundsException is thrown if
inData is not large enough to hold a pixel value for
this ColorModel.
If this transferType is not supported, a
UnsupportedOperationException will be
thrown. Since
ColorModel is an abstract class, any instance
must be an instance of a subclass. Subclasses inherit the
implementation of this method and if they don't override it, this
method throws an exception if the subclass uses a
transferType other than
DataBuffer.TYPE_BYTE,
DataBuffer.TYPE_USHORT, or
DataBuffer.TYPE_INT.ClassCastException is thrown. An
ArrayIndexOutOfBoundsException is
thrown if inData is not large enough to hold a pixel
value for this ColorModel.
The returned value will be in a non pre-multiplied format, i.e. if
the alpha is premultiplied, this method will divide it out of the
color components (if the alpha value is 0, the color values will be 0).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.getMapSize are
written.ColorModel.
The transfer type is the type of primitive array used to represent
pixel values as arrays.IndexColorModel or -1 if there is no pixel
with an alpha value of 0. If a transparent pixel was
explicitly specified in one of the constructors by its
index, then that index will be preferred, otherwise,
the index of any pixel which happens to be fully transparent
may be returned.ColorSpace object for this
ColorModel. An IllegalArgumentException
will be thrown if color component values for this
ColorModel are not conveniently representable in the
unnormalized form. If the
components array is null, a new array
will be allocated. The components array will
be returned. Color/alpha components are stored in the
components array starting at offset (even
if the array is allocated by this method). An
ArrayIndexOutOfBoundsException is thrown if the
components array is not null and is not
large enough to hold all the color and alpha
components (starting at offset). An
IllegalArgumentException is thrown if the
normComponents array is not large enough to hold
all the color and alpha components starting at
normOffset.BigInteger that indicates the valid/invalid
pixels in the colormap. A bit is valid if the
BigInteger value at that index is set, and is invalid
if the BigInteger value at that index is not set.
The only valid ranges to query in the BigInteger are
between 0 and the map size.ColorModel.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.true if raster is compatible
with this ColorModel or false if it
is not compatible with this ColorModel.SampleModel is compatible
with this ColorModel. If sm is
null, this method returns false.wait methods.
The awakened thread will not be able to proceed until the current thread relinquishes the lock on this object. The awakened thread will compete in the usual manner with any other threads that might be actively competing to synchronize on this object; for example, the awakened thread enjoys no reliable privilege or disadvantage in being the next thread to lock this object.
This method should only be called by a thread that is the owner of this object's monitor. A thread becomes the owner of the object's monitor in one of three ways:
synchronized statement
that synchronizes on the object.
Class, by executing a
synchronized static method of that class.
Only one thread at a time can own an object's monitor.
wait methods.
The awakened threads will not be able to proceed until the current thread relinquishes the lock on this object. The awakened threads will compete in the usual manner with any other threads that might be actively competing to synchronize on this object; for example, the awakened threads enjoy no reliable privilege or disadvantage in being the next thread to lock this object.
This method should only be called by a thread that is the owner
of this object's monitor. See the notify method for a
description of the ways in which a thread can become the owner of
a monitor.
String representation of the contents of
this ColorModelobject.
The current thread must own this object's monitor. The thread
releases ownership of this monitor and waits until another thread
notifies threads waiting on this object's monitor to wake up
either through a call to the notify method or the
notifyAll method. The thread then waits until it can
re-obtain ownership of the monitor and resumes execution.
As in the one argument version, interrupts and spurious wakeups are possible, and this method should always be used in a loop:
synchronized (obj) {
while (<condition does not hold>)
obj.wait();
... // Perform action appropriate to condition
}
This method should only be called by a thread that is the owner
of this object's monitor. See the notify method for a
description of the ways in which a thread can become the owner of
a monitor.The current thread must own this object's monitor.
This method causes the current thread (call it T) to place itself in the wait set for this object and then to relinquish any and all synchronization claims on this object. Thread T becomes disabled for thread scheduling purposes and lies dormant until one of four things happens:
A thread can also wake up without being notified, interrupted, or timing out, a so-called spurious wakeup. While this will rarely occur in practice, applications must guard against it by testing for the condition that should have caused the thread to be awakened, and continuing to wait if the condition is not satisfied. In other words, waits should always occur in loops, like this one:
synchronized (obj) {
while (<condition does not hold>)
obj.wait(timeout);
... // Perform action appropriate to condition
}
(For more information on this topic, see Section 3.2.3 in Doug Lea's
"Concurrent Programming in Java (Second Edition)" (Addison-Wesley,
2000), or Item 50 in Joshua Bloch's "Effective Java Programming
Language Guide" (Addison-Wesley, 2001).
If the current thread is interrupted by another thread while it is waiting, then an InterruptedException is thrown. This exception is not thrown until the lock status of this object has been restored as described above.
Note that the wait method, as it places the current thread into the wait set for this object, unlocks only this object; any other objects on which the current thread may be synchronized remain locked while the thread waits.
This method should only be called by a thread that is the owner
of this object's monitor. See the notify method for a
description of the ways in which a thread can become the owner of
a monitor.
This method is similar to the wait method of one
argument, but it allows finer control over the amount of time to
wait for a notification before giving up. The amount of real time,
measured in nanoseconds, is given by:
1000000*timeout+nanos
In all other respects, this method does the same thing as the method of one argument. In particular, wait(0, 0) means the same thing as wait(0).
The current thread must own this object's monitor. The thread releases ownership of this monitor and waits until either of the following two conditions has occurred:
notify method
or the notifyAll method.
timeout
milliseconds plus nanos nanoseconds arguments, has
elapsed.
The thread then waits until it can re-obtain ownership of the monitor and resumes execution.
As in the one argument version, interrupts and spurious wakeups are possible, and this method should always be used in a loop:
synchronized (obj) {
while (<condition does not hold>)
obj.wait(timeout, nanos);
... // Perform action appropriate to condition
}
This method should only be called by a thread that is the owner
of this object's monitor. See the notify method for a
description of the ways in which a thread can become the owner of
a monitor.