< prev index next >
src/java.desktop/share/classes/java/awt/image/DirectColorModel.java
Print this page
@@ -27,23 +27,23 @@
import java.awt.color.ColorSpace;
import java.awt.Transparency;
/**
- * The <code>DirectColorModel</code> class is a <code>ColorModel</code>
+ * The {@code DirectColorModel} class is a {@code ColorModel}
* class that works with pixel values that represent RGB
* color and alpha information as separate samples and that pack all
* samples for a single pixel into a single int, short, or byte quantity.
* This class can be used only with ColorSpaces of type ColorSpace.TYPE_RGB.
* In addition, for each component of the ColorSpace, the minimum
- * normalized component value obtained via the <code>getMinValue()</code>
+ * normalized component value obtained via the {@code getMinValue()}
* method of ColorSpace must be 0.0, and the maximum value obtained via
- * the <code>getMaxValue()</code> method must be 1.0 (these min/max
+ * the {@code getMaxValue()} method must be 1.0 (these min/max
* values are typical for RGB spaces).
* There must be three color samples in the pixel values and there can
* be a single alpha sample. For those methods that use a primitive array
- * pixel representation of type <code>transferType</code>, the array
+ * pixel representation of type {@code transferType}, the array
* length is always one. The transfer
* types supported are DataBuffer.TYPE_BYTE,
* DataBuffer.TYPE_USHORT, and DataBuffer.TYPE_INT.
* Color and alpha samples are stored in the single
* element of the array in bits indicated by bit masks. Each bit mask
@@ -58,30 +58,30 @@
* <li> Index 3 corresponds to the alpha sample, if present.
* </ul>
* <p>
* The translation from pixel values to color/alpha components for
* display or processing purposes is a one-to-one correspondence of
- * samples to components. A <code>DirectColorModel</code> is
+ * samples to components. A {@code DirectColorModel} is
* typically used with image data which uses masks to define packed
- * samples. For example, a <code>DirectColorModel</code> can be used in
- * conjunction with a <code>SinglePixelPackedSampleModel</code> to
+ * samples. For example, a {@code DirectColorModel} can be used in
+ * conjunction with a {@code SinglePixelPackedSampleModel} to
* construct a {@link BufferedImage}. Normally the masks used by the
- * {@link SampleModel} and the <code>ColorModel</code> would be the
+ * {@link SampleModel} and the {@code ColorModel} would be the
* same. However, if they are different, the color interpretation
* of pixel data will be done according to the masks of the
- * <code>ColorModel</code>.
+ * {@code ColorModel}.
* <p>
* A single int pixel representation is valid for all objects of this
* class, since it is always possible to represent pixel values used with
* this class in a single int. Therefore, methods which use this
- * representation will not throw an <code>IllegalArgumentException</code>
+ * representation will not throw an {@code IllegalArgumentException}
* due to an invalid pixel value.
* <p>
* This color model is similar to an X11 TrueColor visual.
* The default RGB ColorModel specified by the
* {@link ColorModel#getRGBdefault() getRGBdefault} method is a
- * <code>DirectColorModel</code> with the following parameters:
+ * {@code DirectColorModel} with the following parameters:
* <pre>
* Number of bits: 32
* Red mask: 0x00ff0000
* Green mask: 0x0000ff00
* Blue mask: 0x000000ff
@@ -124,18 +124,18 @@
private byte[] tosRGB8LUT;
private byte[] fromsRGB8LUT8;
private short[] fromsRGB8LUT16;
/**
- * Constructs a <code>DirectColorModel</code> from the specified masks
- * that indicate which bits in an <code>int</code> pixel representation
+ * Constructs a {@code DirectColorModel} from the specified masks
+ * that indicate which bits in an {@code int} pixel representation
* contain the red, green and blue color samples. As pixel values do not
* contain alpha information, all pixels are treated as opaque, which
* means that alpha = 1.0. All of the bits
* in each mask must be contiguous and fit in the specified number
- * of least significant bits of an <code>int</code> pixel representation.
- * The <code>ColorSpace</code> is the default sRGB space. The
+ * of least significant bits of an {@code int} pixel representation.
+ * The {@code ColorSpace} is the default sRGB space. The
* transparency value is Transparency.OPAQUE. The transfer type
* is the smallest of DataBuffer.TYPE_BYTE, DataBuffer.TYPE_USHORT,
* or DataBuffer.TYPE_INT that can hold a single pixel.
* @param bits the number of bits in the pixel values; for example,
* the sum of the number of bits in the masks.
@@ -151,19 +151,19 @@
int rmask, int gmask, int bmask) {
this(bits, rmask, gmask, bmask, 0);
}
/**
- * Constructs a <code>DirectColorModel</code> from the specified masks
- * that indicate which bits in an <code>int</code> pixel representation
+ * Constructs a {@code DirectColorModel} from the specified masks
+ * that indicate which bits in an {@code int} pixel representation
* contain the red, green and blue color samples and the alpha sample,
- * if present. If <code>amask</code> is 0, pixel values do not contain
+ * if present. If {@code amask} is 0, pixel values do not contain
* alpha information and all pixels are treated as opaque, which means
* that alpha = 1.0. All of the bits in each mask must
* be contiguous and fit in the specified number of least significant bits
- * of an <code>int</code> pixel representation. Alpha, if present, is not
- * premultiplied. The <code>ColorSpace</code> is the default sRGB space.
+ * of an {@code int} pixel representation. Alpha, if present, is not
+ * premultiplied. The {@code ColorSpace} is the default sRGB space.
* The transparency value is Transparency.OPAQUE if no alpha is
* present, or Transparency.TRANSLUCENT otherwise. The transfer type
* is the smallest of DataBuffer.TYPE_BYTE, DataBuffer.TYPE_USHORT,
* or DataBuffer.TYPE_INT that can hold a single pixel.
* @param bits the number of bits in the pixel values; for example,
@@ -185,47 +185,47 @@
ColorModel.getDefaultTransferType(bits));
setFields();
}
/**
- * Constructs a <code>DirectColorModel</code> from the specified
+ * Constructs a {@code DirectColorModel} from the specified
* parameters. Color components are in the specified
- * <code>ColorSpace</code>, which must be of type ColorSpace.TYPE_RGB
+ * {@code ColorSpace}, which must be of type ColorSpace.TYPE_RGB
* and have minimum normalized component values which are all 0.0
* and maximum values which are all 1.0.
- * The masks specify which bits in an <code>int</code> pixel
+ * The masks specify which bits in an {@code int} pixel
* representation contain the red, green and blue color samples and
- * the alpha sample, if present. If <code>amask</code> is 0, pixel
+ * the alpha sample, if present. If {@code amask} is 0, pixel
* values do not contain alpha information and all pixels are treated
* as opaque, which means that alpha = 1.0. All of the
* bits in each mask must be contiguous and fit in the specified number
- * of least significant bits of an <code>int</code> pixel
- * representation. If there is alpha, the <code>boolean</code>
- * <code>isAlphaPremultiplied</code> specifies how to interpret
- * color and alpha samples in pixel values. If the <code>boolean</code>
- * is <code>true</code>, color samples are assumed to have been
+ * of least significant bits of an {@code int} pixel
+ * representation. If there is alpha, the {@code boolean}
+ * {@code isAlphaPremultiplied} specifies how to interpret
+ * color and alpha samples in pixel values. If the {@code boolean}
+ * is {@code true}, color samples are assumed to have been
* multiplied by the alpha sample. The transparency value is
* Transparency.OPAQUE, if no alpha is present, or
* Transparency.TRANSLUCENT otherwise. The transfer type
* is the type of primitive array used to represent pixel values and
* must be one of DataBuffer.TYPE_BYTE, DataBuffer.TYPE_USHORT, or
* DataBuffer.TYPE_INT.
- * @param space the specified <code>ColorSpace</code>
+ * @param space the specified {@code ColorSpace}
* @param bits the number of bits in the pixel values; for example,
* the sum of the number of bits in the masks.
* @param rmask specifies a mask indicating which bits in an
* integer pixel contain the red component
* @param gmask specifies a mask indicating which bits in an
* integer pixel contain the green component
* @param bmask specifies a mask indicating which bits in an
* integer pixel contain the blue component
* @param amask specifies a mask indicating which bits in an
* integer pixel contain the alpha component
- * @param isAlphaPremultiplied <code>true</code> if color samples are
- * premultiplied by the alpha sample; <code>false</code> otherwise
+ * @param isAlphaPremultiplied {@code true} if color samples are
+ * premultiplied by the alpha sample; {@code false} otherwise
* @param transferType the type of array used to represent pixel values
- * @throws IllegalArgumentException if <code>space</code> is not a
+ * @throws IllegalArgumentException if {@code space} is not a
* TYPE_RGB space or if the min/max normalized component
* values are not 0.0/1.0.
*/
public DirectColorModel(ColorSpace space, int bits, int rmask,
int gmask, int bmask, int amask,
@@ -259,43 +259,43 @@
}
setFields();
}
/**
- * Returns the mask indicating which bits in an <code>int</code> pixel
+ * Returns the mask indicating which bits in an {@code int} pixel
* representation contain the red color component.
- * @return the mask, which indicates which bits of the <code>int</code>
+ * @return the mask, which indicates which bits of the {@code int}
* pixel representation contain the red color sample.
*/
public final int getRedMask() {
return maskArray[0];
}
/**
- * Returns the mask indicating which bits in an <code>int</code> pixel
+ * Returns the mask indicating which bits in an {@code int} pixel
* representation contain the green color component.
- * @return the mask, which indicates which bits of the <code>int</code>
+ * @return the mask, which indicates which bits of the {@code int}
* pixel representation contain the green color sample.
*/
public final int getGreenMask() {
return maskArray[1];
}
/**
- * Returns the mask indicating which bits in an <code>int</code> pixel
+ * Returns the mask indicating which bits in an {@code int} pixel
* representation contain the blue color component.
- * @return the mask, which indicates which bits of the <code>int</code>
+ * @return the mask, which indicates which bits of the {@code int}
* pixel representation contain the blue color sample.
*/
public final int getBlueMask() {
return maskArray[2];
}
/**
- * Returns the mask indicating which bits in an <code>int</code> pixel
+ * Returns the mask indicating which bits in an {@code int} pixel
* representation contain the alpha component.
- * @return the mask, which indicates which bits of the <code>int</code>
+ * @return the mask, which indicates which bits of the {@code int}
* pixel representation contain the alpha sample.
*/
public final int getAlphaMask() {
if (supportsAlpha) {
return maskArray[3];
@@ -352,20 +352,20 @@
}
/**
* 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
- * as an <code>int</code>.
+ * as an {@code int}.
* The returned value is a non pre-multiplied value. Thus, if the
* alpha is premultiplied, this method divides it out before returning
* the value. If the alpha value is 0, for example, the red value
* is 0.
* @param pixel the specified pixel
* @return the red color component for the specified pixel, from
- * 0 to 255 in the sRGB <code>ColorSpace</code>.
+ * 0 to 255 in the sRGB {@code ColorSpace}.
*/
public final int getRed(int pixel) {
if (is_sRGB) {
return getsRGBComponentFromsRGB(pixel, 0);
} else if (is_LinearRGB) {
@@ -375,20 +375,20 @@
return (int) (rgb[0] * 255.0f + 0.5f);
}
/**
* 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
- * as an <code>int</code>.
+ * as an {@code int}.
* The returned value is a non pre-multiplied value. Thus, if the
* alpha is premultiplied, this method divides it out before returning
* the value. If the alpha value is 0, for example, the green value
* is 0.
* @param pixel the specified pixel
* @return the green color component for the specified pixel, from
- * 0 to 255 in the sRGB <code>ColorSpace</code>.
+ * 0 to 255 in the sRGB {@code ColorSpace}.
*/
public final int getGreen(int pixel) {
if (is_sRGB) {
return getsRGBComponentFromsRGB(pixel, 1);
} else if (is_LinearRGB) {
@@ -398,20 +398,20 @@
return (int) (rgb[1] * 255.0f + 0.5f);
}
/**
* 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
- * as an <code>int</code>.
+ * as an {@code int}.
* The returned value is a non pre-multiplied value. Thus, if the
* alpha is premultiplied, this method divides it out before returning
* the value. If the alpha value is 0, for example, the blue value
* is 0.
* @param pixel the specified pixel
* @return the blue color component for the specified pixel, from
- * 0 to 255 in the sRGB <code>ColorSpace</code>.
+ * 0 to 255 in the sRGB {@code ColorSpace}.
*/
public final int getBlue(int pixel) {
if (is_sRGB) {
return getsRGBComponentFromsRGB(pixel, 2);
} else if (is_LinearRGB) {
@@ -421,13 +421,13 @@
return (int) (rgb[2] * 255.0f + 0.5f);
}
/**
* Returns the alpha component for the specified pixel, scaled
- * from 0 to 255. The pixel value is specified as an <code>int</code>.
+ * from 0 to 255. The pixel value is specified as an {@code int}.
* @param pixel the specified pixel
- * @return the value of the alpha component of <code>pixel</code>
+ * @return the value of the alpha component of {@code pixel}
* from 0 to 255.
*/
public final int getAlpha(int pixel) {
if (!supportsAlpha) return 255;
int a = ((pixel & maskArray[3]) >>> maskOffsets[3]);
@@ -438,11 +438,11 @@
}
/**
* 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 <code>int</code>.
+ * The pixel value is specified as an {@code int}.
* The returned value is in a non pre-multiplied format. Thus, if
* the alpha is premultiplied, this method divides it out of the
* color components. If the alpha value is 0, for example, the color
* values are each 0.
* @param pixel the specified pixel
@@ -464,37 +464,37 @@
| (((int) (rgb[2] * 255.0f + 0.5f)) << 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 <code>transferType</code> passed
+ * by an array of data elements of type {@code transferType} passed
* in as an object reference.
* The returned value is a non pre-multiplied value. Thus, if the
* alpha is premultiplied, this method divides it out before returning
* the value. If the alpha value is 0, for example, the red value
* is 0.
- * If <code>inData</code> is not a primitive array of type
- * <code>transferType</code>, 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>. Since
- * <code>DirectColorModel</code> can be subclassed, subclasses inherit
+ * If {@code inData} is not a primitive array of type
+ * {@code 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}. Since
+ * {@code DirectColorModel} can be subclassed, subclasses inherit
* the implementation of this method and if they don't override it
* then they throw an exception if they use an unsupported
- * <code>transferType</code>.
- * An <code>UnsupportedOperationException</code> is thrown if this
- * <code>transferType</code> is not supported by this
- * <code>ColorModel</code>.
+ * {@code transferType}.
+ * An {@code UnsupportedOperationException} is thrown if this
+ * {@code transferType} is not supported by this
+ * {@code ColorModel}.
* @param inData the array containing the pixel value
* @return the value of the red component of the specified pixel.
- * @throws ArrayIndexOutOfBoundsException if <code>inData</code> is not
+ * @throws ArrayIndexOutOfBoundsException if {@code inData} is not
* large enough to hold a pixel value for this color model
- * @throws ClassCastException if <code>inData</code> is not a
- * primitive array of type <code>transferType</code>
- * @throws UnsupportedOperationException if this <code>transferType</code>
+ * @throws ClassCastException if {@code inData} is not a
+ * primitive array of type {@code transferType}
+ * @throws UnsupportedOperationException if this {@code transferType}
* is not supported by this color model
*/
public int getRed(Object inData) {
int pixel=0;
switch (transferType) {
@@ -518,36 +518,36 @@
}
/**
* 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 <code>transferType</code> passed
+ * by an array of data elements of type {@code transferType} passed
* in as an object reference.
* The returned value is a non pre-multiplied value. Thus, if the
* alpha is premultiplied, this method divides it out before returning
* the value. If the alpha value is 0, for example, the green value
- * is 0. If <code>inData</code> is not a primitive array of type
- * <code>transferType</code>, 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>. Since
- * <code>DirectColorModel</code> can be subclassed, subclasses inherit
+ * is 0. If {@code inData} is not a primitive array of type
+ * {@code 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}. Since
+ * {@code DirectColorModel} can be subclassed, subclasses inherit
* the implementation of this method and if they don't override it
* then they throw an exception if they use an unsupported
- * <code>transferType</code>.
- * An <code>UnsupportedOperationException</code> is
- * thrown if this <code>transferType</code> is not supported by this
- * <code>ColorModel</code>.
+ * {@code transferType}.
+ * An {@code UnsupportedOperationException} is
+ * thrown if this {@code transferType} is not supported by this
+ * {@code ColorModel}.
* @param inData the array containing the pixel value
* @return the value of the green component of the specified pixel.
- * @throws ArrayIndexOutOfBoundsException if <code>inData</code> is not
+ * @throws ArrayIndexOutOfBoundsException if {@code inData} is not
* large enough to hold a pixel value for this color model
- * @throws ClassCastException if <code>inData</code> is not a
- * primitive array of type <code>transferType</code>
- * @throws UnsupportedOperationException if this <code>transferType</code>
+ * @throws ClassCastException if {@code inData} is not a
+ * primitive array of type {@code transferType}
+ * @throws UnsupportedOperationException if this {@code transferType}
* is not supported by this color model
*/
public int getGreen(Object inData) {
int pixel=0;
switch (transferType) {
@@ -571,36 +571,36 @@
}
/**
* 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 <code>transferType</code> passed
+ * by an array of data elements of type {@code transferType} passed
* in as an object reference.
* The returned value is a non pre-multiplied value. Thus, if the
* alpha is premultiplied, this method divides it out before returning
* the value. If the alpha value is 0, for example, the blue value
- * is 0. If <code>inData</code> is not a primitive array of type
- * <code>transferType</code>, 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>. Since
- * <code>DirectColorModel</code> can be subclassed, subclasses inherit
+ * is 0. If {@code inData} is not a primitive array of type
+ * {@code 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}. Since
+ * {@code DirectColorModel} can be subclassed, subclasses inherit
* the implementation of this method and if they don't override it
* then they throw an exception if they use an unsupported
- * <code>transferType</code>.
- * An <code>UnsupportedOperationException</code> is
- * thrown if this <code>transferType</code> is not supported by this
- * <code>ColorModel</code>.
+ * {@code transferType}.
+ * An {@code UnsupportedOperationException} is
+ * thrown if this {@code transferType} is not supported by this
+ * {@code ColorModel}.
* @param inData the array containing the pixel value
* @return the value of the blue component of the specified pixel.
- * @throws ArrayIndexOutOfBoundsException if <code>inData</code> is not
+ * @throws ArrayIndexOutOfBoundsException if {@code inData} is not
* large enough to hold a pixel value for this color model
- * @throws ClassCastException if <code>inData</code> is not a
- * primitive array of type <code>transferType</code>
- * @throws UnsupportedOperationException if this <code>transferType</code>
+ * @throws ClassCastException if {@code inData} is not a
+ * primitive array of type {@code transferType}
+ * @throws UnsupportedOperationException if this {@code transferType}
* is not supported by this color model
*/
public int getBlue(Object inData) {
int pixel=0;
switch (transferType) {
@@ -624,34 +624,34 @@
}
/**
* 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 <code>transferType</code> passed in as an object
+ * elements of type {@code transferType} passed in as an object
* reference.
- * If <code>inData</code> is not a primitive array of type
- * <code>transferType</code>, 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>. Since
- * <code>DirectColorModel</code> can be subclassed, subclasses inherit
+ * If {@code inData} is not a primitive array of type
+ * {@code 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}. Since
+ * {@code DirectColorModel} can be subclassed, subclasses inherit
* the implementation of this method and if they don't override it
* then they throw an exception if they use an unsupported
- * <code>transferType</code>.
- * If this <code>transferType</code> is not supported, an
- * <code>UnsupportedOperationException</code> is thrown.
+ * {@code transferType}.
+ * If this {@code transferType} is not supported, an
+ * {@code UnsupportedOperationException} is thrown.
* @param inData the specified pixel
* @return the alpha component of the specified pixel, scaled from
* 0 to 255.
- * @exception ClassCastException if <code>inData</code>
- * is not a primitive array of type <code>transferType</code>
+ * @exception ClassCastException if {@code inData}
+ * is not a primitive array of type {@code transferType}
* @exception 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}
* @exception 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;
switch (transferType) {
case DataBuffer.TYPE_BYTE:
@@ -675,30 +675,30 @@
/**
* 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 <code>transferType</code> passed in as an object
- * reference. If <code>inData</code> is not a primitive array of type
- * <code>transferType</code>, 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>.
+ * elements of type {@code transferType} passed in as an object
+ * reference. If {@code inData} is not a primitive array of type
+ * {@code 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}.
* The returned value is in a non pre-multiplied format. Thus, if
* the alpha is premultiplied, this method divides it out of the
* color components. If the alpha value is 0, for example, the color
- * values is 0. Since <code>DirectColorModel</code> can be
+ * values is 0. Since {@code DirectColorModel} can be
* subclassed, subclasses inherit the implementation of this method
* and if they don't override it then
* they throw an exception if they use an unsupported
- * <code>transferType</code>.
+ * {@code transferType}.
*
* @param inData the specified pixel
* @return the color and alpha components of the specified pixel.
* @exception UnsupportedOperationException if this
- * <code>transferType</code> is not supported by this
- * <code>ColorModel</code>
+ * {@code transferType} is not supported by this
+ * {@code ColorModel}
* @see ColorModel#getRGBdefault
*/
public int getRGB(Object inData) {
int pixel=0;
switch (transferType) {
@@ -721,39 +721,39 @@
return getRGB(pixel);
}
/**
* Returns a data element array representation of a pixel in this
- * <code>ColorModel</code>, given an integer pixel representation in the
+ * {@code ColorModel}, given an integer pixel representation in the
* default RGB color model.
- * This array can then be passed to the <code>setDataElements</code>
- * method of a <code>WritableRaster</code> object. If the pixel variable
- * is <code>null</code>, a new array is 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.
- * Since <code>DirectColorModel</code> can be subclassed, subclasses
+ * This array can then be passed to the {@code setDataElements}
+ * method of a {@code WritableRaster} object. If the pixel variable
+ * is {@code null}, a new array is 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}. The pixel array is returned.
+ * Since {@code DirectColorModel} can be subclassed, subclasses
* inherit the implementation of this method and if they don't
* override it then they throw an exception if they use an unsupported
- * <code>transferType</code>.
+ * {@code transferType}.
*
* @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>
- * @exception ClassCastException if <code>pixel</code>
- * is not a primitive array of type <code>transferType</code>
+ * {@code ColorModel}
+ * @exception ClassCastException if {@code pixel}
+ * is not a primitive array of type {@code transferType}
* @exception 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}
* @exception UnsupportedOperationException if this
- * <code>transferType</code> is not supported by this
- * <code>ColorModel</code>
+ * {@code transferType} is not supported by this
+ * {@code ColorModel}
* @see WritableRaster#setDataElements
* @see SampleModel#setDataElements
*/
public Object getDataElements(int rgb, Object pixel) {
//REMIND: maybe more efficient not to use int array for
@@ -903,24 +903,24 @@
}
/**
* 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>. If the <code>components</code> array is
- * <code>null</code>, a new array is allocated. The
- * <code>components</code> array is 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
+ * in this {@code ColorModel}. The pixel value is specified as an
+ * {@code int}. If the {@code components} array is
+ * {@code null}, a new array is allocated. The
+ * {@code components} array is returned. Color/alpha components are
+ * 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
+ * {@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>.
+ * {@code offset}.
* @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.
*/
public final int[] getComponents(int pixel, int[] components, int offset) {
@@ -935,45 +935,45 @@
return components;
}
/**
* 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 <code>transferType</code> passed in as
- * an object reference. If <code>pixel</code> is not a primitive array
- * of type <code>transferType</code>, 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>. If the
- * <code>components</code> array is <code>null</code>, a new
- * array is allocated. The <code>components</code> array is 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>.
- * Since <code>DirectColorModel</code> can be subclassed, subclasses
+ * in this {@code ColorModel}. The pixel value is specified by an
+ * array of data elements of type {@code transferType} passed in as
+ * an object reference. If {@code pixel} is not a primitive array
+ * of type {@code 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}. If the
+ * {@code components} array is {@code null}, a new
+ * array is allocated. The {@code components} array is returned.
+ * Color/alpha components are 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 {@code components} array is not
+ * {@code null} and is not large enough to hold all the color and
+ * alpha components, starting at {@code offset}.
+ * Since {@code DirectColorModel} can be subclassed, subclasses
* inherit the implementation of this method and if they don't
* override it then they throw an exception if they use an unsupported
- * <code>transferType</code>.
+ * {@code transferType}.
* @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.
- * @exception ClassCastException if <code>pixel</code>
- * is not a primitive array of type <code>transferType</code>
+ * @exception ClassCastException if {@code pixel}
+ * is not a primitive array of type {@code transferType}
* @exception ArrayIndexOutOfBoundsException if
- * <code>pixel</code> is not large enough to hold a pixel value
- * for this <code>ColorModel</code>, or if <code>components</code>
- * is not <code>null</code> and is not large enough to hold all the
- * color and alpha components, starting at <code>offset</code>
+ * {@code pixel} is not large enough to hold a pixel value
+ * for this {@code ColorModel}, or if {@code components}
+ * is not {@code null} and is not large enough to hold all the
+ * color and alpha components, starting at {@code offset}
* @exception UnsupportedOperationException if this
- * <code>transferType</code> is not supported by this
+ * {@code transferType} is not supported by this
* color model
*/
public final int[] getComponents(Object pixel, int[] components,
int offset) {
int intpixel=0;
@@ -996,18 +996,18 @@
}
return getComponents(intpixel, components, offset);
}
/**
- * 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>.
- * @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
+ * Creates a {@code WritableRaster} with the specified width and
+ * height that has a data layout ({@code SampleModel}) compatible
+ * with this {@code ColorModel}.
+ * @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 IllegalArgumentException if <code>w</code> or <code>h</code>
+ * @throws IllegalArgumentException if {@code w} or {@code h}
* is less than or equal to zero
* @see WritableRaster
* @see SampleModel
*/
public final WritableRaster createCompatibleWritableRaster (int w,
@@ -1041,26 +1041,26 @@
w,h,bandmasks,null);
}
}
/**
- * Returns a pixel value represented as an <code>int</code> in this
- * <code>ColorModel</code>, given an array of unnormalized color/alpha
- * components. An <code>ArrayIndexOutOfBoundsException</code> is
- * thrown if the <code>components</code> array is
+ * Returns a pixel value represented as an {@code int} in this
+ * {@code ColorModel}, given an array of unnormalized color/alpha
+ * components. 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>.
+ * at {@code offset}.
* @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.
* @exception 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}
*/
public int getDataElement(int[] components, int offset) {
int pixel = 0;
for (int i=0; i < numComponents; i++) {
pixel |= ((components[offset+i]<<maskOffsets[i])&maskArray[i]);
@@ -1068,46 +1068,46 @@
return pixel;
}
/**
* 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.
- * An <code>ArrayIndexOutOfBoundsException</code> is thrown if the
- * <code>components</code> array
+ * This array can then be passed to the {@code setDataElements}
+ * method of a {@code WritableRaster} object.
+ * An {@code ArrayIndexOutOfBoundsException} is thrown if the
+ * {@code components} array
* is not large enough to hold all the color and alpha components,
- * starting at offset. If the <code>obj</code> variable is
- * <code>null</code>, a new array is allocated. If <code>obj</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>obj</code> is not large enough to hold a pixel value for this
- * <code>ColorModel</code>.
- * Since <code>DirectColorModel</code> can be subclassed, subclasses
+ * starting at offset. If the {@code obj} variable is
+ * {@code null}, a new array is allocated. If {@code obj} 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 obj} is not large enough to hold a pixel value for this
+ * {@code ColorModel}.
+ * Since {@code DirectColorModel} can be subclassed, subclasses
* inherit the implementation of this method and if they don't
* override it then they throw an exception if they use an unsupported
- * <code>transferType</code>.
+ * {@code transferType}.
* @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.
- * @exception ClassCastException if <code>obj</code>
- * is not a primitive array of type <code>transferType</code>
+ * @exception ClassCastException if {@code obj}
+ * is not a primitive array of type {@code transferType}
* @exception 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}
* @exception UnsupportedOperationException if this
- * <code>transferType</code> is not supported by this
+ * {@code transferType} is not supported by this
* color model
* @see WritableRaster#setDataElements
* @see SampleModel#setDataElements
*/
public Object getDataElements(int[] components, int offset, Object obj) {
@@ -1149,30 +1149,30 @@
}
}
/**
* 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 this transferType is
- * not supported by this <code>ColorModel</code>. Since
- * <code>ColorModel</code> can be subclassed, subclasses inherit the
+ * {@code UnsupportedOperationException} if this transferType is
+ * not supported by this {@code ColorModel}. Since
+ * {@code ColorModel} can be subclassed, subclasses inherit the
* implementation of this method and if they don't override it then
* they throw an exception if they use an unsupported transferType.
*
- * @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
+ * @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.
* @exception UnsupportedOperationException if this
- * <code>transferType</code> is not supported by this
+ * {@code transferType} is not supported by this
* color model
*/
public final ColorModel coerceData (WritableRaster raster,
boolean isAlphaPremultiplied)
{
@@ -1341,16 +1341,16 @@
transferType);
}
/**
- * 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.
* @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>; <code>false</code> otherwise.
+ * @return {@code true} if {@code raster} is compatible
+ * with this {@code ColorModel}; {@code false} otherwise.
*/
public boolean isCompatibleRaster(Raster raster) {
SampleModel sm = raster.getSampleModel();
SinglePixelPackedSampleModel spsm;
if (sm instanceof SinglePixelPackedSampleModel) {
@@ -1399,14 +1399,14 @@
}
}
}
/**
- * Returns a <code>String</code> that represents this
- * <code>DirectColorModel</code>.
- * @return a <code>String</code> representing this
- * <code>DirectColorModel</code>.
+ * Returns a {@code String} that represents this
+ * {@code DirectColorModel}.
+ * @return a {@code String} representing this
+ * {@code DirectColorModel}.
*/
public String toString() {
return new String("DirectColorModel: rmask="
+Integer.toHexString(red_mask)+" gmask="
+Integer.toHexString(green_mask)+" bmask="
< prev index next >