< prev index next >
src/java.desktop/share/classes/java/awt/image/ColorModel.java
Print this page
@@ -35,112 +35,112 @@
import java.util.Collections;
import java.util.Map;
import java.util.WeakHashMap;
/**
- * The <code>ColorModel</code> abstract class encapsulates the
+ * The {@code 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
- * <code>ColorModel</code> is specified by its <code>ColorSpace</code>.
- * A <code>ColorModel</code> used with pixel data that does not include
+ * {@code ColorModel} is specified by its {@code ColorSpace}.
+ * A {@code ColorModel} 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
+ * This {@code 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 <code>byte</code> or single
- * <code>int</code> values. For purposes of the <code>ColorModel</code>
+ * represented pixels as single {@code byte} or single
+ * {@code int} values. For purposes of the {@code 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, <code>ColorModel</code> now has methods that accept
+ * Consequently, {@code ColorModel} 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
+ * type used by a particular {@code ColorModel} object is called its
* transfer type.
* <p>
- * <code>ColorModel</code> objects used with images for which pixel values
+ * {@code 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 <code>ColorModel</code> must
+ * argument are called. Subclasses of {@code ColorModel} 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
+ * The transfer type for a particular {@code ColorModel} object is
* specified when the object is created, either explicitly or by default.
- * All subclasses of <code>ColorModel</code> must specify what the
+ * All subclasses of {@code ColorModel} 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>.
+ * For {@code BufferedImages}, the transfer type of its
+ * {@code Raster} and of the {@code Raster} object's
+ * {@code SampleModel} (available from the
+ * {@code getTransferType} methods of these classes) must match that
+ * of the {@code ColorModel}. The number of elements in an array
+ * representing a pixel for the {@code Raster} and
+ * {@code SampleModel} (available from the
+ * {@code getNumDataElements} methods of these classes) must match
+ * that of the {@code ColorModel}.
* <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
+ * {@code SampleModel} of a {@code BufferedImage} object's
+ * {@code 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.
* <p>
- * Methods in the <code>ColorModel</code> class use two different
+ * Methods in the {@code 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
- * <code>float</code> value between some minimum and maximum values. For
+ * {@code 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 <code>ColorSpace</code> object. These values
+ * be obtained from the {@code 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 <code>getMinValue</code> and
- * <code>getMaxValue</code> methods of the <code>ColorSpace</code>
+ * limits can be obtained using the {@code getMinValue} and
+ * {@code getMaxValue} methods of the {@code ColorSpace}
* class. Normalized color component values are not premultiplied.
- * All <code>ColorModels</code> must support the normalized form.
+ * All {@code ColorModels} 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
+ * {@code 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 <code>ColorModel</code> whose <code>ColorSpace</code> has minimum
+ * of {@code ColorModel} whose {@code 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 <code>ColorModels</code> whose normalized component
+ * representation for {@code 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 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>
+ * the unnormalized form is not convenient. Such {@code ColorModel}
* objects throw an {@link IllegalArgumentException} when methods involving
- * an unnormalized argument are called. Subclasses of <code>ColorModel</code>
+ * an unnormalized argument are called. Subclasses of {@code ColorModel}
* must specify the conditions under which this occurs.
*
* @see IndexColorModel
* @see ComponentColorModel
* @see PackedColorModel
@@ -220,23 +220,23 @@
initIDs();
}
private static ColorModel RGBdefault;
/**
- * Returns a <code>DirectColorModel</code> that describes the default
+ * Returns a {@code 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
- * <code>ColorModel</code> for a particular device or for all images.
+ * {@code ColorModel} 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
+ * @return a {@code DirectColorModel} object describing default
* RGB values.
*/
public static ColorModel getRGBdefault() {
if (RGBdefault == null) {
RGBdefault = new DirectColorModel(32,
@@ -248,13 +248,13 @@
}
return RGBdefault;
}
/**
- * Constructs a <code>ColorModel</code> that translates pixels of the
+ * Constructs a {@code ColorModel} 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.
+ * space is the default RGB {@code 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
@@ -265,11 +265,11 @@
* 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
+ * of bits in {@code bits} is less than 1
*/
public ColorModel(int bits) {
pixel_bits = bits;
if (bits < 1) {
throw new IllegalArgumentException("Number of bits must be > 0");
@@ -280,53 +280,53 @@
// REMIND: make sure transferType is set correctly
transferType = ColorModel.getDefaultTransferType(bits);
}
/**
- * Constructs a <code>ColorModel</code> that translates pixel values
+ * Constructs a {@code ColorModel} that translates pixel values
* to color/alpha components. Color components will be in the
- * specified <code>ColorSpace</code>. <code>pixel_bits</code> is the
+ * specified {@code ColorSpace}. {@code 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
- * <code>ColorSpace</code> if there is no alpha information in the
+ * {@code ColorSpace} 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
+ * information. {@code hasAlpha} indicates whether or not alpha
+ * information is present. The {@code boolean}
+ * {@code isAlphaPremultiplied} 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>
+ * separate spatial bands. If the {@code boolean}
+ * is {@code true}, color samples are assumed to have been
+ * multiplied by the alpha sample. The {@code 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
- * <code>IndexColorModel</code> with <code>pixel_bits</code> equal to
+ * {@code IndexColorModel} with {@code pixel_bits} 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
+ * @param cspace the specified {@code ColorSpace}
+ * @param hasAlpha {@code true} if alpha information is present;
+ * {@code false} otherwise
+ * @param isAlphaPremultiplied {@code true} if color samples are
* assumed to be premultiplied by the alpha samples;
- * <code>false</code> otherwise
+ * {@code false} 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
+ * components in this {@code ColorModel}, 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.
+ * of bits in {@code bits} is less than 1 or if
+ * any of the elements in {@code bits} is less than 0.
* @see java.awt.Transparency
*/
protected ColorModel(int pixel_bits, int[] bits, ColorSpace cspace,
boolean hasAlpha,
boolean isAlphaPremultiplied,
@@ -397,36 +397,36 @@
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.
+ * {@code ColorModel}.
+ * @return {@code true} if alpha is supported in this
+ * {@code ColorModel}; {@code false} otherwise.
*/
public final 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>
+ * pixel values to be translated by this {@code ColorModel}.
+ * If the boolean is {@code true}, this {@code 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 <code>true</code> if the alpha values are premultiplied
+ * @return {@code true} if the alpha values are premultiplied
* in the pixel values to be translated by this
- * <code>ColorModel</code>; <code>false</code> otherwise.
+ * {@code ColorModel}; {@code false} otherwise.
*/
public final boolean isAlphaPremultiplied() {
return isAlphaPremultiplied;
}
/**
- * Returns the transfer type of this <code>ColorModel</code>.
+ * Returns the transfer type of this {@code ColorModel}.
* The transfer type is the type of primitive array used to represent
* pixel values as arrays.
* @return the transfer type.
* @since 1.3
*/
@@ -434,34 +434,34 @@
return transferType;
}
/**
* Returns the number of bits per pixel described by this
- * <code>ColorModel</code>.
+ * {@code ColorModel}.
* @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
+ * {@code 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 <code>ColorModel</code> supports alpha, the alpha
+ * to blue. If this {@code ColorModel} 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>
+ * @throws ArrayIndexOutOfBoundsException if {@code componentIdx}
* is greater than the number of components or
* less than zero
* @throws NullPointerException if the number of bits array is
- * <code>null</code>
+ * {@code null}
*/
public int getComponentSize(int componentIdx) {
// REMIND:
if (nBits == null) {
throw new NullPointerException("Number of bits array is null.");
@@ -471,11 +471,11 @@
}
/**
* 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
+ * {@code ColorSpace}, 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) {
@@ -486,48 +486,48 @@
}
/**
* Returns the transparency. Returns either OPAQUE, BITMASK,
* or TRANSLUCENT.
- * @return the transparency of this <code>ColorModel</code>.
+ * @return the transparency of this {@code ColorModel}.
* @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
+ * {@code ColorModel}. 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>
+ * @return the number of components in this {@code ColorModel}
*/
public int getNumComponents() {
return numComponents;
}
/**
* Returns the number of color components in this
- * <code>ColorModel</code>.
+ * {@code ColorModel}.
* This is the number of components returned by
* {@link ColorSpace#getNumComponents}.
* @return the number of color components in this
- * <code>ColorModel</code>.
+ * {@code ColorModel}.
* @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
+ * An {@code IllegalArgumentException} is thrown if pixel
+ * values for this {@code 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.
* @param pixel a specified pixel
@@ -537,12 +537,12 @@
/**
* 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
+ * An {@code IllegalArgumentException} is thrown if pixel
+ * values for this {@code 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.
* @param pixel the specified pixel
@@ -552,12 +552,12 @@
/**
* 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
+ * An {@code IllegalArgumentException} is thrown if pixel values
+ * for this {@code 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.
* @param pixel the specified pixel
@@ -566,24 +566,24 @@
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
+ * An {@code IllegalArgumentException} is thrown if pixel
+ * values for this {@code ColorModel} 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
+ * An {@code IllegalArgumentException} thrown if pixel values
+ * for this {@code 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.
* @param pixel the specified pixel
@@ -598,43 +598,43 @@
| (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
+ * from 0 to 255 in the default RGB {@code 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 <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
+ * If {@code inData} is not a primitive array of type
+ * transferType, a {@code ClassCastException} is thrown. An
+ * {@code ArrayIndexOutOfBoundsException} is thrown if
+ * {@code inData} is not large enough to hold a pixel value for
+ * this {@code ColorModel}.
+ * If this {@code transferType} is not supported, a
+ * {@code UnsupportedOperationException} will be
* thrown. Since
- * <code>ColorModel</code> is an abstract class, any instance
+ * {@code 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
- * <code>transferType</code> other than
- * <code>DataBuffer.TYPE_BYTE</code>,
- * <code>DataBuffer.TYPE_USHORT</code>, or
- * <code>DataBuffer.TYPE_INT</code>.
+ * {@code transferType} other than
+ * {@code DataBuffer.TYPE_BYTE},
+ * {@code DataBuffer.TYPE_USHORT}, or
+ * {@code DataBuffer.TYPE_INT}.
* @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 ClassCastException if {@code inData}
+ * is not a primitive array of type {@code transferType}
* @throws ArrayIndexOutOfBoundsException if
- * <code>inData</code> is not large enough to hold a pixel value
- * for this <code>ColorModel</code>
+ * {@code inData} is not large enough to hold a pixel value
+ * for this {@code ColorModel}
* @throws UnsupportedOperationException if this
- * <code>transferType</code> is not supported by this
- * <code>ColorModel</code>
+ * {@code transferType} is not supported by this
+ * {@code ColorModel}
*/
public int getRed(Object inData) {
int pixel=0,length=0;
switch (transferType) {
case DataBuffer.TYPE_BYTE:
@@ -665,43 +665,43 @@
}
}
/**
* Returns the green color component for the specified pixel, scaled
- * from 0 to 255 in the default RGB <code>ColorSpace</code>, sRGB. A
+ * from 0 to 255 in the default RGB {@code 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 <code>inData</code> is
+ * alpha value is 0, the green value is 0. If {@code 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
+ * {@code ClassCastException} is thrown. An
+ * {@code ArrayIndexOutOfBoundsException} is thrown if
+ * {@code inData} is not large enough to hold a pixel value for
+ * this {@code ColorModel}.
+ * If this {@code transferType} is not supported, a
+ * {@code UnsupportedOperationException} will be
* thrown. Since
- * <code>ColorModel</code> is an abstract class, any instance
+ * {@code 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
- * <code>transferType</code> other than
- * <code>DataBuffer.TYPE_BYTE</code>,
- * <code>DataBuffer.TYPE_USHORT</code>, or
- * <code>DataBuffer.TYPE_INT</code>.
+ * {@code transferType} other than
+ * {@code DataBuffer.TYPE_BYTE},
+ * {@code DataBuffer.TYPE_USHORT}, or
+ * {@code DataBuffer.TYPE_INT}.
* @param inData an array of pixel values
* @return the value of the green component of the specified pixel.
- * @throws ClassCastException if <code>inData</code>
- * is not a primitive array of type <code>transferType</code>
+ * @throws ClassCastException if {@code inData}
+ * is not a primitive array of type {@code transferType}
* @throws ArrayIndexOutOfBoundsException if
- * <code>inData</code> is not large enough to hold a pixel value
- * for this <code>ColorModel</code>
+ * {@code inData} is not large enough to hold a pixel value
+ * for this {@code ColorModel}
* @throws UnsupportedOperationException if this
- * <code>transferType</code> is not supported by this
- * <code>ColorModel</code>
+ * {@code transferType} is not supported by this
+ * {@code ColorModel}
*/
public int getGreen(Object inData) {
int pixel=0,length=0;
switch (transferType) {
case DataBuffer.TYPE_BYTE:
@@ -732,43 +732,43 @@
}
}
/**
* Returns the blue color component for the specified pixel, scaled
- * from 0 to 255 in the default RGB <code>ColorSpace</code>, sRGB. A
+ * from 0 to 255 in the default RGB {@code 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
- * <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
+ * {@code inData} is not a primitive array of type transferType,
+ * a {@code ClassCastException} is thrown. An
+ * {@code ArrayIndexOutOfBoundsException} is
+ * thrown if {@code inData} is not large enough to hold a pixel
+ * value for this {@code ColorModel}.
+ * If this {@code transferType} is not supported, a
+ * {@code UnsupportedOperationException} will be
* thrown. Since
- * <code>ColorModel</code> is an abstract class, any instance
+ * {@code 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
- * <code>transferType</code> other than
- * <code>DataBuffer.TYPE_BYTE</code>,
- * <code>DataBuffer.TYPE_USHORT</code>, or
- * <code>DataBuffer.TYPE_INT</code>.
+ * {@code transferType} other than
+ * {@code DataBuffer.TYPE_BYTE},
+ * {@code DataBuffer.TYPE_USHORT}, or
+ * {@code DataBuffer.TYPE_INT}.
* @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 ClassCastException if {@code inData}
+ * is not a primitive array of type {@code transferType}
* @throws ArrayIndexOutOfBoundsException if
- * <code>inData</code> is not large enough to hold a pixel value
- * for this <code>ColorModel</code>
+ * {@code inData} is not large enough to hold a pixel value
+ * for this {@code ColorModel}
* @throws UnsupportedOperationException if this
- * <code>transferType</code> is not supported by this
- * <code>ColorModel</code>
+ * {@code transferType} is not supported by this
+ * {@code ColorModel}
*/
public int getBlue(Object inData) {
int pixel=0,length=0;
switch (transferType) {
case DataBuffer.TYPE_BYTE:
@@ -802,36 +802,36 @@
/**
* 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
+ * {@code ClassCastException} is thrown. An
+ * {@code ArrayIndexOutOfBoundsException} is thrown if
+ * {@code inData} is not large enough to hold a pixel value for
+ * this {@code ColorModel}.
+ * If this {@code transferType} is not supported, a
+ * {@code UnsupportedOperationException} will be
* thrown. Since
- * <code>ColorModel</code> is an abstract class, any instance
+ * {@code 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
- * <code>transferType</code> other than
- * <code>DataBuffer.TYPE_BYTE</code>,
- * <code>DataBuffer.TYPE_USHORT</code>, or
- * <code>DataBuffer.TYPE_INT</code>.
+ * {@code transferType} other than
+ * {@code DataBuffer.TYPE_BYTE},
+ * {@code DataBuffer.TYPE_USHORT}, or
+ * {@code DataBuffer.TYPE_INT}.
* @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 ClassCastException if {@code inData}
+ * is not a primitive array of type {@code transferType}
* @throws ArrayIndexOutOfBoundsException if
- * <code>inData</code> is not large enough to hold a pixel value
- * for this <code>ColorModel</code>
+ * {@code inData} is not large enough to hold a pixel value
+ * for this {@code ColorModel}
* @throws UnsupportedOperationException if this
- * <code>tranferType</code> is not supported by this
- * <code>ColorModel</code>
+ * {@code tranferType} is not supported by this
+ * {@code ColorModel}
*/
public int getAlpha(Object inData) {
int pixel=0,length=0;
switch (transferType) {
case DataBuffer.TYPE_BYTE:
@@ -866,14 +866,14 @@
* 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>.
+ * {@code ClassCastException} is thrown. An
+ * {@code ArrayIndexOutOfBoundsException} is
+ * thrown if {@code inData} is not large enough to hold a pixel
+ * value for this {@code 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).
* @param inData the specified pixel
* @return the color and alpha components of the specified pixel.
@@ -886,123 +886,123 @@
| (getBlue(inData) << 0);
}
/**
* Returns a data element array representation of a pixel in this
- * <code>ColorModel</code>, given an integer pixel representation in
+ * {@code 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
- * <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
+ * {@code null}, a new array will be allocated. If
+ * {@code pixel} is not
+ * {@code null}, it must be a primitive array of type
+ * {@code transferType}; otherwise, a
+ * {@code ClassCastException} is thrown. An
+ * {@code ArrayIndexOutOfBoundsException} is thrown if
+ * {@code pixel} 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,
+ * {@code ColorModel}. The pixel array is returned.
+ * If this {@code transferType} is not supported, a
+ * {@code UnsupportedOperationException} will be
+ * thrown. Since {@code 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 <code>UnsupportedOperationException</code>.
+ * class throws an {@code UnsupportedOperationException}.
* @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>
+ * {@code ColorModel}.
+ * @throws ClassCastException if {@code pixel}
+ * is not a primitive array of type {@code transferType}
* @throws ArrayIndexOutOfBoundsException if
- * <code>pixel</code> is not large enough to hold a pixel value
- * for this <code>ColorModel</code>
+ * {@code pixel} is not large enough to hold a pixel value
+ * for this {@code ColorModel}
* @throws UnsupportedOperationException if this
- * method is not supported by this <code>ColorModel</code>
+ * method is not supported by this {@code ColorModel}
* @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
+ * in this {@code ColorModel}. The pixel value is specified as
+ * an {@code int}. An {@code IllegalArgumentException}
+ * will be thrown if pixel values for this {@code ColorModel} are
+ * not conveniently representable as a single {@code int} or if
+ * color component values for this {@code 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
- * <code>DirectColorModel</code>. If the components array is
- * <code>null</code>, a new array will be allocated. The
+ * {@code DirectColorModel}. If the components array is
+ * {@code null}, 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>
+ * stored in the components array starting at {@code offset}
* (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
+ * {@code ArrayIndexOutOfBoundsException} is thrown if the
+ * components array is not {@code null} and is not large
* enough to hold all the color and alpha components (starting at offset).
- * Since <code>ColorModel</code> is an abstract class,
+ * Since {@code 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 <code>UnsupportedOperationException</code>.
+ * class throws an {@code UnsupportedOperationException}.
* @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
+ * @param offset the offset into the {@code components} 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>
+ * method is not supported by this {@code ColorModel}
*/
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
+ * in this {@code ColorModel}. 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
+ * object reference. If {@code pixel} is not a primitive array
+ * of type transferType, a {@code ClassCastException} is thrown.
+ * An {@code IllegalArgumentException} will be thrown if color
+ * component values for this {@code ColorModel} 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>.
+ * An {@code ArrayIndexOutOfBoundsException} is
+ * thrown if {@code pixel} is not large enough to hold a pixel
+ * value for this {@code ColorModel}.
* 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
+ * pixel value in any {@code ColorModel}. If the components
+ * array is {@code null}, 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
+ * stored in the {@code components} array starting at
+ * {@code offset} (even if the array is allocated by this
+ * method). An {@code ArrayIndexOutOfBoundsException}
+ * is thrown if the components array is not {@code null} 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,
+ * (starting at {@code offset}).
+ * Since {@code 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 <code>UnsupportedOperationException</code>.
+ * class throws an {@code UnsupportedOperationException}.
* @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
+ * @param offset the index into the {@code components} 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>
+ * method is not supported by this {@code ColorModel}
*/
public int[] getComponents(Object pixel, int[] components, int offset) {
throw new UnsupportedOperationException
("This method is not supported by this color model.");
}
@@ -1011,47 +1011,47 @@
* 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>
+ * maximum specified by the {@code ColorSpace} object for this
+ * {@code ColorModel}. An {@code IllegalArgumentException}
* will be thrown if color component values for this
- * <code>ColorModel</code> are not conveniently representable in the
+ * {@code ColorModel} 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
+ * {@code components} array is {@code null}, a new array
+ * will be allocated. The {@code components} array will
* be returned. Color/alpha components are stored in the
- * <code>components</code> array starting at <code>offset</code> (even
+ * {@code components} array starting at {@code offset} (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
+ * {@code ArrayIndexOutOfBoundsException} is thrown if the
+ * {@code components} array is not {@code null} 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
+ * components (starting at {@code offset}). An
+ * {@code IllegalArgumentException} is thrown if the
+ * {@code normComponents} array is not large enough to hold
* all the color and alpha components starting at
- * <code>normOffset</code>.
+ * {@code normOffset}.
* @param normComponents an array containing normalized components
- * @param normOffset the offset into the <code>normComponents</code>
+ * @param normOffset the offset into the {@code normComponents}
* 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
+ * {@code normComponents}
+ * @param offset the index into {@code components} at which to
* begin storing normalized components from
- * <code>normComponents</code>
+ * {@code normComponents}
* @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
+ * {@code ColorModel} 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>
+ * {@code normComponents} minus {@code normOffset}
+ * is less than {@code numComponents}
* @throws UnsupportedOperationException if the
- * constructor of this <code>ColorModel</code> called the
- * <code>super(bits)</code> constructor, but did not
+ * constructor of this {@code ColorModel} called the
+ * {@code super(bits)} constructor, but did not
* override this method. See the constructor,
* {@link #ColorModel(int)}.
*/
public int[] getUnnormalizedComponents(float[] normComponents,
int normOffset,
@@ -1103,49 +1103,49 @@
* 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>
+ * maximum specified by the {@code ColorSpace} object for this
+ * {@code ColorModel}. An {@code IllegalArgumentException}
* will be thrown if color component values for this
- * <code>ColorModel</code> are not conveniently representable in the
+ * {@code ColorModel} 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
+ * {@code normComponents} array is {@code null}, a new array
+ * will be allocated. The {@code normComponents} 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>
+ * {@code normComponents} array starting at
+ * {@code normOffset} (even if the array is allocated by this
+ * method). An {@code ArrayIndexOutOfBoundsException} is thrown
+ * if the {@code normComponents} array is not {@code null}
* 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>.
+ * (starting at {@code normOffset}). An
+ * {@code IllegalArgumentException} is thrown if the
+ * {@code components} array is not large enough to hold all the
+ * color and alpha components starting at {@code offset}.
* <p>
- * Since <code>ColorModel</code> is an abstract class,
+ * Since {@code 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.
* @param components an array containing unnormalized components
- * @param offset the offset into the <code>components</code> array at
+ * @param offset the offset into the {@code components} 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
+ * @param normOffset the index into {@code normComponents} 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
+ * {@code ColorModel} 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
+ * constructor of this {@code ColorModel} called the
+ * {@code super(bits)} 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
*/
@@ -1201,175 +1201,175 @@
return normComponents;
}
/**
- * Returns a pixel value represented as an <code>int</code> in this
- * <code>ColorModel</code>, given an array of unnormalized color/alpha
+ * Returns a pixel value represented as an {@code int} in this
+ * {@code ColorModel}, 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
+ * {@code IllegalArgumentException} if component values for this
+ * {@code ColorModel} are not conveniently representable as a
+ * single {@code int} or if color component values for this
+ * {@code ColorModel} 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,
+ * {@code ArrayIndexOutOfBoundsException} is thrown if the
+ * {@code components} array is not large enough to hold all the
+ * color and alpha components (starting at {@code offset}).
+ * Since {@code 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 <code>UnsupportedOperationException</code>.
+ * class throws an {@code UnsupportedOperationException}.
* @param components an array of unnormalized color and alpha
* components
- * @param offset the index into <code>components</code> at which to
+ * @param offset the index into {@code components} 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.
+ * @return an {@code int} pixel value in this
+ * {@code ColorModel} 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>
+ * pixel values for this {@code ColorModel} are not
+ * conveniently representable as a single {@code int}
* @throws IllegalArgumentException if
- * component values for this <code>ColorModel</code> are not
+ * component values for this {@code ColorModel} are not
* conveniently representable in the unnormalized form
* @throws ArrayIndexOutOfBoundsException if
- * the <code>components</code> array is not large enough to
+ * the {@code components} array is not large enough to
* hold all of the color and alpha components starting at
- * <code>offset</code>
+ * {@code offset}
* @throws UnsupportedOperationException if this
- * method is not supported by this <code>ColorModel</code>
+ * method is not supported by this {@code ColorModel}
*/
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
+ * {@code ColorModel}, 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
+ * {@code setDataElements} method of a {@code WritableRaster}
+ * object. This method will throw an {@code IllegalArgumentException}
+ * if color component values for this {@code ColorModel} 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
+ * An {@code ArrayIndexOutOfBoundsException} is thrown
+ * if the {@code components} 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
+ * {@code offset}). If the {@code obj} variable is
+ * {@code null}, a new array will be allocated. If
+ * {@code obj} is not {@code null}, 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,
+ * {@code ClassCastException} is thrown. An
+ * {@code ArrayIndexOutOfBoundsException} is thrown if
+ * {@code obj} is not large enough to hold a pixel value for this
+ * {@code ColorModel}.
+ * Since {@code 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 <code>UnsupportedOperationException</code>.
+ * class throws an {@code UnsupportedOperationException}.
* @param components an array of unnormalized color and alpha
* components
- * @param offset the index into <code>components</code> at which to
+ * @param offset the index into {@code components} at which to
* begin retrieving color and alpha components
- * @param obj the <code>Object</code> representing an array of color
+ * @param obj the {@code Object} representing an array of color
* and alpha components
- * @return an <code>Object</code> representing an array of color and
+ * @return an {@code Object} 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 ClassCastException if {@code obj}
+ * is not a primitive array of type {@code transferType}
* @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>
+ * {@code obj} is not large enough to hold a pixel value
+ * for this {@code ColorModel} or the {@code components}
* array is not large enough to hold all of the color and alpha
- * components starting at <code>offset</code>
+ * components starting at {@code offset}
* @throws IllegalArgumentException if
- * component values for this <code>ColorModel</code> are not
+ * component values for this {@code ColorModel} are not
* conveniently representable in the unnormalized form
* @throws UnsupportedOperationException if this
- * method is not supported by this <code>ColorModel</code>
+ * method is not supported by this {@code ColorModel}
* @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
+ * Returns a pixel value represented as an {@code int} in this
+ * {@code ColorModel}, 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,
+ * {@code IllegalArgumentException} if pixel values for this
+ * {@code ColorModel} are not conveniently representable as a
+ * single {@code int}. An
+ * {@code ArrayIndexOutOfBoundsException} is thrown if the
+ * {@code normComponents} array is not large enough to hold all the
+ * color and alpha components (starting at {@code normOffset}).
+ * Since {@code 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
- * <code>getDataElement(int[], int)</code>. Subclasses which may
+ * {@code getDataElement(int[], int)}. 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
+ * @param normOffset the index into {@code normComponents} 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.
+ * @return an {@code int} pixel value in this
+ * {@code ColorModel} 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>
+ * pixel values for this {@code ColorModel} are not
+ * conveniently representable as a single {@code int}
* @throws ArrayIndexOutOfBoundsException if
- * the <code>normComponents</code> array is not large enough to
+ * the {@code normComponents} array is not large enough to
* hold all of the color and alpha components starting at
- * <code>normOffset</code>
+ * {@code normOffset}
* @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
+ * {@code ColorModel}, 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
+ * {@code setDataElements} method of a {@code WritableRaster}
+ * object. An {@code ArrayIndexOutOfBoundsException} is thrown
+ * if the {@code normComponents} 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
+ * {@code normOffset}). If the {@code obj} variable is
+ * {@code null}, a new array will be allocated. If
+ * {@code obj} is not {@code null}, 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,
+ * {@code ClassCastException} is thrown. An
+ * {@code ArrayIndexOutOfBoundsException} is thrown if
+ * {@code obj} is not large enough to hold a pixel value for this
+ * {@code ColorModel}.
+ * Since {@code 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
- * <code>getDataElement(int[], int, Object)</code>. Subclasses which may
+ * {@code getDataElement(int[], int, Object)}. 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
+ * @param normOffset the index into {@code normComponents} 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
+ * @return an {@code Object} 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 ClassCastException if {@code obj}
+ * is not a primitive array of type {@code transferType}
* @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>
+ * {@code obj} is not large enough to hold a pixel value
+ * for this {@code ColorModel} or the {@code normComponents}
* array is not large enough to hold all of the color and alpha
- * components starting at <code>normOffset</code>
+ * components starting at {@code normOffset}
* @see WritableRaster#setDataElements
* @see SampleModel#setDataElements
* @since 1.4
*/
public Object getDataElements(float[] normComponents, int normOffset,
@@ -1379,55 +1379,55 @@
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
+ * form, given a pixel in this {@code 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 <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>.
+ * of type transferType, a {@code ClassCastException} is thrown.
+ * An {@code ArrayIndexOutOfBoundsException} is thrown if
+ * {@code pixel} is not large enough to hold a pixel value for this
+ * {@code ColorModel}.
* 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
+ * and maximum specified by the {@code ColorSpace} object for this
+ * {@code ColorModel}. If the
+ * {@code normComponents} array is {@code null}, a new array
+ * will be allocated. The {@code normComponents} 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>
+ * {@code normComponents} array starting at
+ * {@code normOffset} (even if the array is allocated by this
+ * method). An {@code ArrayIndexOutOfBoundsException} is thrown
+ * if the {@code normComponents} array is not {@code null}
* 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,
+ * (starting at {@code normOffset}).
+ * Since {@code 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
- * <code>getComponents(Object, int[], int)</code> and then calls
- * <code>getNormalizedComponents(int[], int, float[], int)</code>.
+ * {@code getComponents(Object, int[], int)} and then calls
+ * {@code getNormalizedComponents(int[], int, float[], int)}.
* 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>
+ * @param normOffset the offset into the {@code normComponents}
* 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
+ * @throws ClassCastException if {@code pixel} 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>
+ * {@code normComponents} is not large enough to hold all
+ * color and alpha components starting at {@code normOffset}
* @throws ArrayIndexOutOfBoundsException if
- * <code>pixel</code> is not large enough to hold a pixel
- * value for this <code>ColorModel</code>.
+ * {@code pixel} is not large enough to hold a pixel
+ * value for this {@code ColorModel}.
* @throws UnsupportedOperationException if the
- * constructor of this <code>ColorModel</code> called the
- * <code>super(bits)</code> constructor, but did not
+ * constructor of this {@code ColorModel} called the
+ * {@code super(bits)} 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
@@ -1439,17 +1439,17 @@
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.
+ * Tests if the specified {@code Object} is an instance of
+ * {@code ColorModel} and if it equals this
+ * {@code ColorModel}.
+ * @param obj the {@code Object} to test for equality
+ * @return {@code true} if the specified {@code Object}
+ * is an instance of {@code ColorModel} and equals this
+ * {@code ColorModel}; {@code false} otherwise.
*/
public boolean equals(Object obj) {
if (!(obj instanceof ColorModel)) {
return false;
}
@@ -1505,171 +1505,171 @@
return result;
}
/**
- * Returns the <code>ColorSpace</code> associated with this
- * <code>ColorModel</code>.
- * @return the <code>ColorSpace</code> of this
- * <code>ColorModel</code>.
+ * Returns the {@code ColorSpace} associated with this
+ * {@code ColorModel}.
+ * @return the {@code ColorSpace} of this
+ * {@code ColorModel}.
*/
public final 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
+ * {@code isAlphaPremultiplied} variable, assuming the data is
+ * currently correctly described by this {@code 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
- * <code>ColorModel</code> with the <code>isAlphaPremultiplied</code>
+ * {@code ColorModel} with the {@code isAlphaPremultiplied}
* 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,
+ * {@code UnsupportedOperationException} if it is not supported
+ * by this {@code ColorModel}.
+ * Since {@code 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 <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
+ * class throws an {@code UnsupportedOperationException}.
+ * @param raster the {@code WritableRaster} data
+ * @param isAlphaPremultiplied {@code true} if the alpha is
+ * premultiplied; {@code false} otherwise
+ * @return a {@code ColorModel} 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
+ * Returns {@code true} if {@code raster} is compatible
+ * with this {@code ColorModel} and {@code false} if it is
* not.
- * Since <code>ColorModel</code> is an abstract class,
+ * Since {@code 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 <code>UnsupportedOperationException</code>.
+ * class throws an {@code UnsupportedOperationException}.
* @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>.
+ * @return {@code true} if {@code raster} is compatible
+ * with this {@code ColorModel}.
* @throws UnsupportedOperationException if this
* method has not been implemented for this
- * <code>ColorModel</code>
+ * {@code ColorModel}
*/
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,
+ * Creates a {@code WritableRaster} with the specified width and
+ * height that has a data layout ({@code SampleModel}) compatible
+ * with this {@code ColorModel}.
+ * Since {@code 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 <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
+ * class throws an {@code UnsupportedOperationException}.
+ * @param w the width to apply to the new {@code WritableRaster}
+ * @param h the height to apply to the new {@code WritableRaster}
+ * @return a {@code WritableRaster} object with the specified
* width and height.
* @throws UnsupportedOperationException if this
- * method is not supported by this <code>ColorModel</code>
+ * method is not supported by this {@code ColorModel}
* @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
+ * Creates a {@code SampleModel} 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,
+ * {@code ColorModel}.
+ * Since {@code 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 <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
+ * class throws an {@code UnsupportedOperationException}.
+ * @param w the width to apply to the new {@code SampleModel}
+ * @param h the height to apply to the new {@code SampleModel}
+ * @return a {@code SampleModel} object with the specified
* width and height.
* @throws UnsupportedOperationException if this
- * method is not supported by this <code>ColorModel</code>
+ * method is not supported by this {@code ColorModel}
* @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,
+ /** Checks if the {@code SampleModel} is compatible with this
+ * {@code ColorModel}.
+ * Since {@code 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 <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>
+ * class throws an {@code UnsupportedOperationException}.
+ * @param sm the specified {@code SampleModel}
+ * @return {@code true} if the specified {@code SampleModel}
+ * is compatible with this {@code ColorModel}; {@code false}
* otherwise.
* @throws UnsupportedOperationException if this
- * method is not supported by this <code>ColorModel</code>
+ * method is not supported by this {@code ColorModel}
* @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
+ * {@code ColorModel} once this {@code ColorModel} 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
+ * Returns a {@code Raster} representing the alpha channel of an
+ * image, extracted from the input {@code Raster}, provided that
+ * pixel values of this {@code ColorModel} 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>
+ * {@link ComponentColorModel} and {@code DirectColorModel}).
+ * This method assumes that {@code Raster} objects associated
+ * with such a {@code ColorModel} store the alpha band, if
+ * present, as the last band of image data. Returns {@code null}
* 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
+ * {@code ColorModel}. If this is an
+ * {@code IndexColorModel} which has alpha in the lookup table,
+ * this method will return {@code null} since
* there is no spatially discrete alpha channel.
- * This method will create a new <code>Raster</code> (but will share
+ * This method will create a new {@code Raster} (but will share
* the data array).
- * Since <code>ColorModel</code> is an abstract class, any instance
+ * Since {@code 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 <code>null</code>
+ * method to get any behavior other than returning {@code null}
* 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>.
+ * {@code null}.
+ * @param raster the specified {@code Raster}
+ * @return a {@code Raster} representing the alpha channel of
+ * an image, obtained from the specified {@code Raster}.
*/
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.
+ * Returns the {@code String} representation of the contents of
+ * this {@code ColorModel} object.
+ * @return a {@code String} representing the contents of this
+ * {@code ColorModel} object.
*/
public String toString() {
return new String("ColorModel: #pixelBits = "+pixel_bits
+ " numComponents = "+numComponents
+ " color space = "+colorSpace
< prev index next >