/*
* Copyright (c) 1995, 2006, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package java.awt.image;
import java.awt.Transparency;
import java.awt.color.ColorSpace;
import java.awt.color.ICC_ColorSpace;
import sun.java2d.cmm.CMSManager;
import sun.java2d.cmm.ColorTransform;
import sun.java2d.cmm.PCMM;
import java.awt.Toolkit;
import java.util.Collections;
import java.util.Map;
import java.util.WeakHashMap;
/**
* The <code>ColorModel</code> 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
* <code>ColorModel</code> is specified by its <code>ColorSpace</code>.
* A <code>ColorModel</code> used with pixel data that does not include
* alpha information treats all pixels as opaque, which is an alpha
* value of 1.0.
* <p>
* This <code>ColorModel</code> 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 <code>byte</code> or single
* <code>int</code> values. For purposes of the <code>ColorModel</code>
* 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, <code>ColorModel</code> now has methods that accept
* pixel values represented as arrays of primitive types. The primitive
* type used by a particular <code>ColorModel</code> object is called its
* transfer type.
* <p>
* <code>ColorModel</code> 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 <code>ColorModel</code> must
* specify the conditions under which this occurs. This does not
* occur with {@link DirectColorModel} or {@link IndexColorModel} objects.
* <p>
* 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 <code>ColorModel</code> object is
* specified when the object is created, either explicitly or by default.
* All subclasses of <code>ColorModel</code> must specify what the
* possible transfer types are and how the number of elements in the
* primitive arrays representing pixels is determined.
* <p>
* For <code>BufferedImages</code>, the transfer type of its
* <code>Raster</code> and of the <code>Raster</code> object's
* <code>SampleModel</code> (available from the
* <code>getTransferType</code> methods of these classes) must match that
* of the <code>ColorModel</code>. The number of elements in an array
* representing a pixel for the <code>Raster</code> and
* <code>SampleModel</code> (available from the
* <code>getNumDataElements</code> methods of these classes) must match
* that of the <code>ColorModel</code>.
* <p>
* 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
* <code>SampleModel</code> of a <code>BufferedImage</code> object's
* <code>Raster</code> 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.
* <p>
* Methods in the <code>ColorModel</code> 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
* <code>float</code> 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 <code>ColorSpace</code> 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 <code>getMinValue</code> and
* <code>getMaxValue</code> methods of the <code>ColorSpace</code>
* class. Normalized color component values are not premultiplied.
* All <code>ColorModels</code> must support the normalized form.
* <p>
* In the unnormalized
* form, each component is an unsigned integral value between 0 and
* 2<sup>n</sup> - 1, where n is the number of significant bits for a
* particular component. If pixel values for a particular
* <code>ColorModel</code> represent color samples premultiplied by
* the alpha sample, unnormalized color component values are
* also premultiplied. The unnormalized form is used only with instances
* of <code>ColorModel</code> whose <code>ColorSpace</code> 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 <code>ColorModels</code> 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 2<sup>n</sup> - 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 <code>ColorModel</code>
* objects throw an {@link IllegalArgumentException} when methods involving
* an unnormalized argument are called. Subclasses of <code>ColorModel</code>
* must specify the conditions under which this occurs.
*
* @see IndexColorModel
* @see ComponentColorModel
* @see PackedColorModel
* @see DirectColorModel
* @see java.awt.Image
* @see BufferedImage
* @see RenderedImage
* @see java.awt.color.ColorSpace
* @see SampleModel
* @see Raster
* @see DataBuffer
*/
public abstract class ColorModel implements Transparency{
private long pData; // Placeholder for data for native functions
/**
* The total number of bits in the pixel.
*/
protected int pixel_bits;
int nBits[];
int transparency = Transparency.TRANSLUCENT;
boolean supportsAlpha = true;
boolean isAlphaPremultiplied = false;
int numComponents = -1;
int numColorComponents = -1;
ColorSpace colorSpace = ColorSpace.getInstance(ColorSpace.CS_sRGB);
int colorSpaceType = ColorSpace.TYPE_RGB;
int maxBits;
boolean is_sRGB = true;
/**
* Data type of the array used to represent pixel values.
*/
protected int transferType;
/**
* 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. 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 boolean loaded = false;
static void loadLibraries() {
if (!loaded) {
java.security.AccessController.doPrivileged(
new sun.security.action.LoadLibraryAction("awt"));
loaded = true;
}
}
private static native void initIDs();
static {
/* ensure that the proper libraries are loaded */
loadLibraries();
initIDs();
}
private static ColorModel RGBdefault;
/**
* Returns a <code>DirectColorModel</code> 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
* <code>ColorModel</code> for a particular device or for all images.
* It is merely used as a common color model format.
* @return a <code>DirectColorModel</code>object describing default
* RGB values.
*/
public static ColorModel getRGBdefault() {
if (RGBdefault == null) {
RGBdefault = new DirectColorModel(32,
0x00ff0000, // Red
0x0000ff00, // Green
0x000000ff, // Blue
0xff000000 // Alpha
);
}
return RGBdefault;
}
/**
* Constructs a <code>ColorModel</code> that translates pixels of the
* specified number of bits to color/alpha components. The color
* space is the default RGB <code>ColorSpace</code>, 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.
* @param bits the number of bits of a pixel
* @throws IllegalArgumentException if the number
* of bits in <code>bits</code> is less than 1
*/
public ColorModel(int bits) {
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);
}
/**
* Constructs a <code>ColorModel</code> that translates pixel values
* to color/alpha components. Color components will be in the
* specified <code>ColorSpace</code>. <code>pixel_bits</code> 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
* <code>ColorSpace</code> if there is no alpha information in the
* pixel values, or one more than this number if there is alpha
* information. <code>hasAlpha</code> indicates whether or not alpha
* information is present. The <code>boolean</code>
* <code>isAlphaPremultiplied</code> specifies how to interpret pixel
* values in which color and alpha information are represented as
* separate spatial bands. If the <code>boolean</code>
* is <code>true</code>, color samples are assumed to have been
* multiplied by the alpha sample. The <code>transparency</code>
* 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
* <code>IndexColorModel</code> with <code>pixel_bits</code> equal to
* 16, the bits array might have four elements with each element set
* to 8.
* @param pixel_bits the number of bits in the pixel values
* @param bits array that specifies the number of significant bits
* per color and alpha component
* @param cspace the specified <code>ColorSpace</code>
* @param hasAlpha <code>true</code> if alpha information is present;
* <code>false</code> otherwise
* @param isAlphaPremultiplied <code>true</code> if color samples are
* assumed to be premultiplied by the alpha samples;
* <code>false</code> otherwise
* @param transparency what alpha values can be represented by this
* color model
* @param transferType the type of the array used to represent pixel
* values
* @throws IllegalArgumentException if the length of
* the bit array is less than the number of color or alpha
* components in this <code>ColorModel</code>, or if the
* transparency is not a valid value.
* @throws IllegalArgumentException if the sum of the number
* of bits in <code>bits</code> is less than 1 or if
* any of the elements in <code>bits</code> is less than 0.
* @see java.awt.Transparency
*/
protected ColorModel(int pixel_bits, int[] bits, ColorSpace cspace,
boolean hasAlpha,
boolean isAlphaPremultiplied,
int transparency,
int transferType) {
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;
}
/**
* Returns whether or not alpha is supported in this
* <code>ColorModel</code>.
* @return <code>true</code> if alpha is supported in this
* <code>ColorModel</code>; <code>false</code> otherwise.
*/
final public boolean hasAlpha() {
return supportsAlpha;
}
/**
* Returns whether or not the alpha has been premultiplied in the
* pixel values to be translated by this <code>ColorModel</code>.
* If the boolean is <code>true</code>, this <code>ColorModel</code>
* 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 <code>true</code> if the alpha values are premultiplied
* in the pixel values to be translated by this
* <code>ColorModel</code>; <code>false</code> otherwise.
*/
final public boolean isAlphaPremultiplied() {
return isAlphaPremultiplied;
}
/**
* Returns the transfer type of this <code>ColorModel</code>.
* The transfer type is the type of primitive array used to represent
* pixel values as arrays.
* @return the transfer type.
* @since 1.3
*/
final public int getTransferType() {
return transferType;
}
/**
* Returns the number of bits per pixel described by this
* <code>ColorModel</code>.
* @return the number of bits per pixel.
*/
public int getPixelSize() {
return pixel_bits;
}
/**
* Returns the number of bits for the specified color/alpha component.
* Color components are indexed in the order specified by the
* <code>ColorSpace</code>. 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 <code>ColorModel</code> supports alpha, the alpha
* component corresponds to the index following the last color
* component.
* @param componentIdx the index of the color/alpha component
* @return the number of bits for the color/alpha component at the
* specified index.
* @throws ArrayIndexOutOfBoundsException if <code>componentIdx</code>
* is greater than the number of components or
* less than zero
* @throws NullPointerException if the number of bits array is
* <code>null</code>
*/
public int getComponentSize(int componentIdx) {
// REMIND:
if (nBits == null) {
throw new NullPointerException("Number of bits array is null.");
}
return nBits[componentIdx];
}
/**
* Returns an array of the number of bits per color/alpha component.
* The array contains the color components in the order specified by the
* <code>ColorSpace</code>, followed by the alpha component, if
* present.
* @return an array of the number of bits per color/alpha component
*/
public int[] getComponentSize() {
if (nBits != null) {
return (int[]) nBits.clone();
}
return null;
}
/**
* Returns the transparency. Returns either OPAQUE, BITMASK,
* or TRANSLUCENT.
* @return the transparency of this <code>ColorModel</code>.
* @see Transparency#OPAQUE
* @see Transparency#BITMASK
* @see Transparency#TRANSLUCENT
*/
public int getTransparency() {
return transparency;
}
/**
* Returns the number of components, including alpha, in this
* <code>ColorModel</code>. This is equal to the number of color
* components, optionally plus one, if there is an alpha component.
* @return the number of components in this <code>ColorModel</code>
*/
public int getNumComponents() {
return numComponents;
}
/**
* Returns the number of color components in this
* <code>ColorModel</code>.
* This is the number of components returned by
* {@link ColorSpace#getNumComponents}.
* @return the number of color components in this
* <code>ColorModel</code>.
* @see ColorSpace#getNumComponents
*/
public int getNumColorComponents() {
return numColorComponents;
}
/**
* 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 <code>IllegalArgumentException</code> is thrown if pixel
* values for this <code>ColorModel</code> 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.
* @param pixel a specified pixel
* @return the value of the red component of the specified pixel.
*/
public abstract int getRed(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 <code>IllegalArgumentException</code> is thrown if pixel
* values for this <code>ColorModel</code> 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.
* @param pixel the specified pixel
* @return the value of the green component of the specified pixel.
*/
public abstract int getGreen(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 <code>IllegalArgumentException</code> is thrown if pixel values
* for this <code>ColorModel</code> 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.
* @param pixel the specified pixel
* @return the value of the blue component of the specified pixel.
*/
public abstract int getBlue(int pixel);
/**
* Returns the alpha component for the specified pixel, scaled
* from 0 to 255. The pixel value is specified as an int.
* An <code>IllegalArgumentException</code> is thrown if pixel
* values for this <code>ColorModel</code> are not conveniently
* representable as a single int.
* @param pixel the specified pixel
* @return the value of alpha component of the specified pixel.
*/
public abstract int getAlpha(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 <code>IllegalArgumentException</code> thrown if pixel values
* for this <code>ColorModel</code> 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.
* @param pixel the specified pixel
* @return the RGB value of the color/alpha components of the
* specified pixel.
* @see ColorModel#getRGBdefault
*/
public int getRGB(int pixel) {
return (getAlpha(pixel) << 24)
| (getRed(pixel) << 16)
| (getGreen(pixel) << 8)
| (getBlue(pixel) << 0);
}
/**
* Returns the red color component for the specified pixel, scaled
* from 0 to 255 in the default RGB <code>ColorSpace</code>, 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 <code>inData</code> is not a primitive array of type
* transferType, a <code>ClassCastException</code> is thrown. An
* <code>ArrayIndexOutOfBoundsException</code> is thrown if
* <code>inData</code> is not large enough to hold a pixel value for
* this <code>ColorModel</code>.
* If this <code>transferType</code> is not supported, a
* <code>UnsupportedOperationException</code> will be
* thrown. Since
* <code>ColorModel</code> 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
* <code>transferType</code> other than
* <code>DataBuffer.TYPE_BYTE</code>,
* <code>DataBuffer.TYPE_USHORT</code>, or
* <code>DataBuffer.TYPE_INT</code>.
* @param inData an array of pixel values
* @return the value of the red component of the specified pixel.
* @throws ClassCastException if <code>inData</code>
* is not a primitive array of type <code>transferType</code>
* @throws ArrayIndexOutOfBoundsException if
* <code>inData</code> is not large enough to hold a pixel value
* for this <code>ColorModel</code>
* @throws UnsupportedOperationException if this
* <code>tranferType</code> is not supported by this
* <code>ColorModel</code>
*/
public int getRed(Object inData) {
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");
}
}
/**
* Returns the green color component for the specified pixel, scaled
* from 0 to 255 in the default RGB <code>ColorSpace</code>, 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 <code>inData</code> is
* not a primitive array of type transferType, a
* <code>ClassCastException</code> is thrown. An
* <code>ArrayIndexOutOfBoundsException</code> is thrown if
* <code>inData</code> is not large enough to hold a pixel value for
* this <code>ColorModel</code>.
* If this <code>transferType</code> is not supported, a
* <code>UnsupportedOperationException</code> will be
* thrown. Since
* <code>ColorModel</code> 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
* <code>transferType</code> other than
* <code>DataBuffer.TYPE_BYTE</code>,
* <code>DataBuffer.TYPE_USHORT</code>, or
* <code>DataBuffer.TYPE_INT</code>.
* @param inData an array of pixel values
* @return the value of the green component of the specified pixel.
* @throws <code>ClassCastException</code> if <code>inData</code>
* is not a primitive array of type <code>transferType</code>
* @throws <code>ArrayIndexOutOfBoundsException</code> if
* <code>inData</code> is not large enough to hold a pixel value
* for this <code>ColorModel</code>
* @throws <code>UnsupportedOperationException</code> if this
* <code>tranferType</code> is not supported by this
* <code>ColorModel</code>
*/
public int getGreen(Object inData) {
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");
}
}
/**
* Returns the blue color component for the specified pixel, scaled
* from 0 to 255 in the default RGB <code>ColorSpace</code>, 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
* <code>inData</code> is not a primitive array of type transferType,
* a <code>ClassCastException</code> is thrown. An
* <code>ArrayIndexOutOfBoundsException</code> is
* thrown if <code>inData</code> is not large enough to hold a pixel
* value for this <code>ColorModel</code>.
* If this <code>transferType</code> is not supported, a
* <code>UnsupportedOperationException</code> will be
* thrown. Since
* <code>ColorModel</code> 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
* <code>transferType</code> other than
* <code>DataBuffer.TYPE_BYTE</code>,
* <code>DataBuffer.TYPE_USHORT</code>, or
* <code>DataBuffer.TYPE_INT</code>.
* @param inData an array of pixel values
* @return the value of the blue component of the specified pixel.
* @throws ClassCastException if <code>inData</code>
* is not a primitive array of type <code>transferType</code>
* @throws ArrayIndexOutOfBoundsException if
* <code>inData</code> is not large enough to hold a pixel value
* for this <code>ColorModel</code>
* @throws UnsupportedOperationException if this
* <code>tranferType</code> is not supported by this
* <code>ColorModel</code>
*/
public int getBlue(Object inData) {
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");
}
}
/**
* 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
* <code>ClassCastException</code> is thrown. An
* <code>ArrayIndexOutOfBoundsException</code> is thrown if
* <code>inData</code> is not large enough to hold a pixel value for
* this <code>ColorModel</code>.
* If this <code>transferType</code> is not supported, a
* <code>UnsupportedOperationException</code> will be
* thrown. Since
* <code>ColorModel</code> 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
* <code>transferType</code> other than
* <code>DataBuffer.TYPE_BYTE</code>,
* <code>DataBuffer.TYPE_USHORT</code>, or
* <code>DataBuffer.TYPE_INT</code>.
* @param inData the specified pixel
* @return the alpha component of the specified pixel, scaled from
* 0 to 255.
* @throws ClassCastException if <code>inData</code>
* is not a primitive array of type <code>transferType</code>
* @throws ArrayIndexOutOfBoundsException if
* <code>inData</code> is not large enough to hold a pixel value
* for this <code>ColorModel</code>
* @throws UnsupportedOperationException if this
* <code>tranferType</code> is not supported by this
* <code>ColorModel</code>
*/
public int getAlpha(Object inData) {
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");
}
}
/**
* 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
* <code>ClassCastException</code> is thrown. An
* <code>ArrayIndexOutOfBoundsException</code> is
* thrown if <code>inData</code> is not large enough to hold a pixel
* value for this <code>ColorModel</code>.
* 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).
* @param inData the specified pixel
* @return the color and alpha components of the specified pixel.
* @see ColorModel#getRGBdefault
*/
public int getRGB(Object inData) {
return (getAlpha(inData) << 24)
| (getRed(inData) << 16)
| (getGreen(inData) << 8)
| (getBlue(inData) << 0);
}
/**
* Returns a data element array representation of a pixel in this
* <code>ColorModel</code>, 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
* <code>null</code>, a new array will be allocated. If
* <code>pixel</code> is not
* <code>null</code>, it must be a primitive array of type
* <code>transferType</code>; otherwise, a
* <code>ClassCastException</code> is thrown. An
* <code>ArrayIndexOutOfBoundsException</code> is thrown if
* <code>pixel</code> is
* not large enough to hold a pixel value for this
* <code>ColorModel</code>. The pixel array is returned.
* If this <code>transferType</code> is not supported, a
* <code>UnsupportedOperationException</code> will be
* thrown. Since <code>ColorModel</code> 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 <code>UnsupportedOperationException</code>.
* @param rgb the integer pixel representation in the default RGB
* color model
* @param pixel the specified pixel
* @return an array representation of the specified pixel in this
* <code>ColorModel</code>.
* @throws ClassCastException if <code>pixel</code>
* is not a primitive array of type <code>transferType</code>
* @throws ArrayIndexOutOfBoundsException if
* <code>pixel</code> is not large enough to hold a pixel value
* for this <code>ColorModel</code>
* @throws UnsupportedOperationException if this
* method is not supported by this <code>ColorModel</code>
* @see WritableRaster#setDataElements
* @see SampleModel#setDataElements
*/
public Object getDataElements(int rgb, Object pixel) {
throw new UnsupportedOperationException
("This method is not supported by this color model.");
}
/**
* Returns an array of unnormalized color/alpha components given a pixel
* in this <code>ColorModel</code>. The pixel value is specified as
* an <code>int</code>. An <code>IllegalArgumentException</code>
* will be thrown if pixel values for this <code>ColorModel</code> are
* not conveniently representable as a single <code>int</code> or if
* color component values for this <code>ColorModel</code> 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
* <code>DirectColorModel</code>. If the components array is
* <code>null</code>, a new array will be allocated. The
* components array will be returned. Color/alpha components are
* stored in the components array starting at <code>offset</code>
* (even if the array is allocated by this method). An
* <code>ArrayIndexOutOfBoundsException</code> is thrown if the
* components array is not <code>null</code> and is not large
* enough to hold all the color and alpha components (starting at offset).
* Since <code>ColorModel</code> 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 <code>UnsupportedOperationException</code>.
* @param pixel the specified pixel
* @param components the array to receive the color and alpha
* components of the specified pixel
* @param offset the offset into the <code>components</code> array at
* which to start storing the color and alpha components
* @return an array containing the color and alpha components of the
* specified pixel starting at the specified offset.
* @throws UnsupportedOperationException if this
* method is not supported by this <code>ColorModel</code>
*/
public int[] getComponents(int pixel, int[] components, int offset) {
throw new UnsupportedOperationException
("This method is not supported by this color model.");
}
/**
* Returns an array of unnormalized color/alpha components given a pixel
* in this <code>ColorModel</code>. The pixel value is specified by
* an array of data elements of type transferType passed in as an
* object reference. If <code>pixel</code> is not a primitive array
* of type transferType, a <code>ClassCastException</code> is thrown.
* An <code>IllegalArgumentException</code> will be thrown if color
* component values for this <code>ColorModel</code> are not
* conveniently representable in the unnormalized form.
* An <code>ArrayIndexOutOfBoundsException</code> is
* thrown if <code>pixel</code> is not large enough to hold a pixel
* value for this <code>ColorModel</code>.
* This method can be used to retrieve the components for a specific
* pixel value in any <code>ColorModel</code>. If the components
* array is <code>null</code>, a new array will be allocated. The
* components array will be returned. Color/alpha components are
* stored in the <code>components</code> array starting at
* <code>offset</code> (even if the array is allocated by this
* method). An <code>ArrayIndexOutOfBoundsException</code>
* is thrown if the components array is not <code>null</code> and is
* not large enough to hold all the color and alpha components
* (starting at <code>offset</code>).
* Since <code>ColorModel</code> 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 <code>UnsupportedOperationException</code>.
* @param pixel the specified pixel
* @param components an array that receives the color and alpha
* components of the specified pixel
* @param offset the index into the <code>components</code> array at
* which to begin storing the color and alpha components of the
* specified pixel
* @return an array containing the color and alpha components of the
* specified pixel starting at the specified offset.
* @throws UnsupportedOperationException if this
* method is not supported by this <code>ColorModel</code>
*/
public int[] getComponents(Object pixel, int[] components, int offset) {
throw new UnsupportedOperationException
("This method is not supported by this color model.");
}
/**
* 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 2<sup>n</sup> - 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 <code>ColorSpace</code> object for this
* <code>ColorModel</code>. An <code>IllegalArgumentException</code>
* will be thrown if color component values for this
* <code>ColorModel</code> are not conveniently representable in the
* unnormalized form. If the
* <code>components</code> array is <code>null</code>, a new array
* will be allocated. The <code>components</code> array will
* be returned. Color/alpha components are stored in the
* <code>components</code> array starting at <code>offset</code> (even
* if the array is allocated by this method). An
* <code>ArrayIndexOutOfBoundsException</code> is thrown if the
* <code>components</code> array is not <code>null</code> and is not
* large enough to hold all the color and alpha
* components (starting at <code>offset</code>). An
* <code>IllegalArgumentException</code> is thrown if the
* <code>normComponents</code> array is not large enough to hold
* all the color and alpha components starting at
* <code>normOffset</code>.
* @param normComponents an array containing normalized components
* @param normOffset the offset into the <code>normComponents</code>
* array at which to start retrieving normalized components
* @param components an array that receives the components from
* <code>normComponents</code>
* @param offset the index into <code>components</code> at which to
* begin storing normalized components from
* <code>normComponents</code>
* @return an array containing unnormalized color and alpha
* components.
* @throws IllegalArgumentException If the component values for this
* <CODE>ColorModel</CODE> are not conveniently representable in the
* unnormalized form.
* @throws IllegalArgumentException if the length of
* <code>normComponents</code> minus <code>normOffset</code>
* is less than <code>numComponents</code>
* @throws UnsupportedOperationException if the
* constructor of this <code>ColorModel</code> called the
* <code>super(bits)</code> constructor, but did not
* override this method. See the constructor,
* {@link #ColorModel(int)}.
*/
public int[] getUnnormalizedComponents(float[] normComponents,
int normOffset,
int[] components, int offset) {
// 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;
}
/**
* 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 2<sup>n</sup> - 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 <code>ColorSpace</code> object for this
* <code>ColorModel</code>. An <code>IllegalArgumentException</code>
* will be thrown if color component values for this
* <code>ColorModel</code> are not conveniently representable in the
* unnormalized form. If the
* <code>normComponents</code> array is <code>null</code>, a new array
* will be allocated. The <code>normComponents</code> array
* will be returned. Color/alpha components are stored in the
* <code>normComponents</code> array starting at
* <code>normOffset</code> (even if the array is allocated by this
* method). An <code>ArrayIndexOutOfBoundsException</code> is thrown
* if the <code>normComponents</code> array is not <code>null</code>
* and is not large enough to hold all the color and alpha components
* (starting at <code>normOffset</code>). An
* <code>IllegalArgumentException</code> is thrown if the
* <code>components</code> array is not large enough to hold all the
* color and alpha components starting at <code>offset</code>.
* <p>
* Since <code>ColorModel</code> 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.
* @param components an array containing unnormalized components
* @param offset the offset into the <code>components</code> array at
* which to start retrieving unnormalized components
* @param normComponents an array that receives the normalized components
* @param normOffset the index into <code>normComponents</code> at
* which to begin storing normalized components
* @return an array containing normalized color and alpha
* components.
* @throws IllegalArgumentException If the component values for this
* <CODE>ColorModel</CODE> are not conveniently representable in the
* unnormalized form.
* @throws UnsupportedOperationException if the
* constructor of this <code>ColorModel</code> called the
* <code>super(bits)</code> constructor, but did not
* override this method. See the constructor,
* {@link #ColorModel(int)}.
* @throws UnsupportedOperationException if this method is unable
* to determine the number of bits per component
*/
public float[] getNormalizedComponents(int[] components, int offset,
float[] normComponents,
int 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 ((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;
}
/**
* Returns a pixel value represented as an <code>int</code> in this
* <code>ColorModel</code>, given an array of unnormalized color/alpha
* components. This method will throw an
* <code>IllegalArgumentException</code> if component values for this
* <code>ColorModel</code> are not conveniently representable as a
* single <code>int</code> or if color component values for this
* <code>ColorModel</code> are not conveniently representable in the
* unnormalized form. An
* <code>ArrayIndexOutOfBoundsException</code> is thrown if the
* <code>components</code> array is not large enough to hold all the
* color and alpha components (starting at <code>offset</code>).
* Since <code>ColorModel</code> 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 <code>UnsupportedOperationException</code>.
* @param components an array of unnormalized color and alpha
* components
* @param offset the index into <code>components</code> at which to
* begin retrieving the color and alpha components
* @return an <code>int</code> pixel value in this
* <code>ColorModel</code> corresponding to the specified components.
* @throws IllegalArgumentException if
* pixel values for this <code>ColorModel</code> are not
* conveniently representable as a single <code>int</code>
* @throws IllegalArgumentException if
* component values for this <code>ColorModel</code> are not
* conveniently representable in the unnormalized form
* @throws ArrayIndexOutOfBoundsException if
* the <code>components</code> array is not large enough to
* hold all of the color and alpha components starting at
* <code>offset</code>
* @throws UnsupportedOperationException if this
* method is not supported by this <code>ColorModel</code>
*/
public int getDataElement(int[] components, int offset) {
throw new UnsupportedOperationException("This method is not supported "+
"by this color model.");
}
/**
* Returns a data element array representation of a pixel in this
* <code>ColorModel</code>, given an array of unnormalized color/alpha
* components. This array can then be passed to the
* <code>setDataElements</code> method of a <code>WritableRaster</code>
* object. This method will throw an <code>IllegalArgumentException</code>
* if color component values for this <code>ColorModel</code> are not
* conveniently representable in the unnormalized form.
* An <code>ArrayIndexOutOfBoundsException</code> is thrown
* if the <code>components</code> array is not large enough to hold
* all the color and alpha components (starting at
* <code>offset</code>). If the <code>obj</code> variable is
* <code>null</code>, a new array will be allocated. If
* <code>obj</code> is not <code>null</code>, it must be a primitive
* array of type transferType; otherwise, a
* <code>ClassCastException</code> is thrown. An
* <code>ArrayIndexOutOfBoundsException</code> is thrown if
* <code>obj</code> is not large enough to hold a pixel value for this
* <code>ColorModel</code>.
* Since <code>ColorModel</code> 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 <code>UnsupportedOperationException</code>.
* @param components an array of unnormalized color and alpha
* components
* @param offset the index into <code>components</code> at which to
* begin retrieving color and alpha components
* @param obj the <code>Object</code> representing an array of color
* and alpha components
* @return an <code>Object</code> representing an array of color and
* alpha components.
* @throws ClassCastException if <code>obj</code>
* is not a primitive array of type <code>transferType</code>
* @throws ArrayIndexOutOfBoundsException if
* <code>obj</code> is not large enough to hold a pixel value
* for this <code>ColorModel</code> or the <code>components</code>
* array is not large enough to hold all of the color and alpha
* components starting at <code>offset</code>
* @throws IllegalArgumentException if
* component values for this <code>ColorModel</code> are not
* conveniently representable in the unnormalized form
* @throws UnsupportedOperationException if this
* method is not supported by this <code>ColorModel</code>
* @see WritableRaster#setDataElements
* @see SampleModel#setDataElements
*/
public Object getDataElements(int[] components, int offset, Object obj) {
throw new UnsupportedOperationException("This method has not been implemented "+
"for this color model.");
}
/**
* Returns a pixel value represented as an <code>int</code> in this
* <code>ColorModel</code>, given an array of normalized color/alpha
* components. This method will throw an
* <code>IllegalArgumentException</code> if pixel values for this
* <code>ColorModel</code> are not conveniently representable as a
* single <code>int</code>. An
* <code>ArrayIndexOutOfBoundsException</code> is thrown if the
* <code>normComponents</code> array is not large enough to hold all the
* color and alpha components (starting at <code>normOffset</code>).
* Since <code>ColorModel</code> 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
* <code>getDataElement(int[], int)</code>. Subclasses which may
* have instances which do not support the unnormalized form must
* override this method.
* @param normComponents an array of normalized color and alpha
* components
* @param normOffset the index into <code>normComponents</code> at which to
* begin retrieving the color and alpha components
* @return an <code>int</code> pixel value in this
* <code>ColorModel</code> corresponding to the specified components.
* @throws IllegalArgumentException if
* pixel values for this <code>ColorModel</code> are not
* conveniently representable as a single <code>int</code>
* @throws ArrayIndexOutOfBoundsException if
* the <code>normComponents</code> array is not large enough to
* hold all of the color and alpha components starting at
* <code>normOffset</code>
* @since 1.4
*/
public int getDataElement(float[] normComponents, int normOffset) {
int components[] = getUnnormalizedComponents(normComponents,
normOffset, null, 0);
return getDataElement(components, 0);
}
/**
* Returns a data element array representation of a pixel in this
* <code>ColorModel</code>, given an array of normalized color/alpha
* components. This array can then be passed to the
* <code>setDataElements</code> method of a <code>WritableRaster</code>
* object. An <code>ArrayIndexOutOfBoundsException</code> is thrown
* if the <code>normComponents</code> array is not large enough to hold
* all the color and alpha components (starting at
* <code>normOffset</code>). If the <code>obj</code> variable is
* <code>null</code>, a new array will be allocated. If
* <code>obj</code> is not <code>null</code>, it must be a primitive
* array of type transferType; otherwise, a
* <code>ClassCastException</code> is thrown. An
* <code>ArrayIndexOutOfBoundsException</code> is thrown if
* <code>obj</code> is not large enough to hold a pixel value for this
* <code>ColorModel</code>.
* Since <code>ColorModel</code> 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
* <code>getDataElement(int[], int, Object)</code>. Subclasses which may
* have instances which do not support the unnormalized form must
* override this method.
* @param normComponents an array of normalized color and alpha
* components
* @param normOffset the index into <code>normComponents</code> at which to
* begin retrieving color and alpha components
* @param obj a primitive data array to hold the returned pixel
* @return an <code>Object</code> which is a primitive data array
* representation of a pixel
* @throws ClassCastException if <code>obj</code>
* is not a primitive array of type <code>transferType</code>
* @throws ArrayIndexOutOfBoundsException if
* <code>obj</code> is not large enough to hold a pixel value
* for this <code>ColorModel</code> or the <code>normComponents</code>
* array is not large enough to hold all of the color and alpha
* components starting at <code>normOffset</code>
* @see WritableRaster#setDataElements
* @see SampleModel#setDataElements
* @since 1.4
*/
public Object getDataElements(float[] normComponents, int normOffset,
Object obj) {
int components[] = getUnnormalizedComponents(normComponents,
normOffset, null, 0);
return getDataElements(components, 0, obj);
}
/**
* Returns an array of all of the color/alpha components in normalized
* form, given a pixel in this <code>ColorModel</code>. 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 <code>ClassCastException</code> is thrown.
* An <code>ArrayIndexOutOfBoundsException</code> is thrown if
* <code>pixel</code> is not large enough to hold a pixel value for this
* <code>ColorModel</code>.
* Normalized components are float values between a per component minimum
* and maximum specified by the <code>ColorSpace</code> object for this
* <code>ColorModel</code>. If the
* <code>normComponents</code> array is <code>null</code>, a new array
* will be allocated. The <code>normComponents</code> array
* will be returned. Color/alpha components are stored in the
* <code>normComponents</code> array starting at
* <code>normOffset</code> (even if the array is allocated by this
* method). An <code>ArrayIndexOutOfBoundsException</code> is thrown
* if the <code>normComponents</code> array is not <code>null</code>
* and is not large enough to hold all the color and alpha components
* (starting at <code>normOffset</code>).
* Since <code>ColorModel</code> 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
* <code>getComponents(Object, int[], int)</code> and then calls
* <code>getNormalizedComponents(int[], int, float[], int)</code>.
* Subclasses which may
* have instances which do not support the unnormalized form must
* override this method.
* @param pixel the specified pixel
* @param normComponents an array to receive the normalized components
* @param normOffset the offset into the <code>normComponents</code>
* array at which to start storing normalized components
* @return an array containing normalized color and alpha
* components.
* @throws ClassCastException if <code>pixel</code> is not a primitive
* array of type transferType
* @throws ArrayIndexOutOfBoundsException if
* <code>normComponents</code> is not large enough to hold all
* color and alpha components starting at <code>normOffset</code>
* @throws ArrayIndexOutOfBoundsException if
* <code>pixel</code> is not large enough to hold a pixel
* value for this <code>ColorModel</code>.
* @throws UnsupportedOperationException if the
* constructor of this <code>ColorModel</code> called the
* <code>super(bits)</code> constructor, but did not
* override this method. See the constructor,
* {@link #ColorModel(int)}.
* @throws UnsupportedOperationException if this method is unable
* to determine the number of bits per component
* @since 1.4
*/
public float[] getNormalizedComponents(Object pixel,
float[] normComponents,
int normOffset) {
int components[] = getComponents(pixel, null, 0);
return getNormalizedComponents(components, 0,
normComponents, normOffset);
}
/**
* Tests if the specified <code>Object</code> is an instance of
* <code>ColorModel</code> and if it equals this
* <code>ColorModel</code>.
* @param obj the <code>Object</code> to test for equality
* @return <code>true</code> if the specified <code>Object</code>
* is an instance of <code>ColorModel</code> and equals this
* <code>ColorModel</code>; <code>false</code> otherwise.
*/
public boolean equals(Object obj) {
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;
}
/**
* Returns the hash code for this ColorModel.
*
* @return a hash code for this ColorModel.
*/
public int hashCode() {
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;
}
/**
* Returns the <code>ColorSpace</code> associated with this
* <code>ColorModel</code>.
* @return the <code>ColorSpace</code> of this
* <code>ColorModel</code>.
*/
final public ColorSpace getColorSpace() {
return colorSpace;
}
/**
* Forces the raster data to match the state specified in the
* <code>isAlphaPremultiplied</code> variable, assuming the data is
* currently correctly described by this <code>ColorModel</code>. 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
* <code>ColorModel</code> with the <code>isAlphaPremultiplied</code>
* flag set appropriately. This method will throw a
* <code>UnsupportedOperationException</code> if it is not supported
* by this <code>ColorModel</code>.
* Since <code>ColorModel</code> 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 <code>UnsupportedOperationException</code>.
* @param raster the <code>WritableRaster</code> data
* @param isAlphaPremultiplied <code>true</code> if the alpha is
* premultiplied; <code>false</code> otherwise
* @return a <code>ColorModel</code> object that represents the
* coerced data.
*/
public ColorModel coerceData (WritableRaster raster,
boolean isAlphaPremultiplied) {
throw new UnsupportedOperationException
("This method is not supported by this color model");
}
/**
* Returns <code>true</code> if <code>raster</code> is compatible
* with this <code>ColorModel</code> and <code>false</code> if it is
* not.
* Since <code>ColorModel</code> 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 <code>UnsupportedOperationException</code>.
* @param raster the {@link Raster} object to test for compatibility
* @return <code>true</code> if <code>raster</code> is compatible
* with this <code>ColorModel</code>.
* @throws UnsupportedOperationException if this
* method has not been implemented for this
* <code>ColorModel</code>
*/
public boolean isCompatibleRaster(Raster raster) {
throw new UnsupportedOperationException(
"This method has not been implemented for this ColorModel.");
}
/**
* Creates a <code>WritableRaster</code> with the specified width and
* height that has a data layout (<code>SampleModel</code>) compatible
* with this <code>ColorModel</code>.
* Since <code>ColorModel</code> 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 <code>UnsupportedOperationException</code>.
* @param w the width to apply to the new <code>WritableRaster</code>
* @param h the height to apply to the new <code>WritableRaster</code>
* @return a <code>WritableRaster</code> object with the specified
* width and height.
* @throws UnsupportedOperationException if this
* method is not supported by this <code>ColorModel</code>
* @see WritableRaster
* @see SampleModel
*/
public WritableRaster createCompatibleWritableRaster(int w, int h) {
throw new UnsupportedOperationException
("This method is not supported by this color model");
}
/**
* Creates a <code>SampleModel</code> with the specified width and
* height that has a data layout compatible with this
* <code>ColorModel</code>.
* Since <code>ColorModel</code> 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 <code>UnsupportedOperationException</code>.
* @param w the width to apply to the new <code>SampleModel</code>
* @param h the height to apply to the new <code>SampleModel</code>
* @return a <code>SampleModel</code> object with the specified
* width and height.
* @throws UnsupportedOperationException if this
* method is not supported by this <code>ColorModel</code>
* @see SampleModel
*/
public SampleModel createCompatibleSampleModel(int w, int h) {
throw new UnsupportedOperationException
("This method is not supported by this color model");
}
/** Checks if the <code>SampleModel</code> is compatible with this
* <code>ColorModel</code>.
* Since <code>ColorModel</code> 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 <code>UnsupportedOperationException</code>.
* @param sm the specified <code>SampleModel</code>
* @return <code>true</code> if the specified <code>SampleModel</code>
* is compatible with this <code>ColorModel</code>; <code>false</code>
* otherwise.
* @throws UnsupportedOperationException if this
* method is not supported by this <code>ColorModel</code>
* @see SampleModel
*/
public boolean isCompatibleSampleModel(SampleModel sm) {
throw new UnsupportedOperationException
("This method is not supported by this color model");
}
/**
* Disposes of system resources associated with this
* <code>ColorModel</code> once this <code>ColorModel</code> is no
* longer referenced.
*/
public void finalize() {
}
/**
* Returns a <code>Raster</code> representing the alpha channel of an
* image, extracted from the input <code>Raster</code>, provided that
* pixel values of this <code>ColorModel</code> represent color and
* alpha information as separate spatial bands (e.g.
* {@link ComponentColorModel} and <code>DirectColorModel</code>).
* This method assumes that <code>Raster</code> objects associated
* with such a <code>ColorModel</code> store the alpha band, if
* present, as the last band of image data. Returns <code>null</code>
* if there is no separate spatial alpha channel associated with this
* <code>ColorModel</code>. If this is an
* <code>IndexColorModel</code> which has alpha in the lookup table,
* this method will return <code>null</code> since
* there is no spatially discrete alpha channel.
* This method will create a new <code>Raster</code> (but will share
* the data array).
* Since <code>ColorModel</code> is an abstract class, any instance
* is an instance of a subclass. Subclasses must override this
* method to get any behavior other than returning <code>null</code>
* because the implementation in this abstract class returns
* <code>null</code>.
* @param raster the specified <code>Raster</code>
* @return a <code>Raster</code> representing the alpha channel of
* an image, obtained from the specified <code>Raster</code>.
*/
public WritableRaster getAlphaRaster(WritableRaster raster) {
return null;
}
/**
* Returns the <code>String</code> representation of the contents of
* this <code>ColorModel</code>object.
* @return a <code>String</code> representing the contents of this
* <code>ColorModel</code> object.
*/
public String toString() {
return new String("ColorModel: #pixelBits = "+pixel_bits
+ " numComponents = "+numComponents
+ " color space = "+colorSpace
+ " transparency = "+transparency
+ " has alpha = "+supportsAlpha
+ " isAlphaPre = "+isAlphaPremultiplied
);
}
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[] l8Tos8 = null; // 8-bit linear to 8-bit non-linear sRGB LUT
static byte[] s8Tol8 = null; // 8-bit non-linear sRGB to 8-bit linear LUT
static byte[] l16Tos8 = null; // 16-bit linear to 8-bit non-linear sRGB LUT
static short[] s8Tol16 = null; // 8-bit non-linear sRGB to 16-bit linear LUT
// Maps to hold LUTs for grayscale conversions
static Map g8Tos8Map = null; // 8-bit gray values to 8-bit sRGB values
static Map lg16Toog8Map = null; // 16-bit linear to 8-bit "other" gray
static Map g16Tos8Map = null; // 16-bit gray values to 8-bit sRGB values
static Map lg16Toog16Map = null; // 16-bit linear to 16-bit "other" gray
static boolean isLinearRGBspace(ColorSpace cs) {
// Note: CMM.LINEAR_RGBspace will be null if the linear
// RGB space has not been created yet.
return (cs == CMSManager.LINEAR_RGBspace);
}
static boolean isLinearGRAYspace(ColorSpace cs) {
// Note: CMM.GRAYspace will be null if the linear
// gray space has not been created yet.
return (cs == CMSManager.GRAYspace);
}
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;
}
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;
}
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 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;
}
/*
* Return a byte LUT that converts 8-bit gray values in the grayCS
* ColorSpace to the appropriate 8-bit sRGB value. I.e., if lut
* is the byte array returned by this method and sval = lut[gval],
* then the sRGB triple (sval,sval,sval) is the best match to gval.
* Cache references to any computed LUT in a Map.
*/
static byte[] getGray8TosRGB8LUT(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;
}
ColorTransform[] transformList = new ColorTransform[2];
PCMM mdl = CMSManager.getModule();
ICC_ColorSpace srgbCS =
(ICC_ColorSpace) ColorSpace.getInstance(ColorSpace.CS_sRGB);
transformList[0] = mdl.createTransform(
grayCS.getProfile(), ColorTransform.Any, ColorTransform.In);
transformList[1] = mdl.createTransform(
srgbCS.getProfile(), ColorTransform.Any, ColorTransform.Out);
ColorTransform t = mdl.createTransform(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;
}
/*
* Return a byte LUT that converts 16-bit gray values in the CS_GRAY
* linear gray ColorSpace to the appropriate 8-bit value in the
* grayCS ColorSpace. Cache references to any computed LUT in a Map.
*/
static byte[] getLinearGray16ToOtherGray8LUT(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;
}
ColorTransform[] transformList = new ColorTransform[2];
PCMM mdl = CMSManager.getModule();
ICC_ColorSpace lgCS =
(ICC_ColorSpace) ColorSpace.getInstance(ColorSpace.CS_GRAY);
transformList[0] = mdl.createTransform (
lgCS.getProfile(), ColorTransform.Any, ColorTransform.In);
transformList[1] = mdl.createTransform (
grayCS.getProfile(), ColorTransform.Any, ColorTransform.Out);
ColorTransform t = mdl.createTransform(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;
}
/*
* Return a byte LUT that converts 16-bit gray values in the grayCS
* ColorSpace to the appropriate 8-bit sRGB value. I.e., if lut
* is the byte array returned by this method and sval = lut[gval],
* then the sRGB triple (sval,sval,sval) is the best match to gval.
* Cache references to any computed LUT in a Map.
*/
static byte[] getGray16TosRGB8LUT(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;
}
ColorTransform[] transformList = new ColorTransform[2];
PCMM mdl = CMSManager.getModule();
ICC_ColorSpace srgbCS =
(ICC_ColorSpace) ColorSpace.getInstance(ColorSpace.CS_sRGB);
transformList[0] = mdl.createTransform (
grayCS.getProfile(), ColorTransform.Any, ColorTransform.In);
transformList[1] = mdl.createTransform (
srgbCS.getProfile(), ColorTransform.Any, ColorTransform.Out);
ColorTransform t = mdl.createTransform(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;
}
/*
* Return a short LUT that converts 16-bit gray values in the CS_GRAY
* linear gray ColorSpace to the appropriate 16-bit value in the
* grayCS ColorSpace. Cache references to any computed LUT in a Map.
*/
static short[] getLinearGray16ToOtherGray16LUT(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;
}
ColorTransform[] transformList = new ColorTransform[2];
PCMM mdl = CMSManager.getModule();
ICC_ColorSpace lgCS =
(ICC_ColorSpace) ColorSpace.getInstance(ColorSpace.CS_GRAY);
transformList[0] = mdl.createTransform (
lgCS.getProfile(), ColorTransform.Any, ColorTransform.In);
transformList[1] = mdl.createTransform(
grayCS.getProfile(), ColorTransform.Any, ColorTransform.Out);
ColorTransform t = mdl.createTransform(
transformList);
short[] lg16Toog16LUT = t.colorConvert(tmp, null);
if (lg16Toog16Map == null) {
lg16Toog16Map = Collections.synchronizedMap(new WeakHashMap(2));
}
lg16Toog16Map.put(grayCS, lg16Toog16LUT);
return lg16Toog16LUT;
}
}