|
||||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Object java.awt.image.ColorModel
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.
This ColorModel
class supports two representations of
pixel values. A pixel value can be a single 32-bit int or an
array of primitive types. The Java(tm) Platform 1.0 and 1.1 APIs
represented pixels as single byte
or single
int
values. For purposes of the ColorModel
class, pixel value arguments were passed as ints. The Java(tm) 2
Platform API introduced additional classes for representing images.
With BufferedImage
or RenderedImage
objects, based on Raster
and SampleModel
classes, pixel
values might not be conveniently representable as a single int.
Consequently, ColorModel
now has methods that accept
pixel values represented as arrays of primitive types. The primitive
type used by a particular ColorModel
object is called its
transfer type.
ColorModel
objects used with images for which pixel values
are not conveniently representable as a single int throw an
IllegalArgumentException
when methods taking a single int pixel
argument are called. Subclasses of ColorModel
must
specify the conditions under which this occurs. This does not
occur with DirectColorModel
or IndexColorModel
objects.
Currently, the transfer types supported by the Java 2D(tm) API are
DataBuffer.TYPE_BYTE, DataBuffer.TYPE_USHORT, DataBuffer.TYPE_INT,
DataBuffer.TYPE_SHORT, DataBuffer.TYPE_FLOAT, and DataBuffer.TYPE_DOUBLE.
Most rendering operations will perform much faster when using ColorModels
and images based on the first three of these types. In addition, some
image filtering operations are not supported for ColorModels and
images based on the latter three types.
The transfer type for a particular ColorModel
object is
specified when the object is created, either explicitly or by default.
All subclasses of ColorModel
must specify what the
possible transfer types are and how the number of elements in the
primitive arrays representing pixels is determined.
For BufferedImages
, the transfer type of its
Raster
and of the Raster
object's
SampleModel
(available from the
getTransferType
methods of these classes) must match that
of the ColorModel
. The number of elements in an array
representing a pixel for the Raster
and
SampleModel
(available from the
getNumDataElements
methods of these classes) must match
that of the ColorModel
.
The algorithm used to convert from pixel values to color and alpha
components varies by subclass. For example, there is not necessarily
a one-to-one correspondence between samples obtained from the
SampleModel
of a BufferedImage
object's
Raster
and color/alpha components. Even when
there is such a correspondence, the number of bits in a sample is not
necessarily the same as the number of bits in the corresponding color/alpha
component. Each subclass must specify how the translation from
pixel values to color/alpha components is done.
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 some minimum and maximum values. For
the alpha component, the minimum is 0.0 and the maximum is 1.0. For
color components the minimum and maximum values for each component can
be obtained from the ColorSpace
object. These values
will often be 0.0 and 1.0 (e.g. normalized component values for the
default sRGB color space range from 0.0 to 1.0), but some color spaces
have component values with different upper and lower limits. These
limits can be obtained using the getMinValue
and
getMaxValue
methods of the ColorSpace
class. 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.
IndexColorModel
,
ComponentColorModel
,
PackedColorModel
,
DirectColorModel
,
Image
,
BufferedImage
,
RenderedImage
,
ColorSpace
,
SampleModel
,
Raster
,
DataBuffer
Field Summary | |
(package private) ColorSpace |
colorSpace
|
(package private) int |
colorSpaceType
|
(package private) static Map |
g16Tos8Map
|
(package private) static Map |
g8Tos8Map
|
(package private) boolean |
is_sRGB
|
(package private) boolean |
isAlphaPremultiplied
|
(package private) static byte[] |
l16Tos8
|
(package private) static byte[] |
l8Tos8
|
(package private) static Map |
lg16Toog16Map
|
(package private) static Map |
lg16Toog8Map
|
private static boolean |
loaded
This is copied from java.awt.Toolkit since we need the library loaded in java.awt.image also: WARNING: This is a temporary workaround for a problem in the way the AWT loads native libraries. |
(package private) int |
maxBits
|
(package private) int[] |
nBits
|
(package private) int |
numColorComponents
|
(package private) int |
numComponents
|
private long |
pData
|
protected int |
pixel_bits
The total number of bits in the pixel. |
private static ColorModel |
RGBdefault
|
(package private) static short[] |
s8Tol16
|
(package private) static byte[] |
s8Tol8
|
(package private) boolean |
supportsAlpha
|
protected int |
transferType
Data type of the array used to represent pixel values. |
(package private) int |
transparency
|
Fields inherited from interface java.awt.Transparency |
BITMASK, OPAQUE, TRANSLUCENT |
Constructor Summary | |
|
ColorModel(int bits)
Constructs a ColorModel that translates pixels of the
specified number of bits to color/alpha components. |
protected |
ColorModel(int pixel_bits,
int[] bits,
ColorSpace cspace,
boolean hasAlpha,
boolean isAlphaPremultiplied,
int transparency,
int transferType)
Constructs a ColorModel that translates pixel values
to color/alpha components. |
Method Summary | |
ColorModel |
coerceData(WritableRaster raster,
boolean isAlphaPremultiplied)
Forces the raster data to match the state specified in the isAlphaPremultiplied variable, assuming the data is
currently correctly described by this ColorModel . |
SampleModel |
createCompatibleSampleModel(int w,
int h)
Creates a SampleModel with the specified width and
height that has a data layout compatible with this
ColorModel .
|
WritableRaster |
createCompatibleWritableRaster(int w,
int h)
Creates a WritableRaster with the specified width and
height that has a data layout (SampleModel ) compatible
with this ColorModel .
|
boolean |
equals(Object obj)
Tests if the specified Object is an instance of
ColorModel and if it equals this
ColorModel . |
void |
finalize()
Disposes of system resources associated with this ColorModel once this ColorModel is no
longer referenced. |
abstract int |
getAlpha(int pixel)
Returns the alpha component for the specified pixel, scaled from 0 to 255. |
int |
getAlpha(Object inData)
Returns the alpha component for the specified pixel, scaled from 0 to 255. |
WritableRaster |
getAlphaRaster(WritableRaster raster)
Returns a 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.
|
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. |
int |
getBlue(Object inData)
Returns the blue color component for the specified pixel, scaled from 0 to 255 in the default RGB ColorSpace , sRGB. |
ColorSpace |
getColorSpace()
Returns the ColorSpace associated with this
ColorModel . |
int[] |
getComponents(int pixel,
int[] components,
int offset)
Returns an array of unnormalized color/alpha components given a pixel in this ColorModel . |
int[] |
getComponents(Object pixel,
int[] components,
int offset)
Returns an array of unnormalized color/alpha components given a pixel in this ColorModel . |
int[] |
getComponentSize()
Returns an array of the number of bits per color/alpha component. |
int |
getComponentSize(int componentIdx)
Returns the number of bits for the specified color/alpha component. |
int |
getDataElement(float[] normComponents,
int normOffset)
Returns a pixel value represented as an int in this
ColorModel , given an array of normalized color/alpha
components. |
int |
getDataElement(int[] components,
int offset)
Returns a pixel value represented as an int in this
ColorModel , given an array of unnormalized color/alpha
components. |
Object |
getDataElements(float[] normComponents,
int normOffset,
Object obj)
Returns a data element array representation of a pixel in this ColorModel , given an array of normalized color/alpha
components. |
Object |
getDataElements(int[] components,
int offset,
Object obj)
Returns a data element array representation of a pixel in this ColorModel , given an array of unnormalized color/alpha
components. |
Object |
getDataElements(int rgb,
Object pixel)
Returns a data element array representation of a pixel in this ColorModel , given an integer pixel representation in
the default RGB color model.
|
(package private) static int |
getDefaultTransferType(int pixel_bits)
|
(package private) static byte[] |
getGray16TosRGB8LUT(ICC_ColorSpace grayCS)
|
(package private) static byte[] |
getGray8TosRGB8LUT(ICC_ColorSpace grayCS)
|
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. |
int |
getGreen(Object inData)
Returns the green color component for the specified pixel, scaled from 0 to 255 in the default RGB ColorSpace , sRGB. |
(package private) static short[] |
getLinearGray16ToOtherGray16LUT(ICC_ColorSpace grayCS)
|
(package private) static byte[] |
getLinearGray16ToOtherGray8LUT(ICC_ColorSpace grayCS)
|
(package private) static byte[] |
getLinearRGB16TosRGB8LUT()
|
(package private) static byte[] |
getLinearRGB8TosRGB8LUT()
|
float[] |
getNormalizedComponents(int[] components,
int offset,
float[] normComponents,
int normOffset)
Returns an array of all of the color/alpha components in normalized form, given an unnormalized component array. |
float[] |
getNormalizedComponents(Object pixel,
float[] normComponents,
int normOffset)
Returns an array of all of the color/alpha components in normalized form, given a pixel in this ColorModel . |
int |
getNumColorComponents()
Returns the number of color components in this ColorModel .
|
int |
getNumComponents()
Returns the number of components, including alpha, in this ColorModel . |
int |
getPixelSize()
Returns the number of bits per pixel described by this ColorModel . |
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. |
int |
getRed(Object inData)
Returns the red color component for the specified pixel, scaled from 0 to 255 in the default RGB ColorSpace , sRGB. |
int |
getRGB(int pixel)
Returns the color/alpha components of the pixel in the default RGB color model format. |
int |
getRGB(Object inData)
Returns the color/alpha components for the specified pixel in the default RGB color model format. |
static ColorModel |
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.
|
(package private) static short[] |
getsRGB8ToLinearRGB16LUT()
|
(package private) static byte[] |
getsRGB8ToLinearRGB8LUT()
|
int |
getTransferType()
Returns the transfer type of this ColorModel .
|
int |
getTransparency()
Returns the transparency. |
int[] |
getUnnormalizedComponents(float[] normComponents,
int normOffset,
int[] components,
int offset)
Returns an array of all of the color/alpha components in unnormalized form, given a normalized component array. |
boolean |
hasAlpha()
Returns whether or not alpha is supported in this ColorModel . |
int |
hashCode()
Returns the hash code for this ColorModel. |
private static void |
initIDs()
|
boolean |
isAlphaPremultiplied()
Returns whether or not the alpha has been premultiplied in the pixel values to be translated by this ColorModel .
|
boolean |
isCompatibleRaster(Raster raster)
Returns true if raster is compatible
with this ColorModel and false if it is
not.
|
boolean |
isCompatibleSampleModel(SampleModel sm)
Checks if the SampleModel is compatible with this
ColorModel .
|
(package private) static boolean |
isLinearGRAYspace(ColorSpace cs)
|
(package private) static boolean |
isLinearRGBspace(ColorSpace cs)
|
(package private) static void |
loadLibraries()
|
String |
toString()
Returns the String representation of the contents of
this ColorModel object. |
Methods inherited from class java.lang.Object |
clone, getClass, notify, notifyAll, wait, wait, wait |
Field Detail |
private long pData
protected int pixel_bits
int[] nBits
int transparency
boolean supportsAlpha
boolean isAlphaPremultiplied
int numComponents
int numColorComponents
ColorSpace colorSpace
int colorSpaceType
int maxBits
boolean is_sRGB
protected int transferType
private static boolean loaded
private static ColorModel RGBdefault
static byte[] l8Tos8
static byte[] s8Tol8
static byte[] l16Tos8
static short[] s8Tol16
static Map g8Tos8Map
static Map lg16Toog8Map
static Map g16Tos8Map
static Map lg16Toog16Map
Constructor Detail |
public ColorModel(int bits)
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.
bits
- the number of bits of a pixel
IllegalArgumentException
- if the number
of bits in bits
is less than 1protected ColorModel(int pixel_bits, int[] bits, ColorSpace cspace, boolean hasAlpha, boolean isAlphaPremultiplied, int transparency, int transferType)
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 boolean
isAlphaPremultiplied
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.
pixel_bits
- the number of bits in the pixel valuesbits
- array that specifies the number of significant bits
per color and alpha componentcspace
- the specified ColorSpace
hasAlpha
- true
if alpha information is present;
false
otherwiseisAlphaPremultiplied
- true
if color samples are
assumed to be premultiplied by the alpha samples;
false
otherwisetransparency
- what alpha values can be represented by this
color modeltransferType
- the type of the array used to represent pixel
values
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.Transparency
Method Detail |
static void loadLibraries()
private static void initIDs()
public static ColorModel getRGBdefault()
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.
DirectColorModel
object describing default
RGB values.public final boolean hasAlpha()
ColorModel
.
true
if alpha is supported in this
ColorModel
; false
otherwise.public final boolean isAlphaPremultiplied()
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 the alpha values are premultiplied
in the pixel values to be translated by this
ColorModel
; false
otherwise.public final int getTransferType()
ColorModel
.
The transfer type is the type of primitive array used to represent
pixel values as arrays.
public int getPixelSize()
ColorModel
.
public int getComponentSize(int componentIdx)
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.
componentIdx
- the index of the color/alpha component
ArrayIndexOutOfBoundsException
- if componentIdx
is greater than the number of components or
less than zero
NullPointerException
- if the number of bits array is
null
public int[] getComponentSize()
ColorSpace
, followed by the alpha component, if
present.
public int getTransparency()
getTransparency
in interface Transparency
ColorModel
.Transparency.OPAQUE
,
Transparency.BITMASK
,
Transparency.TRANSLUCENT
public int getNumComponents()
ColorModel
. This is equal to the number of color
components, optionally plus one, if there is an alpha component.
ColorModel
public int getNumColorComponents()
ColorModel
.
This is the number of components returned by
ColorSpace.getNumComponents()
.
ColorModel
.ColorSpace.getNumComponents()
public abstract int getRed(int pixel)
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.
pixel
- a specified pixel
public abstract int getGreen(int pixel)
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.
pixel
- the specified pixel
public abstract int getBlue(int pixel)
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.
pixel
- the specified pixel
public abstract int getAlpha(int pixel)
IllegalArgumentException
is thrown if pixel
values for this ColorModel
are not conveniently
representable as a single int.
pixel
- the specified pixel
public int getRGB(int pixel)
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.
pixel
- the specified pixel
getRGBdefault()
public int getRed(Object inData)
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
.
inData
- an array of pixel values
ClassCastException
- if inData
is not a primitive array of type transferType
ArrayIndexOutOfBoundsException
- if
inData
is not large enough to hold a pixel value
for this ColorModel
UnsupportedOperationException
- if this
tranferType
is not supported by this
ColorModel
public int getGreen(Object inData)
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
.
inData
- an array of pixel values
ClassCastException
- if inData
is not a primitive array of type transferType
ArrayIndexOutOfBoundsException
- if
inData
is not large enough to hold a pixel value
for this ColorModel
UnsupportedOperationException
- if this
tranferType
is not supported by this
ColorModel
public int getBlue(Object inData)
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
.
inData
- an array of pixel values
ClassCastException
- if inData
is not a primitive array of type transferType
ArrayIndexOutOfBoundsException
- if
inData
is not large enough to hold a pixel value
for this ColorModel
UnsupportedOperationException
- if this
tranferType
is not supported by this
ColorModel
public int getAlpha(Object inData)
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
.
inData
- the specified pixel
ClassCastException
- if inData
is not a primitive array of type transferType
ArrayIndexOutOfBoundsException
- if
inData
is not large enough to hold a pixel value
for this ColorModel
UnsupportedOperationException
- if this
tranferType
is not supported by this
ColorModel
public int getRGB(Object inData)
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).
inData
- the specified pixel
getRGBdefault()
public Object getDataElements(int rgb, Object pixel)
ColorModel
, given an integer pixel representation in
the default RGB color model.
This array can then be passed to the
WritableRaster.setDataElements(int, int, java.lang.Object)
method of
a WritableRaster
object. If the pixel variable is
null
, a new array will be 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.
If this transferType
is not supported, a
UnsupportedOperationException
will be
thrown. 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
.
rgb
- the integer pixel representation in the default RGB
color modelpixel
- the specified pixel
ColorModel
.
ClassCastException
- if pixel
is not a primitive array of type transferType
ArrayIndexOutOfBoundsException
- if
pixel
is not large enough to hold a pixel value
for this ColorModel
UnsupportedOperationException
- if this
method is not supported by this ColorModel
WritableRaster.setDataElements(int, int, java.lang.Object)
,
SampleModel.setDataElements(int, int, java.lang.Object, java.awt.image.DataBuffer)
public int[] getComponents(int pixel, int[] components, int offset)
ColorModel
. The pixel value is specified as
an int
. An IllegalArgumentException
will be thrown if pixel values for this ColorModel
are
not conveniently representable as a single int
or if
color component values for this ColorModel
are not
conveniently representable in the unnormalized form.
For example, this method can be used to retrieve the
components for a specific pixel value in a
DirectColorModel
. 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).
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
.
pixel
- the specified pixelcomponents
- the array to receive the color and alpha
components of the specified pixeloffset
- the offset into the components
array at
which to start storing the color and alpha components
UnsupportedOperationException
- if this
method is not supported by this ColorModel
public int[] getComponents(Object pixel, int[] components, int 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 IllegalArgumentException
will be thrown if color
component values for this ColorModel
are not
conveniently representable in the unnormalized form.
An ArrayIndexOutOfBoundsException
is
thrown if pixel
is not large enough to hold a pixel
value for this ColorModel
.
This method can be used to retrieve the components for a specific
pixel value in any ColorModel
. 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
).
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
.
pixel
- the specified pixelcomponents
- an array that receives the color and alpha
components of the specified pixeloffset
- the index into the components
array at
which to begin storing the color and alpha components of the
specified pixel
UnsupportedOperationException
- if this
method is not supported by this ColorModel
public int[] getUnnormalizedComponents(float[] normComponents, int normOffset, int[] components, int offset)
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
.
normComponents
- an array containing normalized componentsnormOffset
- the offset into the normComponents
array at which to start retrieving normalized componentscomponents
- an array that receives the components from
normComponents
offset
- the index into components
at which to
begin storing normalized components from
normComponents
IllegalArgumentException
- If the component values for this
ColorModel
are not conveniently representable in the
unnormalized form.
IllegalArgumentException
- if the length of
normComponents
minus normOffset
is less than numComponents
UnsupportedOperationException
- if the
constructor of this ColorModel
called the
super(bits)
constructor, but did not
override this method. See the constructor,
ColorModel(int)
.public float[] getNormalizedComponents(int[] components, int offset, float[] normComponents, int normOffset)
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.
components
- an array containing unnormalized componentsoffset
- the offset into the components
array at
which to start retrieving unnormalized componentsnormComponents
- an array that receives the normalized componentsnormOffset
- the index into normComponents
at
which to begin storing normalized components
IllegalArgumentException
- If the component values for this
ColorModel
are not conveniently representable in the
unnormalized form.
UnsupportedOperationException
- if the
constructor of this ColorModel
called the
super(bits)
constructor, but did not
override this method. See the constructor,
ColorModel(int)
.
UnsupportedOperationException
- if this method is unable
to determine the number of bits per componentpublic int getDataElement(int[] components, int offset)
int
in this
ColorModel
, given an array of unnormalized color/alpha
components. This method will throw an
IllegalArgumentException
if component values for this
ColorModel
are not conveniently representable as a
single int
or if color component values for this
ColorModel
are not conveniently representable in the
unnormalized form. An
ArrayIndexOutOfBoundsException
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. Subclasses must
override this method since the implementation in this abstract
class throws an UnsupportedOperationException
.
components
- an array of unnormalized color and alpha
componentsoffset
- the index into components
at which to
begin retrieving the color and alpha components
int
pixel value in this
ColorModel
corresponding to the specified components.
IllegalArgumentException
- if
pixel values for this ColorModel
are not
conveniently representable as a single int
IllegalArgumentException
- if
component values for this ColorModel
are not
conveniently representable in the unnormalized form
ArrayIndexOutOfBoundsException
- if
the components
array is not large enough to
hold all of the color and alpha components starting at
offset
UnsupportedOperationException
- if this
method is not supported by this ColorModel
public Object getDataElements(int[] components, int offset, Object obj)
ColorModel
, given an array of unnormalized color/alpha
components. This array can then be passed to the
setDataElements
method of a WritableRaster
object. This method will throw an IllegalArgumentException
if color component values for this ColorModel
are not
conveniently representable in the unnormalized form.
An ArrayIndexOutOfBoundsException
is thrown
if the components
array is not large enough to hold
all the color and alpha components (starting at
offset
). 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. Subclasses must
override this method since the implementation in this abstract
class throws an UnsupportedOperationException
.
components
- an array of unnormalized color and alpha
componentsoffset
- the index into components
at which to
begin retrieving color and alpha componentsobj
- the Object
representing an array of color
and alpha components
Object
representing an array of color and
alpha components.
ClassCastException
- if obj
is not a primitive array of type transferType
ArrayIndexOutOfBoundsException
- if
obj
is not large enough to hold a pixel value
for this ColorModel
or the components
array is not large enough to hold all of the color and alpha
components starting at offset
IllegalArgumentException
- if
component values for this ColorModel
are not
conveniently representable in the unnormalized form
UnsupportedOperationException
- if this
method is not supported by this ColorModel
WritableRaster.setDataElements(int, int, java.lang.Object)
,
SampleModel.setDataElements(int, int, java.lang.Object, java.awt.image.DataBuffer)
public int getDataElement(float[] normComponents, int normOffset)
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.
normComponents
- an array of normalized color and alpha
componentsnormOffset
- the index into normComponents
at which to
begin retrieving the color and alpha components
int
pixel value in this
ColorModel
corresponding to the specified components.
IllegalArgumentException
- if
pixel values for this ColorModel
are not
conveniently representable as a single int
ArrayIndexOutOfBoundsException
- if
the normComponents
array is not large enough to
hold all of the color and alpha components starting at
normOffset
public Object getDataElements(float[] normComponents, int normOffset, Object obj)
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.
normComponents
- an array of normalized color and alpha
componentsnormOffset
- the index into normComponents
at which to
begin retrieving color and alpha componentsobj
- a primitive data array to hold the returned pixel
Object
which is a primitive data array
representation of a pixel
ClassCastException
- if obj
is not a primitive array of type transferType
ArrayIndexOutOfBoundsException
- if
obj
is not large enough to hold a pixel value
for this ColorModel
or the normComponents
array is not large enough to hold all of the color and alpha
components starting at normOffset
WritableRaster.setDataElements(int, int, java.lang.Object)
,
SampleModel.setDataElements(int, int, java.lang.Object, java.awt.image.DataBuffer)
public float[] getNormalizedComponents(Object pixel, float[] normComponents, int normOffset)
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.
pixel
- the specified pixelnormComponents
- an array to receive the normalized componentsnormOffset
- the offset into the normComponents
array at which to start storing normalized components
ClassCastException
- if pixel
is not a primitive
array of type transferType
ArrayIndexOutOfBoundsException
- if
normComponents
is not large enough to hold all
color and alpha components starting at normOffset
ArrayIndexOutOfBoundsException
- if
pixel
is not large enough to hold a pixel
value for this ColorModel
.
UnsupportedOperationException
- if the
constructor of this ColorModel
called the
super(bits)
constructor, but did not
override this method. See the constructor,
ColorModel(int)
.
UnsupportedOperationException
- if this method is unable
to determine the number of bits per componentpublic boolean equals(Object obj)
Object
is an instance of
ColorModel
and if it equals this
ColorModel
.
equals
in class Object
obj
- the Object
to test for equality
true
if the specified Object
is an instance of ColorModel
and equals this
ColorModel
; false
otherwise.Object.hashCode()
,
Hashtable
public int hashCode()
hashCode
in class Object
Object.equals(java.lang.Object)
,
Hashtable
public final ColorSpace getColorSpace()
ColorSpace
associated with this
ColorModel
.
ColorSpace
of this
ColorModel
.public ColorModel coerceData(WritableRaster raster, boolean isAlphaPremultiplied)
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
.
raster
- the WritableRaster
dataisAlphaPremultiplied
- true
if the alpha is
premultiplied; false
otherwise
ColorModel
object that represents the
coerced data.public boolean isCompatibleRaster(Raster raster)
true
if raster
is compatible
with this ColorModel
and false
if it is
not.
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
.
raster
- the Raster
object to test for compatibility
true
if raster
is compatible
with this ColorModel
.
UnsupportedOperationException
- if this
method has not been implemented for this
ColorModel
public WritableRaster createCompatibleWritableRaster(int w, int h)
WritableRaster
with the specified width and
height that has a data layout (SampleModel
) compatible
with 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
.
w
- the width to apply to the new WritableRaster
h
- the height to apply to the new WritableRaster
WritableRaster
object with the specified
width and height.
UnsupportedOperationException
- if this
method is not supported by this ColorModel
WritableRaster
,
SampleModel
public SampleModel createCompatibleSampleModel(int w, int h)
SampleModel
with the specified width and
height that has a data layout compatible with 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
.
w
- the width to apply to the new SampleModel
h
- the height to apply to the new SampleModel
SampleModel
object with the specified
width and height.
UnsupportedOperationException
- if this
method is not supported by this ColorModel
SampleModel
public boolean isCompatibleSampleModel(SampleModel sm)
SampleModel
is compatible with 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
.
sm
- the specified SampleModel
true
if the specified SampleModel
is compatible with this ColorModel
; false
otherwise.
UnsupportedOperationException
- if this
method is not supported by this ColorModel
SampleModel
public void finalize()
ColorModel
once this ColorModel
is no
longer referenced.
finalize
in class Object
public WritableRaster getAlphaRaster(WritableRaster raster)
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
.
raster
- the specified Raster
Raster
representing the alpha channel of
an image, obtained from the specified Raster
.public String toString()
String
representation of the contents of
this ColorModel
object.
toString
in class Object
String
representing the contents of this
ColorModel
object.static int getDefaultTransferType(int pixel_bits)
static boolean isLinearRGBspace(ColorSpace cs)
static boolean isLinearGRAYspace(ColorSpace cs)
static byte[] getLinearRGB8TosRGB8LUT()
static byte[] getsRGB8ToLinearRGB8LUT()
static byte[] getLinearRGB16TosRGB8LUT()
static short[] getsRGB8ToLinearRGB16LUT()
static byte[] getGray8TosRGB8LUT(ICC_ColorSpace grayCS)
static byte[] getLinearGray16ToOtherGray8LUT(ICC_ColorSpace grayCS)
static byte[] getGray16TosRGB8LUT(ICC_ColorSpace grayCS)
static short[] getLinearGray16ToOtherGray16LUT(ICC_ColorSpace grayCS)
|
||||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |