ColorModelpublic abstract class ColorModel extends Object implements TransparencyThe 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 {@link BufferedImage} or {@link RenderedImage}
objects, based on {@link Raster} and {@link 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
{@link 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 {@link DirectColorModel} or {@link 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 {@link IllegalArgumentException} when methods involving
an unnormalized argument are called. Subclasses of ColorModel
must specify the conditions under which this occurs. |
| Fields Summary |
|---|
| private long | pData | | protected int | pixel_bitsThe total number of bits in the pixel. | | int[] | nBits | | int | transparency | | boolean | supportsAlpha | | boolean | isAlphaPremultiplied | | int | numComponents | | int | numColorComponents | | ColorSpace | colorSpace | | int | colorSpaceType | | int | maxBits | | boolean | is_sRGB | | protected int | transferTypeData type of the array used to represent pixel values. | | private static boolean | loadedThis 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. A number of classes in the
AWT package have a native method, initIDs(), which initializes
the JNI field and method ids used in the native portion of
their implementation.
Since the use and storage of these ids is done by the
implementation libraries, the implementation of these method is
provided by the particular AWT implementations (for example,
"Toolkit"s/Peer), such as Motif, Microsoft Windows, or Tiny. The
problem is that this means that the native libraries must be
loaded by the java.* classes, which do not necessarily know the
names of the libraries to load. A better way of doing this
would be to provide a separate library which defines java.awt.*
initIDs, and exports the relevant symbols out to the
implementation libraries.
For now, we know it's done by the implementation, and we assume
that the name of the library is "awt". -br. | | 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 |
| Constructors Summary |
|---|
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.
pixel_bits = bits;
if (bits < 1) {
throw new IllegalArgumentException("Number of bits must be > 0");
}
numComponents = 4;
numColorComponents = 3;
maxBits = bits;
// REMIND: make sure transferType is set correctly
transferType = ColorModel.getDefaultTransferType(bits);
| 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. 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.
colorSpace = cspace;
colorSpaceType = cspace.getType();
numColorComponents = cspace.getNumComponents();
numComponents = numColorComponents + (hasAlpha ? 1 : 0);
supportsAlpha = hasAlpha;
if (bits.length < numComponents) {
throw new IllegalArgumentException("Number of color/alpha "+
"components should be "+
numComponents+
" but length of bits array is "+
bits.length);
}
// 4186669
if (transparency < Transparency.OPAQUE ||
transparency > Transparency.TRANSLUCENT)
{
throw new IllegalArgumentException("Unknown transparency: "+
transparency);
}
if (supportsAlpha == false) {
this.isAlphaPremultiplied = false;
this.transparency = Transparency.OPAQUE;
}
else {
this.isAlphaPremultiplied = isAlphaPremultiplied;
this.transparency = transparency;
}
nBits = (int[]) bits.clone();
this.pixel_bits = pixel_bits;
if (pixel_bits <= 0) {
throw new IllegalArgumentException("Number of pixel bits must "+
"be > 0");
}
// Check for bits < 0
maxBits = 0;
for (int i=0; i < bits.length; i++) {
// bug 4304697
if (bits[i] < 0) {
throw new
IllegalArgumentException("Number of bits must be >= 0");
}
if (maxBits < bits[i]) {
maxBits = bits[i];
}
}
// Make sure that we don't have all 0-bit components
if (maxBits == 0) {
throw new IllegalArgumentException("There must be at least "+
"one component with > 0 "+
"pixel bits.");
}
// Save this since we always need to check if it is the default CS
if (cspace != ColorSpace.getInstance(ColorSpace.CS_sRGB)) {
is_sRGB = false;
}
// Save the transfer type
this.transferType = transferType;
|
| Methods Summary |
|---|
| public java.awt.image.ColorModel | coerceData(java.awt.image.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. 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.
throw new UnsupportedOperationException
("This method is not supported by this color model");
| | public java.awt.image.SampleModel | createCompatibleSampleModel(int w, int h)Creates a 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.
throw new UnsupportedOperationException
("This method is not supported by this color model");
| | public java.awt.image.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.
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.
throw new UnsupportedOperationException
("This method is not supported by this color model");
| | public boolean | equals(java.lang.Object obj)Tests if the specified Object is an instance of
ColorModel and if it equals this
ColorModel.
if (!(obj instanceof ColorModel)) {
return false;
}
ColorModel cm = (ColorModel) obj;
if (this == cm) {
return true;
}
if (supportsAlpha != cm.hasAlpha() ||
isAlphaPremultiplied != cm.isAlphaPremultiplied() ||
pixel_bits != cm.getPixelSize() ||
transparency != cm.getTransparency() ||
numComponents != cm.getNumComponents())
{
return false;
}
int[] nb = cm.getComponentSize();
if ((nBits != null) && (nb != null)) {
for (int i = 0; i < numComponents; i++) {
if (nBits[i] != nb[i]) {
return false;
}
}
} else {
return ((nBits == null) && (nb == null));
}
return true;
| | public void | finalize()Disposes of system resources associated with this
ColorModel once this ColorModel is no
longer referenced.
| | 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.
| | public int | getAlpha(java.lang.Object inData)Returns the alpha component for the specified pixel, scaled
from 0 to 255. The pixel value is specified by an array of data
elements of type transferType passed in as an object reference.
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.
int pixel=0,length=0;
switch (transferType) {
case DataBuffer.TYPE_BYTE:
byte bdata[] = (byte[])inData;
pixel = bdata[0] & 0xff;
length = bdata.length;
break;
case DataBuffer.TYPE_USHORT:
short sdata[] = (short[])inData;
pixel = sdata[0] & 0xffff;
length = sdata.length;
break;
case DataBuffer.TYPE_INT:
int idata[] = (int[])inData;
pixel = idata[0];
length = idata.length;
break;
default:
throw new UnsupportedOperationException("This method has not been "+
"implemented for transferType " + transferType);
}
if (length == 1) {
return getAlpha(pixel);
}
else {
throw new UnsupportedOperationException
("This method is not supported by this color model");
}
| | public java.awt.image.WritableRaster | getAlphaRaster(java.awt.image.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.
{@link 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.
return null;
| | 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.
| | public int | getBlue(java.lang.Object inData)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 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.
int pixel=0,length=0;
switch (transferType) {
case DataBuffer.TYPE_BYTE:
byte bdata[] = (byte[])inData;
pixel = bdata[0] & 0xff;
length = bdata.length;
break;
case DataBuffer.TYPE_USHORT:
short sdata[] = (short[])inData;
pixel = sdata[0] & 0xffff;
length = sdata.length;
break;
case DataBuffer.TYPE_INT:
int idata[] = (int[])inData;
pixel = idata[0];
length = idata.length;
break;
default:
throw new UnsupportedOperationException("This method has not been "+
"implemented for transferType " + transferType);
}
if (length == 1) {
return getBlue(pixel);
}
else {
throw new UnsupportedOperationException
("This method is not supported by this color model");
}
| | public final java.awt.color.ColorSpace | getColorSpace()Returns the ColorSpace associated with this
ColorModel.
return colorSpace;
| | 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.
// REMIND:
if (nBits == null) {
throw new NullPointerException("Number of bits array is null.");
}
return nBits[componentIdx];
| | public int[] | getComponentSize()Returns an array of the number of bits per color/alpha component.
The array contains the color components in the order specified by the
ColorSpace, followed by the alpha component, if
present.
if (nBits != null) {
return (int[]) nBits.clone();
}
return null;
| | public int[] | getComponents(int pixel, int[] components, int offset)Returns an array of unnormalized color/alpha components given a pixel
in this 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.
throw new UnsupportedOperationException
("This method is not supported by this color model.");
| | public int[] | getComponents(java.lang.Object pixel, int[] components, int offset)Returns an array of unnormalized color/alpha components given a pixel
in this 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.
throw new UnsupportedOperationException
("This method is not supported by this color model.");
| | public 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. 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.
throw new UnsupportedOperationException("This method is not supported "+
"by this color model.");
| | public 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. 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.
int components[] = getUnnormalizedComponents(normComponents,
normOffset, null, 0);
return getDataElement(components, 0);
| | public java.lang.Object | getDataElements(int rgb, java.lang.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.
This array can then be passed to the
{@link WritableRaster#setDataElements} method of
a {@link 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.
throw new UnsupportedOperationException
("This method is not supported by this color model.");
| | public java.lang.Object | getDataElements(int[] components, int offset, java.lang.Object obj)Returns a data element array representation of a pixel in this
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.
throw new UnsupportedOperationException("This method has not been implemented "+
"for this color model.");
| | public java.lang.Object | getDataElements(float[] normComponents, int normOffset, java.lang.Object obj)Returns a data element array representation of a pixel in this
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.
int components[] = getUnnormalizedComponents(normComponents,
normOffset, null, 0);
return getDataElements(components, 0, obj);
| | static int | getDefaultTransferType(int pixel_bits)
if (pixel_bits <= 8) {
return DataBuffer.TYPE_BYTE;
} else if (pixel_bits <= 16) {
return DataBuffer.TYPE_USHORT;
} else if (pixel_bits <= 32) {
return DataBuffer.TYPE_INT;
} else {
return DataBuffer.TYPE_UNDEFINED;
}
| | static byte[] | getGray16TosRGB8LUT(java.awt.color.ICC_ColorSpace grayCS)
if (isLinearGRAYspace(grayCS)) {
return getLinearRGB16TosRGB8LUT();
}
if (g16Tos8Map != null) {
byte[] g16Tos8LUT = (byte []) g16Tos8Map.get(grayCS);
if (g16Tos8LUT != null) {
return g16Tos8LUT;
}
}
short[] tmp = new short[65536];
for (int i = 0; i <= 65535; i++) {
tmp[i] = (short) i;
}
ICC_Transform[] transformList = new ICC_Transform[2];
ICC_ColorSpace srgbCS =
(ICC_ColorSpace) ColorSpace.getInstance(ColorSpace.CS_sRGB);
transformList[0] = new ICC_Transform (
grayCS.getProfile(), ICC_Transform.Any, ICC_Transform.In);
transformList[1] = new ICC_Transform (
srgbCS.getProfile(), ICC_Transform.Any, ICC_Transform.Out);
ICC_Transform t = new ICC_Transform(transformList);
tmp = t.colorConvert(tmp, null);
byte[] g16Tos8LUT = new byte[65536];
for (int i = 0, j= 2; i <= 65535; i++, j += 3) {
// All three components of tmp should be equal, since
// the input color space to colorConvert is a gray scale
// space. However, there are slight anomalies in the results.
// Copy tmp starting at index 2, since colorConvert seems
// to be slightly more accurate for the third component!
// scale unsigned short (0 - 65535) to unsigned byte (0 - 255)
g16Tos8LUT[i] =
(byte) (((float) (tmp[j] & 0xffff)) * (1.0f /257.0f) + 0.5f);
}
if (g16Tos8Map == null) {
g16Tos8Map = Collections.synchronizedMap(new WeakHashMap(2));
}
g16Tos8Map.put(grayCS, g16Tos8LUT);
return g16Tos8LUT;
| | static byte[] | getGray8TosRGB8LUT(java.awt.color.ICC_ColorSpace grayCS)
if (isLinearGRAYspace(grayCS)) {
return getLinearRGB8TosRGB8LUT();
}
if (g8Tos8Map != null) {
byte[] g8Tos8LUT = (byte []) g8Tos8Map.get(grayCS);
if (g8Tos8LUT != null) {
return g8Tos8LUT;
}
}
byte[] g8Tos8LUT = new byte[256];
for (int i = 0; i <= 255; i++) {
g8Tos8LUT[i] = (byte) i;
}
ICC_Transform[] transformList = new ICC_Transform[2];
ICC_ColorSpace srgbCS =
(ICC_ColorSpace) ColorSpace.getInstance(ColorSpace.CS_sRGB);
transformList[0] = new ICC_Transform (
grayCS.getProfile(), ICC_Transform.Any, ICC_Transform.In);
transformList[1] = new ICC_Transform (
srgbCS.getProfile(), ICC_Transform.Any, ICC_Transform.Out);
ICC_Transform t = new ICC_Transform(transformList);
byte[] tmp = t.colorConvert(g8Tos8LUT, null);
for (int i = 0, j= 2; i <= 255; i++, j += 3) {
// All three components of tmp should be equal, since
// the input color space to colorConvert is a gray scale
// space. However, there are slight anomalies in the results.
// Copy tmp starting at index 2, since colorConvert seems
// to be slightly more accurate for the third component!
g8Tos8LUT[i] = tmp[j];
}
if (g8Tos8Map == null) {
g8Tos8Map = Collections.synchronizedMap(new WeakHashMap(2));
}
g8Tos8Map.put(grayCS, g8Tos8LUT);
return g8Tos8LUT;
| | 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.
| | public int | getGreen(java.lang.Object inData)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 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.
int pixel=0,length=0;
switch (transferType) {
case DataBuffer.TYPE_BYTE:
byte bdata[] = (byte[])inData;
pixel = bdata[0] & 0xff;
length = bdata.length;
break;
case DataBuffer.TYPE_USHORT:
short sdata[] = (short[])inData;
pixel = sdata[0] & 0xffff;
length = sdata.length;
break;
case DataBuffer.TYPE_INT:
int idata[] = (int[])inData;
pixel = idata[0];
length = idata.length;
break;
default:
throw new UnsupportedOperationException("This method has not been "+
"implemented for transferType " + transferType);
}
if (length == 1) {
return getGreen(pixel);
}
else {
throw new UnsupportedOperationException
("This method is not supported by this color model");
}
| | static short[] | getLinearGray16ToOtherGray16LUT(java.awt.color.ICC_ColorSpace grayCS)
if (lg16Toog16Map != null) {
short[] lg16Toog16LUT = (short []) lg16Toog16Map.get(grayCS);
if (lg16Toog16LUT != null) {
return lg16Toog16LUT;
}
}
short[] tmp = new short[65536];
for (int i = 0; i <= 65535; i++) {
tmp[i] = (short) i;
}
ICC_Transform[] transformList = new ICC_Transform[2];
ICC_ColorSpace lgCS =
(ICC_ColorSpace) ColorSpace.getInstance(ColorSpace.CS_GRAY);
transformList[0] = new ICC_Transform (
lgCS.getProfile(), ICC_Transform.Any, ICC_Transform.In);
transformList[1] = new ICC_Transform (
grayCS.getProfile(), ICC_Transform.Any, ICC_Transform.Out);
ICC_Transform t = new ICC_Transform(transformList);
short[] lg16Toog16LUT = t.colorConvert(tmp, null);
if (lg16Toog16Map == null) {
lg16Toog16Map = Collections.synchronizedMap(new WeakHashMap(2));
}
lg16Toog16Map.put(grayCS, lg16Toog16LUT);
return lg16Toog16LUT;
| | static byte[] | getLinearGray16ToOtherGray8LUT(java.awt.color.ICC_ColorSpace grayCS)
if (lg16Toog8Map != null) {
byte[] lg16Toog8LUT = (byte []) lg16Toog8Map.get(grayCS);
if (lg16Toog8LUT != null) {
return lg16Toog8LUT;
}
}
short[] tmp = new short[65536];
for (int i = 0; i <= 65535; i++) {
tmp[i] = (short) i;
}
ICC_Transform[] transformList = new ICC_Transform[2];
ICC_ColorSpace lgCS =
(ICC_ColorSpace) ColorSpace.getInstance(ColorSpace.CS_GRAY);
transformList[0] = new ICC_Transform (
lgCS.getProfile(), ICC_Transform.Any, ICC_Transform.In);
transformList[1] = new ICC_Transform (
grayCS.getProfile(), ICC_Transform.Any, ICC_Transform.Out);
ICC_Transform t = new ICC_Transform(transformList);
tmp = t.colorConvert(tmp, null);
byte[] lg16Toog8LUT = new byte[65536];
for (int i = 0; i <= 65535; i++) {
// scale unsigned short (0 - 65535) to unsigned byte (0 - 255)
lg16Toog8LUT[i] =
(byte) (((float) (tmp[i] & 0xffff)) * (1.0f /257.0f) + 0.5f);
}
if (lg16Toog8Map == null) {
lg16Toog8Map = Collections.synchronizedMap(new WeakHashMap(2));
}
lg16Toog8Map.put(grayCS, lg16Toog8LUT);
return lg16Toog8LUT;
| | static byte[] | getLinearRGB16TosRGB8LUT()
if (l16Tos8 == null) {
l16Tos8 = new byte[65536];
float input, output;
// algorithm from IEC 61966-2-1 International Standard
for (int i = 0; i <= 65535; i++) {
input = ((float) i) / 65535.0f;
if (input <= 0.0031308f) {
output = input * 12.92f;
} else {
output = 1.055f * ((float) Math.pow(input, (1.0 / 2.4)))
- 0.055f;
}
l16Tos8[i] = (byte) Math.round(output * 255.0f);
}
}
return l16Tos8;
| | static byte[] | getLinearRGB8TosRGB8LUT()
if (l8Tos8 == null) {
l8Tos8 = new byte[256];
float input, output;
// algorithm for linear RGB to nonlinear sRGB conversion
// is from the IEC 61966-2-1 International Standard,
// Colour Management - Default RGB colour space - sRGB,
// First Edition, 1999-10,
// avaiable for order at http://www.iec.ch
for (int i = 0; i <= 255; i++) {
input = ((float) i) / 255.0f;
if (input <= 0.0031308f) {
output = input * 12.92f;
} else {
output = 1.055f * ((float) Math.pow(input, (1.0 / 2.4)))
- 0.055f;
}
l8Tos8[i] = (byte) Math.round(output * 255.0f);
}
}
return l8Tos8;
| | public 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. Unnormalized components
are unsigned integral values between 0 and 2n - 1, where
n is the number of bits for a particular component. Normalized
components are float values between a per component minimum and
maximum specified by the 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.
// Make sure that someone isn't using a custom color model
// that called the super(bits) constructor.
if (colorSpace == null) {
throw new UnsupportedOperationException("This method is not supported by "+
"this color model.");
}
if (nBits == null) {
throw new UnsupportedOperationException ("This method is not supported. "+
"Unable to determine #bits per "+
"component.");
}
if ((components.length - offset) < numComponents) {
throw new
IllegalArgumentException(
"Incorrect number of components. Expecting "+
numComponents);
}
if (normComponents == null) {
normComponents = new float[numComponents+normOffset];
}
if (supportsAlpha && isAlphaPremultiplied) {
// Normalized coordinates are non premultiplied
float normAlpha = (float)components[offset+numColorComponents];
normAlpha /= (float) ((1<<nBits[numColorComponents]) - 1);
if (normAlpha != 0.0f) {
for (int i=0; i < numColorComponents; i++) {
normComponents[normOffset+i] =
((float) components[offset+i]) /
(normAlpha * ((float) ((1<<nBits[i]) - 1)));
}
} else {
for (int i=0; i < numColorComponents; i++) {
normComponents[normOffset+i] = 0.0f;
}
}
normComponents[normOffset+numColorComponents] = normAlpha;
}
else {
for (int i=0; i < numComponents; i++) {
normComponents[normOffset+i] = ((float) components[offset+i]) /
((float) ((1<<nBits[i]) - 1));
}
}
return normComponents;
| | public float[] | getNormalizedComponents(java.lang.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. 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.
int components[] = getComponents(pixel, null, 0);
return getNormalizedComponents(components, 0,
normComponents, normOffset);
| | public int | getNumColorComponents()Returns the number of color components in this
ColorModel.
This is the number of components returned by
{@link ColorSpace#getNumComponents}.
return numColorComponents;
| | public int | getNumComponents()Returns the number of components, including alpha, in this
ColorModel. This is equal to the number of color
components, optionally plus one, if there is an alpha component.
return numComponents;
| | public int | getPixelSize()Returns the number of bits per pixel described by this
ColorModel.
return pixel_bits;
| | 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.
return (getAlpha(pixel) << 24)
| (getRed(pixel) << 16)
| (getGreen(pixel) << 8)
| (getBlue(pixel) << 0);
| | public int | getRGB(java.lang.Object inData)Returns the color/alpha components for the specified pixel in the
default RGB color model format. 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.
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.
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).
return (getAlpha(inData) << 24)
| (getRed(inData) << 16)
| (getGreen(inData) << 8)
| (getBlue(inData) << 0);
| | public static java.awt.image.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.
The color space is the default {@link 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.
if (RGBdefault == null) {
RGBdefault = new DirectColorModel(32,
0x00ff0000, // Red
0x0000ff00, // Green
0x000000ff, // Blue
0xff000000 // Alpha
);
}
return RGBdefault;
| | 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.
| | public int | getRed(java.lang.Object inData)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 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.
int pixel=0,length=0;
switch (transferType) {
case DataBuffer.TYPE_BYTE:
byte bdata[] = (byte[])inData;
pixel = bdata[0] & 0xff;
length = bdata.length;
break;
case DataBuffer.TYPE_USHORT:
short sdata[] = (short[])inData;
pixel = sdata[0] & 0xffff;
length = sdata.length;
break;
case DataBuffer.TYPE_INT:
int idata[] = (int[])inData;
pixel = idata[0];
length = idata.length;
break;
default:
throw new UnsupportedOperationException("This method has not been "+
"implemented for transferType " + transferType);
}
if (length == 1) {
return getRed(pixel);
}
else {
throw new UnsupportedOperationException
("This method is not supported by this color model");
}
| | 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.
return transferType;
| | public int | getTransparency()Returns the transparency. Returns either OPAQUE, BITMASK,
or TRANSLUCENT.
return transparency;
| | public 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. Unnormalized components
are unsigned integral values between 0 and 2n - 1, where
n is the number of bits for a particular component. Normalized
components are float values between a per component minimum and
maximum specified by the 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.
// Make sure that someone isn't using a custom color model
// that called the super(bits) constructor.
if (colorSpace == null) {
throw new UnsupportedOperationException("This method is not supported "+
"by this color model.");
}
if (nBits == null) {
throw new UnsupportedOperationException ("This method is not supported. "+
"Unable to determine #bits per "+
"component.");
}
if ((normComponents.length - normOffset) < numComponents) {
throw new
IllegalArgumentException(
"Incorrect number of components. Expecting "+
numComponents);
}
if (components == null) {
components = new int[offset+numComponents];
}
if (supportsAlpha && isAlphaPremultiplied) {
float normAlpha = normComponents[normOffset+numColorComponents];
for (int i=0; i < numColorComponents; i++) {
components[offset+i] = (int) (normComponents[normOffset+i]
* ((1<<nBits[i]) - 1)
* normAlpha + 0.5f);
}
components[offset+numColorComponents] = (int)
(normAlpha * ((1<<nBits[numColorComponents]) - 1) + 0.5f);
}
else {
for (int i=0; i < numComponents; i++) {
components[offset+i] = (int) (normComponents[normOffset+i]
* ((1<<nBits[i]) - 1) + 0.5f);
}
}
return components;
| | static short[] | getsRGB8ToLinearRGB16LUT()
if (s8Tol16 == null) {
s8Tol16 = new short[256];
float input, output;
// algorithm from IEC 61966-2-1 International Standard
for (int i = 0; i <= 255; i++) {
input = ((float) i) / 255.0f;
if (input <= 0.04045f) {
output = input / 12.92f;
} else {
output = (float) Math.pow((input + 0.055f) / 1.055f, 2.4);
}
s8Tol16[i] = (short) Math.round(output * 65535.0f);
}
}
return s8Tol16;
| | static byte[] | getsRGB8ToLinearRGB8LUT()
if (s8Tol8 == null) {
s8Tol8 = new byte[256];
float input, output;
// algorithm from IEC 61966-2-1 International Standard
for (int i = 0; i <= 255; i++) {
input = ((float) i) / 255.0f;
if (input <= 0.04045f) {
output = input / 12.92f;
} else {
output = (float) Math.pow((input + 0.055f) / 1.055f, 2.4);
}
s8Tol8[i] = (byte) Math.round(output * 255.0f);
}
}
return s8Tol8;
| | public final boolean | hasAlpha()Returns whether or not alpha is supported in this
ColorModel.
return supportsAlpha;
| | public int | hashCode()Returns the hash code for this ColorModel.
int result = 0;
result = (supportsAlpha ? 2 : 3) +
(isAlphaPremultiplied ? 4 : 5) +
pixel_bits * 6 +
transparency * 7 +
numComponents * 8;
if (nBits != null) {
for (int i = 0; i < numComponents; i++) {
result = result + nBits[i] * (i + 9);
}
}
return result;
| | private static native void | initIDs()
| | 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.
return isAlphaPremultiplied;
| | public boolean | isCompatibleRaster(java.awt.image.Raster raster)Returns 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.
throw new UnsupportedOperationException(
"This method has not been implemented for this ColorModel.");
| | public boolean | isCompatibleSampleModel(java.awt.image.SampleModel sm)Checks if the 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.
throw new UnsupportedOperationException
("This method is not supported by this color model");
| | static boolean | isLinearGRAYspace(java.awt.color.ColorSpace cs)
// Note: CMM.GRAYspace will be null if the linear
// gray space has not been created yet.
return (cs == CMM.GRAYspace);
| | static boolean | isLinearRGBspace(java.awt.color.ColorSpace cs) // 16-bit linear to 16-bit "other" gray
// Note: CMM.LINEAR_RGBspace will be null if the linear
// RGB space has not been created yet.
return (cs == CMM.LINEAR_RGBspace);
| | static void | loadLibraries()
if (!loaded) {
java.security.AccessController.doPrivileged(
new sun.security.action.LoadLibraryAction("awt"));
loaded = true;
}
| | public java.lang.String | toString()Returns the String representation of the contents of
this ColorModelobject.
return new String("ColorModel: #pixelBits = "+pixel_bits
+ " numComponents = "+numComponents
+ " color space = "+colorSpace
+ " transparency = "+transparency
+ " has alpha = "+supportsAlpha
+ " isAlphaPre = "+isAlphaPremultiplied
);
|
|
