< prev index next >

src/java.desktop/share/classes/java/awt/image/ComponentColorModel.java

Print this page

        

@@ -27,32 +27,32 @@
 
 import java.awt.color.ColorSpace;
 import java.awt.color.ICC_ColorSpace;
 
 /**
- * A <CODE>ColorModel</CODE> class that works with pixel values that
+ * A {@code ColorModel} class that works with pixel values that
  * represent color and alpha information as separate samples and that
  * store each sample in a separate data element.  This class can be
- * used with an arbitrary <CODE>ColorSpace</CODE>.  The number of
+ * used with an arbitrary {@code ColorSpace}.  The number of
  * color samples in the pixel values must be same as the number of
- * color components in the <CODE>ColorSpace</CODE>. There may be a
+ * color components in the {@code ColorSpace}. There may be a
  * single alpha sample.
  * <p>
  * For those methods that use
- * a primitive array pixel representation of type <CODE>transferType</CODE>,
+ * a primitive array pixel representation of type {@code transferType},
  * the array length is the same as the number of color and alpha samples.
  * Color samples are stored first in the array followed by the alpha
  * sample, if present.  The order of the color samples is specified
- * by the <CODE>ColorSpace</CODE>.  Typically, this order reflects the
- * name of the color space type. For example, for <CODE>TYPE_RGB</CODE>,
+ * by the {@code ColorSpace}.  Typically, this order reflects the
+ * name of the color space type. For example, for {@code TYPE_RGB},
  * index 0 corresponds to red, index 1 to green, and index 2 to blue.
  * <p>
  * The translation from pixel sample values to color/alpha components for
  * display or processing purposes is based on a one-to-one correspondence of
  * samples to components.
  * Depending on the transfer type used to create an instance of
- * <code>ComponentColorModel</code>, the pixel sample values
+ * {@code ComponentColorModel}, the pixel sample values
  * represented by that instance may be signed or unsigned and may
  * be of integral type or float or double (see below for details).
  * The translation from sample values to normalized color/alpha components
  * must follow certain rules.  For float and double samples, the translation
  * is an identity, i.e. normalized component values are equal to the

@@ -60,113 +60,113 @@
  * should be only a simple scale and offset, where the scale and offset
  * constants may be different for each component.  The result of
  * applying the scale and offset constants is a set of color/alpha
  * component values, which are guaranteed to fall within a certain
  * range.  Typically, the range for a color component will be the range
- * defined by the <code>getMinValue</code> and <code>getMaxValue</code>
- * methods of the <code>ColorSpace</code> class.  The range for an
+ * defined by the {@code getMinValue} and {@code getMaxValue}
+ * methods of the {@code ColorSpace} class.  The range for an
  * alpha component should be 0.0 to 1.0.
  * <p>
- * Instances of <code>ComponentColorModel</code> created with transfer types
- * <CODE>DataBuffer.TYPE_BYTE</CODE>, <CODE>DataBuffer.TYPE_USHORT</CODE>,
- * and <CODE>DataBuffer.TYPE_INT</CODE> have pixel sample values which
+ * Instances of {@code ComponentColorModel} created with transfer types
+ * {@code DataBuffer.TYPE_BYTE}, {@code DataBuffer.TYPE_USHORT},
+ * and {@code DataBuffer.TYPE_INT} have pixel sample values which
  * are treated as unsigned integral values.
  * The number of bits in a color or alpha sample of a pixel value might not
  * be the same as the number of bits for the corresponding color or alpha
  * sample passed to the
- * <code>ComponentColorModel(ColorSpace, int[], boolean, boolean, int, int)</code>
+ * {@code ComponentColorModel(ColorSpace, int[], boolean, boolean, int, int)}
  * constructor.  In
  * that case, this class assumes that the least significant n bits of a sample
  * value hold the component value, where n is the number of significant bits
  * for the component passed to the constructor.  It also assumes that
  * any higher-order bits in a sample value are zero.  Thus, sample values
  * range from 0 to 2<sup>n</sup> - 1.  This class maps these sample values
  * to normalized color component values such that 0 maps to the value
- * obtained from the <code>ColorSpace's</code> <code>getMinValue</code>
+ * obtained from the {@code ColorSpace's getMinValue}
  * method for each component and 2<sup>n</sup> - 1 maps to the value
- * obtained from <code>getMaxValue</code>.  To create a
- * <code>ComponentColorModel</code> with a different color sample mapping
+ * obtained from {@code getMaxValue}.  To create a
+ * {@code ComponentColorModel} with a different color sample mapping
  * requires subclassing this class and overriding the
- * <code>getNormalizedComponents(Object, float[], int)</code> method.
+ * {@code getNormalizedComponents(Object, float[], int)} method.
  * The mapping for an alpha sample always maps 0 to 0.0 and
  * 2<sup>n</sup> - 1 to 1.0.
  * <p>
  * For instances with unsigned sample values,
  * the unnormalized color/alpha component representation is only
  * supported if two conditions hold.  First, sample value 0 must
  * map to normalized component value 0.0 and sample value 2<sup>n</sup> - 1
  * to 1.0.  Second the min/max range of all color components of the
- * <code>ColorSpace</code> must be 0.0 to 1.0.  In this case, the
+ * {@code ColorSpace} must be 0.0 to 1.0.  In this case, the
  * component representation is the n least
  * significant bits of the corresponding sample.  Thus 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 these conditions are not met, any method taking an unnormalized
- * component argument will throw an <code>IllegalArgumentException</code>.
+ * component argument will throw an {@code IllegalArgumentException}.
  * <p>
- * Instances of <code>ComponentColorModel</code> created with transfer types
- * <CODE>DataBuffer.TYPE_SHORT</CODE>, <CODE>DataBuffer.TYPE_FLOAT</CODE>, and
- * <CODE>DataBuffer.TYPE_DOUBLE</CODE> have pixel sample values which
+ * Instances of {@code ComponentColorModel} created with transfer types
+ * {@code DataBuffer.TYPE_SHORT}, {@code DataBuffer.TYPE_FLOAT}, and
+ * {@code DataBuffer.TYPE_DOUBLE} have pixel sample values which
  * are treated as signed short, float, or double values.
  * Such instances do not support the unnormalized color/alpha component
  * representation, so any methods taking such a representation as an argument
- * will throw an <code>IllegalArgumentException</code> when called on one
+ * will throw an {@code IllegalArgumentException} when called on one
  * of these instances.  The normalized component values of instances
  * of this class have a range which depends on the transfer
  * type as follows: for float samples, the full range of the float data
  * type; for double samples, the full range of the float data type
  * (resulting from casting double to float); for short samples,
  * from approximately -maxVal to +maxVal, where maxVal is the per
- * component maximum value for the <code>ColorSpace</code>
+ * component maximum value for the {@code ColorSpace}
  * (-32767 maps to -maxVal, 0 maps to 0.0, and 32767 maps
  * to +maxVal).  A subclass may override the scaling for short sample
  * values to normalized component values by overriding the
- * <code>getNormalizedComponents(Object, float[], int)</code> method.
+ * {@code getNormalizedComponents(Object, float[], int)} method.
  * For float and double samples, the normalized component values are
  * taken to be equal to the corresponding sample values, and subclasses
  * should not attempt to add any non-identity scaling for these transfer
  * types.
  * <p>
- * Instances of <code>ComponentColorModel</code> created with transfer types
- * <CODE>DataBuffer.TYPE_SHORT</CODE>, <CODE>DataBuffer.TYPE_FLOAT</CODE>, and
- * <CODE>DataBuffer.TYPE_DOUBLE</CODE>
+ * Instances of {@code ComponentColorModel} created with transfer types
+ * {@code DataBuffer.TYPE_SHORT}, {@code DataBuffer.TYPE_FLOAT}, and
+ * {@code DataBuffer.TYPE_DOUBLE}
  * use all the bits of all sample values.  Thus all color/alpha components
- * have 16 bits when using <CODE>DataBuffer.TYPE_SHORT</CODE>, 32 bits when
- * using <CODE>DataBuffer.TYPE_FLOAT</CODE>, and 64 bits when using
- * <CODE>DataBuffer.TYPE_DOUBLE</CODE>.  When the
- * <code>ComponentColorModel(ColorSpace, int[], boolean, boolean, int, int)</code>
+ * have 16 bits when using {@code DataBuffer.TYPE_SHORT}, 32 bits when
+ * using {@code DataBuffer.TYPE_FLOAT}, and 64 bits when using
+ * {@code DataBuffer.TYPE_DOUBLE}.  When the
+ * {@code ComponentColorModel(ColorSpace, int[], boolean, boolean, int, int)}
  * form of constructor is used with one of these transfer types, the
  * bits array argument is ignored.
  * <p>
  * It is possible to have color/alpha sample values
  * which cannot be reasonably interpreted as component values for rendering.
- * This can happen when <code>ComponentColorModel</code> is subclassed to
+ * This can happen when {@code ComponentColorModel} is subclassed to
  * override the mapping of unsigned sample values to normalized color
  * component values or when signed sample values outside a certain range
  * are used.  (As an example, specifying an alpha component as a signed
  * short value outside the range 0 to 32767, normalized range 0.0 to 1.0, can
  * lead to unexpected results.) It is the
  * responsibility of applications to appropriately scale pixel data before
  * rendering such that color components fall within the normalized range
- * of the <code>ColorSpace</code> (obtained using the <code>getMinValue</code>
- * and <code>getMaxValue</code> methods of the <code>ColorSpace</code> class)
+ * of the {@code ColorSpace} (obtained using the {@code getMinValue}
+ * and {@code getMaxValue} methods of the {@code ColorSpace} class)
  * and the alpha component is between 0.0 and 1.0.  If color or alpha
  * component values fall outside these ranges, rendering results are
  * indeterminate.
  * <p>
  * Methods that use a single int pixel representation throw
- * an <CODE>IllegalArgumentException</CODE>, unless the number of components
- * for the <CODE>ComponentColorModel</CODE> is one and the component
+ * an {@code IllegalArgumentException}, unless the number of components
+ * for the {@code ComponentColorModel} is one and the component
  * value is unsigned -- in other words,  a single color component using
- * a transfer type of <CODE>DataBuffer.TYPE_BYTE</CODE>,
- * <CODE>DataBuffer.TYPE_USHORT</CODE>, or <CODE>DataBuffer.TYPE_INT</CODE>
+ * a transfer type of {@code DataBuffer.TYPE_BYTE},
+ * {@code DataBuffer.TYPE_USHORT}, or {@code DataBuffer.TYPE_INT}
  * and no alpha.
  * <p>
- * A <CODE>ComponentColorModel</CODE> can be used in conjunction with a
- * <CODE>ComponentSampleModel</CODE>, a <CODE>BandedSampleModel</CODE>,
- * or a <CODE>PixelInterleavedSampleModel</CODE> to construct a
- * <CODE>BufferedImage</CODE>.
+ * A {@code ComponentColorModel} can be used in conjunction with a
+ * {@code ComponentSampleModel}, a {@code BandedSampleModel},
+ * or a {@code PixelInterleavedSampleModel} to construct a
+ * {@code BufferedImage}.
  *
  * @see ColorModel
  * @see ColorSpace
  * @see ComponentSampleModel
  * @see BandedSampleModel

@@ -175,14 +175,14 @@
  *
  */
 public class ComponentColorModel extends ColorModel {
 
     /**
-     * <code>signed</code>  is <code>true</code> for <code>short</code>,
-     * <code>float</code>, and <code>double</code> transfer types; it
-     * is <code>false</code> for <code>byte</code>, <code>ushort</code>,
-     * and <code>int</code> transfer types.
+     * {@code signed}  is {@code true} for {@code short},
+     * {@code float}, and {@code double} transfer types; it
+     * is {@code false} for {@code byte}, {@code ushort},
+     * and {@code int} transfer types.
      */
     private boolean signed; // true for transfer types short, float, double
                             // false for byte, ushort, int
     private boolean is_sRGB_stdScale;
     private boolean is_LinearRGB_stdScale;

@@ -200,68 +200,68 @@
     private float[] diffMinMax;
     private float[] compOffset;
     private float[] compScale;
 
     /**
-     * Constructs a <CODE>ComponentColorModel</CODE> from the specified
+     * Constructs a {@code ComponentColorModel} from the specified
      * parameters. Color components will be in the specified
-     * <CODE>ColorSpace</CODE>.  The supported transfer types are
-     * <CODE>DataBuffer.TYPE_BYTE</CODE>, <CODE>DataBuffer.TYPE_USHORT</CODE>,
-     * <CODE>DataBuffer.TYPE_INT</CODE>,
-     * <CODE>DataBuffer.TYPE_SHORT</CODE>, <CODE>DataBuffer.TYPE_FLOAT</CODE>,
-     * and <CODE>DataBuffer.TYPE_DOUBLE</CODE>.
-     * If not null, the <CODE>bits</CODE> array specifies the
+     * {@code ColorSpace}.  The supported transfer types are
+     * {@code DataBuffer.TYPE_BYTE}, {@code DataBuffer.TYPE_USHORT},
+     * {@code DataBuffer.TYPE_INT},
+     * {@code DataBuffer.TYPE_SHORT}, {@code DataBuffer.TYPE_FLOAT},
+     * and {@code DataBuffer.TYPE_DOUBLE}.
+     * If not null, the {@code bits} array specifies the
      * number of significant bits per color and alpha component and its
      * length should be at least the number of components in the
-     * <CODE>ColorSpace</CODE> if there is no alpha
+     * {@code ColorSpace} if there is no alpha
      * information in the pixel values, or one more than this number if
-     * there is alpha information.  When the <CODE>transferType</CODE> is
-     * <CODE>DataBuffer.TYPE_SHORT</CODE>, <CODE>DataBuffer.TYPE_FLOAT</CODE>,
-     * or <CODE>DataBuffer.TYPE_DOUBLE</CODE> the <CODE>bits</CODE> array
-     * argument is ignored.  <CODE>hasAlpha</CODE> indicates whether alpha
-     * information is present.  If <CODE>hasAlpha</CODE> is true, then
-     * the boolean <CODE>isAlphaPremultiplied</CODE>
+     * there is alpha information.  When the {@code transferType} is
+     * {@code DataBuffer.TYPE_SHORT}, {@code DataBuffer.TYPE_FLOAT},
+     * or {@code DataBuffer.TYPE_DOUBLE} the {@code bits} array
+     * argument is ignored.  {@code hasAlpha} indicates whether alpha
+     * information is present.  If {@code hasAlpha} is true, then
+     * the boolean {@code isAlphaPremultiplied}
      * specifies how to interpret color and alpha samples in pixel values.
      * If the boolean is true, color samples are assumed to have been
-     * multiplied by the alpha sample. The <CODE>transparency</CODE>
+     * multiplied by the alpha sample. The {@code transparency}
      * specifies what alpha values can be represented by this color model.
-     * The acceptable <code>transparency</code> values are
-     * <CODE>OPAQUE</CODE>, <CODE>BITMASK</CODE> or <CODE>TRANSLUCENT</CODE>.
-     * The <CODE>transferType</CODE> is the type of primitive array used
+     * The acceptable {@code transparency} values are
+     * {@code OPAQUE}, {@code BITMASK} or {@code TRANSLUCENT}.
+     * The {@code transferType} is the type of primitive array used
      * to represent pixel values.
      *
-     * @param colorSpace       The <CODE>ColorSpace</CODE> associated
+     * @param colorSpace       The {@code ColorSpace} associated
      *                         with this color model.
      * @param bits             The number of significant bits per component.
      *                         May be null, in which case all bits of all
      *                         component samples will be significant.
      *                         Ignored if transferType is one of
-     *                         <CODE>DataBuffer.TYPE_SHORT</CODE>,
-     *                         <CODE>DataBuffer.TYPE_FLOAT</CODE>, or
-     *                         <CODE>DataBuffer.TYPE_DOUBLE</CODE>,
+     *                         {@code DataBuffer.TYPE_SHORT},
+     *                         {@code DataBuffer.TYPE_FLOAT}, or
+     *                         {@code DataBuffer.TYPE_DOUBLE},
      *                         in which case all bits of all component
      *                         samples will be significant.
      * @param hasAlpha         If true, this color model supports alpha.
      * @param isAlphaPremultiplied If true, alpha is premultiplied.
      * @param transparency     Specifies what alpha values can be represented
      *                         by this color model.
      * @param transferType     Specifies the type of primitive array used to
      *                         represent pixel values.
      *
-     * @throws IllegalArgumentException If the <CODE>bits</CODE> array
+     * @throws IllegalArgumentException If the {@code bits} array
      *         argument is not null, its length is less than the number of
      *         color and alpha components, and transferType is one of
-     *         <CODE>DataBuffer.TYPE_BYTE</CODE>,
-     *         <CODE>DataBuffer.TYPE_USHORT</CODE>, or
-     *         <CODE>DataBuffer.TYPE_INT</CODE>.
+     *         {@code DataBuffer.TYPE_BYTE},
+     *         {@code DataBuffer.TYPE_USHORT}, or
+     *         {@code DataBuffer.TYPE_INT}.
      * @throws IllegalArgumentException If transferType is not one of
-     *         <CODE>DataBuffer.TYPE_BYTE</CODE>,
-     *         <CODE>DataBuffer.TYPE_USHORT</CODE>,
-     *         <CODE>DataBuffer.TYPE_INT</CODE>,
-     *         <CODE>DataBuffer.TYPE_SHORT</CODE>,
-     *         <CODE>DataBuffer.TYPE_FLOAT</CODE>, or
-     *         <CODE>DataBuffer.TYPE_DOUBLE</CODE>.
+     *         {@code DataBuffer.TYPE_BYTE},
+     *         {@code DataBuffer.TYPE_USHORT},
+     *         {@code DataBuffer.TYPE_INT},
+     *         {@code DataBuffer.TYPE_SHORT},
+     *         {@code DataBuffer.TYPE_FLOAT}, or
+     *         {@code DataBuffer.TYPE_DOUBLE}.
      *
      * @see ColorSpace
      * @see java.awt.Transparency
      */
     public ComponentColorModel (ColorSpace colorSpace,

@@ -298,48 +298,48 @@
         }
         setupLUTs();
     }
 
     /**
-     * Constructs a <CODE>ComponentColorModel</CODE> from the specified
+     * Constructs a {@code ComponentColorModel} from the specified
      * parameters. Color components will be in the specified
-     * <CODE>ColorSpace</CODE>.  The supported transfer types are
-     * <CODE>DataBuffer.TYPE_BYTE</CODE>, <CODE>DataBuffer.TYPE_USHORT</CODE>,
-     * <CODE>DataBuffer.TYPE_INT</CODE>,
-     * <CODE>DataBuffer.TYPE_SHORT</CODE>, <CODE>DataBuffer.TYPE_FLOAT</CODE>,
-     * and <CODE>DataBuffer.TYPE_DOUBLE</CODE>.  The number of significant
+     * {@code ColorSpace}.  The supported transfer types are
+     * {@code DataBuffer.TYPE_BYTE}, {@code DataBuffer.TYPE_USHORT},
+     * {@code DataBuffer.TYPE_INT},
+     * {@code DataBuffer.TYPE_SHORT}, {@code DataBuffer.TYPE_FLOAT},
+     * and {@code DataBuffer.TYPE_DOUBLE}.  The number of significant
      * bits per color and alpha component will be 8, 16, 32, 16, 32,  or 64,
      * respectively.  The number of color components will be the
-     * number of components in the <CODE>ColorSpace</CODE>.  There will be
-     * an alpha component if <CODE>hasAlpha</CODE> is <CODE>true</CODE>.
-     * If <CODE>hasAlpha</CODE> is true, then
-     * the boolean <CODE>isAlphaPremultiplied</CODE>
+     * number of components in the {@code ColorSpace}.  There will be
+     * an alpha component if {@code hasAlpha} is {@code true}.
+     * If {@code hasAlpha} is true, then
+     * the boolean {@code isAlphaPremultiplied}
      * specifies how to interpret color and alpha samples in pixel values.
      * If the boolean is true, color samples are assumed to have been
-     * multiplied by the alpha sample. The <CODE>transparency</CODE>
+     * multiplied by the alpha sample. The {@code transparency}
      * specifies what alpha values can be represented by this color model.
-     * The acceptable <code>transparency</code> values are
-     * <CODE>OPAQUE</CODE>, <CODE>BITMASK</CODE> or <CODE>TRANSLUCENT</CODE>.
-     * The <CODE>transferType</CODE> is the type of primitive array used
+     * The acceptable {@code transparency} values are
+     * {@code OPAQUE}, {@code BITMASK} or {@code TRANSLUCENT}.
+     * The {@code transferType} is the type of primitive array used
      * to represent pixel values.
      *
-     * @param colorSpace       The <CODE>ColorSpace</CODE> associated
+     * @param colorSpace       The {@code ColorSpace} associated
      *                         with this color model.
      * @param hasAlpha         If true, this color model supports alpha.
      * @param isAlphaPremultiplied If true, alpha is premultiplied.
      * @param transparency     Specifies what alpha values can be represented
      *                         by this color model.
      * @param transferType     Specifies the type of primitive array used to
      *                         represent pixel values.
      *
      * @throws IllegalArgumentException If transferType is not one of
-     *         <CODE>DataBuffer.TYPE_BYTE</CODE>,
-     *         <CODE>DataBuffer.TYPE_USHORT</CODE>,
-     *         <CODE>DataBuffer.TYPE_INT</CODE>,
-     *         <CODE>DataBuffer.TYPE_SHORT</CODE>,
-     *         <CODE>DataBuffer.TYPE_FLOAT</CODE>, or
-     *         <CODE>DataBuffer.TYPE_DOUBLE</CODE>.
+     *         {@code DataBuffer.TYPE_BYTE},
+     *         {@code DataBuffer.TYPE_USHORT},
+     *         {@code DataBuffer.TYPE_INT},
+     *         {@code DataBuffer.TYPE_SHORT},
+     *         {@code DataBuffer.TYPE_FLOAT}, or
+     *         {@code DataBuffer.TYPE_DOUBLE}.
      *
      * @see ColorSpace
      * @see java.awt.Transparency
      * @since 1.4
      */

@@ -660,13 +660,13 @@
      * @param pixel The pixel from which you want to get the red color component.
      *
      * @return The red color component for the specified pixel, as an int.
      *
      * @throws IllegalArgumentException If there is more than
-     * one component in this <CODE>ColorModel</CODE>.
+     * one component in this {@code ColorModel}.
      * @throws IllegalArgumentException If the component value for this
-     * <CODE>ColorModel</CODE> is signed
+     * {@code ColorModel} is signed
      */
     public int getRed(int pixel) {
         return getRGBComponent(pixel, 0);
     }
 

@@ -682,13 +682,13 @@
      * @param pixel The pixel from which you want to get the green color component.
      *
      * @return The green color component for the specified pixel, as an int.
      *
      * @throws IllegalArgumentException If there is more than
-     * one component in this <CODE>ColorModel</CODE>.
+     * one component in this {@code ColorModel}.
      * @throws IllegalArgumentException If the component value for this
-     * <CODE>ColorModel</CODE> is signed
+     * {@code ColorModel} is signed
      */
     public int getGreen(int pixel) {
         return getRGBComponent(pixel, 1);
     }
 

@@ -704,13 +704,13 @@
      * @param pixel The pixel from which you want to get the blue color component.
      *
      * @return The blue color component for the specified pixel, as an int.
      *
      * @throws IllegalArgumentException If there is more than
-     * one component in this <CODE>ColorModel</CODE>.
+     * one component in this {@code ColorModel}.
      * @throws IllegalArgumentException If the component value for this
-     * <CODE>ColorModel</CODE> is signed
+     * {@code ColorModel} is signed
      */
     public int getBlue(int pixel) {
         return getRGBComponent(pixel, 2);
     }
 

@@ -721,13 +721,13 @@
      * @param pixel The pixel from which you want to get the alpha component.
      *
      * @return The alpha component for the specified pixel, as an int.
      *
      * @throws IllegalArgumentException If there is more than
-     * one component in this <CODE>ColorModel</CODE>.
+     * one component in this {@code ColorModel}.
      * @throws IllegalArgumentException If the component value for this
-     * <CODE>ColorModel</CODE> is signed
+     * {@code ColorModel} is signed
      */
     public int getAlpha(int pixel) {
         if (supportsAlpha == false) {
             return 255;
         }

@@ -753,13 +753,13 @@
      * @param pixel The pixel from which you want to get the color/alpha components.
      *
      * @return The color/alpha components for the specified pixel, as an int.
      *
      * @throws IllegalArgumentException If there is more than
-     * one component in this <CODE>ColorModel</CODE>.
+     * one component in this {@code ColorModel}.
      * @throws IllegalArgumentException If the component value for this
-     * <CODE>ColorModel</CODE> is signed
+     * {@code ColorModel} is signed
      */
     public int getRGB(int pixel) {
         if (numComponents > 1) {
             throw new
                 IllegalArgumentException("More than one component per pixel");

@@ -911,137 +911,137 @@
     }
 
     /**
      * 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 <CODE>pixel</CODE> value is specified by an array
-     * of data elements of type <CODE>transferType</CODE> passed in as an object
+     * is done if necessary.  The {@code pixel} value is specified by an array
+     * of data elements of type {@code transferType} passed in as an object
      * reference. The returned value will be a non pre-multiplied value. If the
      * alpha is premultiplied, this method divides it out before returning
      * the value (if the alpha value is 0, the red value will be 0). Since
-     * <code>ComponentColorModel</code> can be subclassed, subclasses
+     * {@code ComponentColorModel} 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 pixel from which you want to get the red color component,
-     * specified by an array of data elements of type <CODE>transferType</CODE>.
+     * specified by an array of data elements of type {@code transferType}.
      *
      * @return The red color component for the specified pixel, as an int.
      *
-     * @throws ClassCastException If <CODE>inData</CODE> is not a primitive array
-     * of type <CODE>transferType</CODE>.
-     * @throws ArrayIndexOutOfBoundsException if <CODE>inData</CODE> is not
+     * @throws ClassCastException If {@code inData} is not a primitive array
+     * of type {@code transferType}.
+     * @throws ArrayIndexOutOfBoundsException if {@code inData} is not
      * large enough to hold a pixel value for this
-     * <CODE>ColorModel</CODE>.
+     * {@code ColorModel}.
      * @throws UnsupportedOperationException If the transfer type of
-     * this <CODE>ComponentColorModel</CODE>
+     * this {@code ComponentColorModel}
      * is not one of the supported transfer types:
-     * <CODE>DataBuffer.TYPE_BYTE</CODE>, <CODE>DataBuffer.TYPE_USHORT</CODE>,
-     * <CODE>DataBuffer.TYPE_INT</CODE>, <CODE>DataBuffer.TYPE_SHORT</CODE>,
-     * <CODE>DataBuffer.TYPE_FLOAT</CODE>, or <CODE>DataBuffer.TYPE_DOUBLE</CODE>.
+     * {@code DataBuffer.TYPE_BYTE}, {@code DataBuffer.TYPE_USHORT},
+     * {@code DataBuffer.TYPE_INT}, {@code DataBuffer.TYPE_SHORT},
+     * {@code DataBuffer.TYPE_FLOAT}, or {@code DataBuffer.TYPE_DOUBLE}.
      */
     public int getRed(Object inData) {
         return getRGBComponent(inData, 0);
     }
 
 
     /**
      * Returns the green color component for the specified pixel, scaled
-     * from 0 to 255 in the default RGB <CODE>ColorSpace</CODE>, sRGB.
-     * A color conversion is done if necessary.  The <CODE>pixel</CODE> value
-     * is specified by an array of data elements of type <CODE>transferType</CODE>
+     * from 0 to 255 in the default RGB {@code ColorSpace}, sRGB.
+     * A color conversion is done if necessary.  The {@code pixel} value
+     * is specified 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. If the alpha is premultiplied, this method divides it out before
      * returning the value (if the alpha value is 0, the green value will be 0).
-     * Since <code>ComponentColorModel</code> can be subclassed,
+     * Since {@code ComponentColorModel} 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>.
+     * unsupported {@code transferType}.
      *
      * @param inData The pixel from which you want to get the green color component,
-     * specified by an array of data elements of type <CODE>transferType</CODE>.
+     * specified by an array of data elements of type {@code transferType}.
      *
      * @return The green color component for the specified pixel, as an int.
      *
-     * @throws ClassCastException If <CODE>inData</CODE> is not a primitive array
-     * of type <CODE>transferType</CODE>.
-     * @throws ArrayIndexOutOfBoundsException if <CODE>inData</CODE> is not
+     * @throws ClassCastException If {@code inData} is not a primitive array
+     * of type {@code transferType}.
+     * @throws ArrayIndexOutOfBoundsException if {@code inData} is not
      * large enough to hold a pixel value for this
-     * <CODE>ColorModel</CODE>.
+     * {@code ColorModel}.
      * @throws UnsupportedOperationException If the transfer type of
-     * this <CODE>ComponentColorModel</CODE>
+     * this {@code ComponentColorModel}
      * is not one of the supported transfer types:
-     * <CODE>DataBuffer.TYPE_BYTE</CODE>, <CODE>DataBuffer.TYPE_USHORT</CODE>,
-     * <CODE>DataBuffer.TYPE_INT</CODE>, <CODE>DataBuffer.TYPE_SHORT</CODE>,
-     * <CODE>DataBuffer.TYPE_FLOAT</CODE>, or <CODE>DataBuffer.TYPE_DOUBLE</CODE>.
+     * {@code DataBuffer.TYPE_BYTE}, {@code DataBuffer.TYPE_USHORT},
+     * {@code DataBuffer.TYPE_INT}, {@code DataBuffer.TYPE_SHORT},
+     * {@code DataBuffer.TYPE_FLOAT}, or {@code DataBuffer.TYPE_DOUBLE}.
      */
     public int getGreen(Object inData) {
         return getRGBComponent(inData, 1);
     }
 
 
     /**
      * Returns the blue color component for the specified pixel, scaled
-     * from 0 to 255 in the default RGB <CODE>ColorSpace</CODE>, sRGB.
-     * A color conversion is done if necessary.  The <CODE>pixel</CODE> value is
-     * specified by an array of data elements of type <CODE>transferType</CODE>
+     * from 0 to 255 in the default RGB {@code ColorSpace}, sRGB.
+     * A color conversion is done if necessary.  The {@code pixel} value is
+     * specified 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. 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).
-     * Since <code>ComponentColorModel</code> can be subclassed,
+     * Since {@code ComponentColorModel} 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>.
+     * unsupported {@code transferType}.
      *
      * @param inData The pixel from which you want to get the blue color component,
-     * specified by an array of data elements of type <CODE>transferType</CODE>.
+     * specified by an array of data elements of type {@code transferType}.
      *
      * @return The blue color component for the specified pixel, as an int.
      *
-     * @throws ClassCastException If <CODE>inData</CODE> is not a primitive array
-     * of type <CODE>transferType</CODE>.
-     * @throws ArrayIndexOutOfBoundsException if <CODE>inData</CODE> is not
+     * @throws ClassCastException If {@code inData} is not a primitive array
+     * of type {@code transferType}.
+     * @throws ArrayIndexOutOfBoundsException if {@code inData} is not
      * large enough to hold a pixel value for this
-     * <CODE>ColorModel</CODE>.
+     * {@code ColorModel}.
      * @throws UnsupportedOperationException If the transfer type of
-     * this <CODE>ComponentColorModel</CODE>
+     * this {@code ComponentColorModel}
      * is not one of the supported transfer types:
-     * <CODE>DataBuffer.TYPE_BYTE</CODE>, <CODE>DataBuffer.TYPE_USHORT</CODE>,
-     * <CODE>DataBuffer.TYPE_INT</CODE>, <CODE>DataBuffer.TYPE_SHORT</CODE>,
-     * <CODE>DataBuffer.TYPE_FLOAT</CODE>, or <CODE>DataBuffer.TYPE_DOUBLE</CODE>.
+     * {@code DataBuffer.TYPE_BYTE}, {@code DataBuffer.TYPE_USHORT},
+     * {@code DataBuffer.TYPE_INT}, {@code DataBuffer.TYPE_SHORT},
+     * {@code DataBuffer.TYPE_FLOAT}, or {@code DataBuffer.TYPE_DOUBLE}.
      */
     public int getBlue(Object inData) {
         return getRGBComponent(inData, 2);
     }
 
     /**
      * 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 reference.  Since <code>ComponentColorModel</code> can be
+     * elements of type {@code transferType} passed in as an
+     * object reference.  Since {@code ComponentColorModel} 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 pixel from which you want to get the alpha component,
-     * specified by an array of data elements of type <CODE>transferType</CODE>.
+     * specified by an array of data elements of type {@code transferType}.
      *
      * @return The alpha component for the specified pixel, as an int.
      *
-     * @throws ClassCastException If <CODE>inData</CODE> is not a primitive array
-     * of type <CODE>transferType</CODE>.
-     * @throws ArrayIndexOutOfBoundsException if <CODE>inData</CODE> is not
+     * @throws ClassCastException If {@code inData} is not a primitive array
+     * of type {@code transferType}.
+     * @throws ArrayIndexOutOfBoundsException if {@code inData} is not
      * large enough to hold a pixel value for this
-     * <CODE>ColorModel</CODE>.
+     * {@code ColorModel}.
      * @throws UnsupportedOperationException If the transfer type of
-     * this <CODE>ComponentColorModel</CODE>
+     * this {@code ComponentColorModel}
      * is not one of the supported transfer types:
-     * <CODE>DataBuffer.TYPE_BYTE</CODE>, <CODE>DataBuffer.TYPE_USHORT</CODE>,
-     * <CODE>DataBuffer.TYPE_INT</CODE>, <CODE>DataBuffer.TYPE_SHORT</CODE>,
-     * <CODE>DataBuffer.TYPE_FLOAT</CODE>, or <CODE>DataBuffer.TYPE_DOUBLE</CODE>.
+     * {@code DataBuffer.TYPE_BYTE}, {@code DataBuffer.TYPE_USHORT},
+     * {@code DataBuffer.TYPE_INT}, {@code DataBuffer.TYPE_SHORT},
+     * {@code DataBuffer.TYPE_FLOAT}, or {@code DataBuffer.TYPE_DOUBLE}.
      */
     public int getAlpha(Object inData) {
         if (supportsAlpha == false) {
             return 255;
         }

@@ -1092,36 +1092,36 @@
 
     /**
      * 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
+     * array of data elements of type {@code transferType} passed
      * in as an object reference.
      * The returned value is in a non pre-multiplied format. If
      * the alpha is premultiplied, this method divides it out of the
      * color components (if the alpha value is 0, the color values will be 0).
-     * Since <code>ComponentColorModel</code> can be subclassed,
+     * Since {@code ComponentColorModel} 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>.
+     * unsupported {@code transferType}.
      *
      * @param inData The pixel from which you want to get the color/alpha components,
-     * specified by an array of data elements of type <CODE>transferType</CODE>.
+     * specified by an array of data elements of type {@code transferType}.
      *
      * @return The color/alpha components for the specified pixel, as an int.
      *
-     * @throws ClassCastException If <CODE>inData</CODE> is not a primitive array
-     * of type <CODE>transferType</CODE>.
-     * @throws ArrayIndexOutOfBoundsException if <CODE>inData</CODE> is not
+     * @throws ClassCastException If {@code inData} is not a primitive array
+     * of type {@code transferType}.
+     * @throws ArrayIndexOutOfBoundsException if {@code inData} is not
      * large enough to hold a pixel value for this
-     * <CODE>ColorModel</CODE>.
+     * {@code ColorModel}.
      * @throws UnsupportedOperationException If the transfer type of
-     * this <CODE>ComponentColorModel</CODE>
+     * this {@code ComponentColorModel}
      * is not one of the supported transfer types:
-     * <CODE>DataBuffer.TYPE_BYTE</CODE>, <CODE>DataBuffer.TYPE_USHORT</CODE>,
-     * <CODE>DataBuffer.TYPE_INT</CODE>, <CODE>DataBuffer.TYPE_SHORT</CODE>,
-     * <CODE>DataBuffer.TYPE_FLOAT</CODE>, or <CODE>DataBuffer.TYPE_DOUBLE</CODE>.
+     * {@code DataBuffer.TYPE_BYTE}, {@code DataBuffer.TYPE_USHORT},
+     * {@code DataBuffer.TYPE_INT}, {@code DataBuffer.TYPE_SHORT},
+     * {@code DataBuffer.TYPE_FLOAT}, or {@code DataBuffer.TYPE_DOUBLE}.
      * @see ColorModel#getRGBdefault
      */
     public int getRGB(Object inData) {
         if (needScaleInit) {
             initScale();

@@ -1148,38 +1148,38 @@
             | (((int) (rgb[2] * 255.0f + 0.5f)) << 0);
     }
 
     /**
      * Returns a data element array representation of a pixel in this
-     * <CODE>ColorModel</CODE>, given an integer pixel representation
+     * {@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
-     * <CODE>pixel</CODE>
+     * This array can then be passed to the {@code setDataElements}
+     * method of a {@code WritableRaster} object.  If the
+     * {@code pixel}
      * parameter is null, a new array is allocated.  Since
-     * <code>ComponentColorModel</code> can be subclassed, subclasses
+     * {@code ComponentColorModel} 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 representation of the pixel in the RGB
      *            color model
      * @param pixel the specified pixel
      * @return The data element array representation of a pixel
-     * in this <CODE>ColorModel</CODE>.
-     * @throws ClassCastException If <CODE>pixel</CODE> is not null and
-     * is not a primitive array of type <CODE>transferType</CODE>.
-     * @throws ArrayIndexOutOfBoundsException If <CODE>pixel</CODE> is
+     * in this {@code ColorModel}.
+     * @throws ClassCastException If {@code pixel} is not null and
+     * is not a primitive array of type {@code transferType}.
+     * @throws ArrayIndexOutOfBoundsException If {@code pixel} is
      * not large enough to hold a pixel value for this
-     * <CODE>ColorModel</CODE>.
+     * {@code ColorModel}.
      * @throws UnsupportedOperationException If the transfer type of
-     * this <CODE>ComponentColorModel</CODE>
+     * this {@code ComponentColorModel}
      * is not one of the supported transfer types:
-     * <CODE>DataBuffer.TYPE_BYTE</CODE>, <CODE>DataBuffer.TYPE_USHORT</CODE>,
-     * <CODE>DataBuffer.TYPE_INT</CODE>, <CODE>DataBuffer.TYPE_SHORT</CODE>,
-     * <CODE>DataBuffer.TYPE_FLOAT</CODE>, or <CODE>DataBuffer.TYPE_DOUBLE</CODE>.
+     * {@code DataBuffer.TYPE_BYTE}, {@code DataBuffer.TYPE_USHORT},
+     * {@code DataBuffer.TYPE_INT}, {@code DataBuffer.TYPE_SHORT},
+     * {@code DataBuffer.TYPE_FLOAT}, or {@code DataBuffer.TYPE_DOUBLE}.
      *
      * @see WritableRaster#setDataElements
      * @see SampleModel#setDataElements
      */
     public Object getDataElements(int rgb, Object pixel) {

@@ -1653,30 +1653,30 @@
         throw new IllegalArgumentException("This method has not been "+
                  "implemented for transferType " + transferType);
     }
 
    /** Returns an array of unnormalized color/alpha components given a pixel
-     * in this <CODE>ColorModel</CODE>.
+     * in this {@code ColorModel}.
      * An IllegalArgumentException is thrown if the component value for this
-     * <CODE>ColorModel</CODE> is not conveniently representable in the
+     * {@code ColorModel} is not conveniently representable in the
      * unnormalized form.  Color/alpha components are stored
-     * in the <CODE>components</CODE> array starting at <CODE>offset</CODE>
+     * in the {@code components} array starting at {@code offset}
      * (even if the array is allocated by this method).
      *
      * @param pixel The pixel value specified as an integer.
      * @param components An integer array in which to store the unnormalized
-     * color/alpha components. If the <CODE>components</CODE> array is null,
+     * color/alpha components. If the {@code components} array is null,
      * a new array is allocated.
-     * @param offset An offset into the <CODE>components</CODE> array.
+     * @param offset An offset into the {@code components} array.
      *
      * @return The components array.
      *
      * @throws IllegalArgumentException If there is more than one
-     * component in this <CODE>ColorModel</CODE>.
+     * component in this {@code ColorModel}.
      * @throws IllegalArgumentException If this
-     * <CODE>ColorModel</CODE> does not support the unnormalized form
-     * @throws ArrayIndexOutOfBoundsException If the <CODE>components</CODE>
+     * {@code ColorModel} does not support the unnormalized form
+     * @throws ArrayIndexOutOfBoundsException If the {@code components}
      * array is not null and is not large enough to hold all the color and
      * alpha components (starting at offset).
      */
     public int[] getComponents(int pixel, int[] components, int offset) {
         if (numComponents > 1) {

@@ -1699,45 +1699,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
+     * 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.
      * An IllegalArgumentException is thrown 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.
-     * 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).  Since <code>ComponentColorModel</code> can be
+     * Color/alpha components are stored in the {@code components} array
+     * starting at  {@code offset} (even if the array is allocated by
+     * this method).  Since {@code ComponentColorModel} can be
      * subclassed, subclasses inherit the
      * implementation of this method and if they don't override it then
      * this method might throw an exception if they use an unsupported
-     * <code>transferType</code>.
+     * {@code transferType}.
      *
      * @param pixel A pixel value specified by an array of data elements of
-     * type <CODE>transferType</CODE>.
+     * type {@code transferType}.
      * @param components An integer array in which to store the unnormalized
-     * color/alpha components. If the <CODE>components</CODE> array is null,
+     * color/alpha components. If the {@code components} array is null,
      * a new array is allocated.
-     * @param offset An offset into the <CODE>components</CODE> array.
+     * @param offset An offset into the {@code components} array.
      *
-     * @return The <CODE>components</CODE> array.
+     * @return The {@code components} array.
      *
      * @throws IllegalArgumentException If this
-     * <CODE>ComponentColorModel</CODE> does not support the unnormalized form
+     * {@code ComponentColorModel} does not support the unnormalized form
      * @throws UnsupportedOperationException in some cases iff the
-     * transfer type of this <CODE>ComponentColorModel</CODE>
+     * transfer type of this {@code ComponentColorModel}
      * is not one of the following transfer types:
-     * <CODE>DataBuffer.TYPE_BYTE</CODE>, <CODE>DataBuffer.TYPE_USHORT</CODE>,
-     * or <CODE>DataBuffer.TYPE_INT</CODE>.
-     * @throws ClassCastException If <CODE>pixel</CODE> is not a primitive
-     * array of type <CODE>transferType</CODE>.
-     * @throws IllegalArgumentException If the <CODE>components</CODE> array is
+     * {@code DataBuffer.TYPE_BYTE}, {@code DataBuffer.TYPE_USHORT},
+     * or {@code DataBuffer.TYPE_INT}.
+     * @throws ClassCastException If {@code pixel} is not a primitive
+     * array of type {@code transferType}.
+     * @throws IllegalArgumentException If the {@code components} array is
      * not null and is not large enough to hold all the color and alpha
-     * components (starting at offset), or if <CODE>pixel</CODE> is not large
+     * components (starting at offset), or if {@code pixel} is not large
      * enough to hold a pixel value for this ColorModel.
      */
     public int[] getComponents(Object pixel, int[] components, int offset) {
         int intpixel[];
         if (needScaleInit) {

@@ -1777,43 +1777,43 @@
      * 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 this
-     * <CODE>ComponentColorModel</CODE> does not support the unnormalized form
+     * {@code ComponentColorModel} does not support 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}
      */
     public int[] getUnnormalizedComponents(float[] normComponents,
                                            int normOffset,
                                            int[] components, int offset) {
         if (needScaleInit) {

@@ -1832,37 +1832,37 @@
      * 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}.
      * @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 this
-     * <CODE>ComponentColorModel</CODE> does not support the unnormalized form
+     * {@code ComponentColorModel} does not support the unnormalized form
      */
     public float[] getNormalizedComponents(int[] components, int offset,
                                            float[] normComponents,
                                            int normOffset) {
         if (needScaleInit) {

@@ -1876,22 +1876,22 @@
         return super.getNormalizedComponents(components, offset,
                                              normComponents, normOffset);
     }
 
     /**
-     * Returns a pixel value represented as an int in this <CODE>ColorModel</CODE>,
+     * Returns a pixel value represented as an int in this {@code ColorModel},
      * given an array of unnormalized color/alpha components.
      *
      * @param components An array of unnormalized color/alpha components.
-     * @param offset An offset into the <CODE>components</CODE> array.
+     * @param offset An offset into the {@code components} array.
      *
      * @return A pixel value represented as an int.
      *
      * @throws IllegalArgumentException If there is more than one component
-     * in this <CODE>ColorModel</CODE>.
+     * in this {@code ColorModel}.
      * @throws IllegalArgumentException If this
-     * <CODE>ComponentColorModel</CODE> does not support the unnormalized form
+     * {@code ComponentColorModel} does not support the unnormalized form
      */
     public int getDataElement(int[] components, int offset) {
         if (needScaleInit) {
             initScale();
         }

@@ -1908,45 +1908,45 @@
                                            " elements in the pixel array.");
     }
 
     /**
      * Returns a data element array representation of a pixel in this
-     * <CODE>ColorModel</CODE>, given an array of unnormalized color/alpha
-     * components. This array can then be passed to the <CODE>setDataElements</CODE>
-     * method of a <CODE>WritableRaster</CODE> object.
+     * {@code ColorModel}, given an array of unnormalized color/alpha
+     * components. This array can then be passed to the {@code setDataElements}
+     * method of a {@code WritableRaster} object.
      *
      * @param components An array of unnormalized color/alpha components.
-     * @param offset The integer offset into the <CODE>components</CODE> array.
+     * @param offset The integer offset into the {@code components} array.
      * @param obj The object in which to store the data element array
-     * representation of the pixel. If <CODE>obj</CODE> variable is null,
-     * a new array is allocated.  If <CODE>obj</CODE> is not null, it must
-     * be a primitive array of type <CODE>transferType</CODE>. 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>ComponentColorModel</code> can be subclassed, subclasses
+     * representation of the pixel. If {@code obj} variable is null,
+     * a new array is allocated.  If {@code obj} is not null, it must
+     * be a primitive array of type {@code transferType}. An
+     * {@code ArrayIndexOutOfBoundsException} is thrown if
+     * {@code obj} is not large enough to hold a pixel value
+     * for this {@code ColorModel}.  Since
+     * {@code ComponentColorModel} 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>.
+     * unsupported {@code transferType}.
      *
      * @return The data element array representation of a pixel
-     * in this <CODE>ColorModel</CODE>.
+     * in this {@code ColorModel}.
      *
      * @throws IllegalArgumentException If the components array
      * is not large enough to hold all the color and alpha components
      * (starting at offset).
-     * @throws ClassCastException If <CODE>obj</CODE> is not null and is not a
-     * primitive  array of type <CODE>transferType</CODE>.
-     * @throws ArrayIndexOutOfBoundsException If <CODE>obj</CODE> is not large
-     * enough to hold a pixel value for this <CODE>ColorModel</CODE>.
+     * @throws ClassCastException If {@code obj} is not null and is not a
+     * primitive  array of type {@code transferType}.
+     * @throws ArrayIndexOutOfBoundsException If {@code obj} is not large
+     * enough to hold a pixel value for this {@code ColorModel}.
      * @throws IllegalArgumentException If this
-     * <CODE>ComponentColorModel</CODE> does not support the unnormalized form
+     * {@code ComponentColorModel} does not support the unnormalized form
      * @throws UnsupportedOperationException If the transfer type of
-     * this <CODE>ComponentColorModel</CODE>
+     * this {@code ComponentColorModel}
      * is not one of the following transfer types:
-     * <CODE>DataBuffer.TYPE_BYTE</CODE>, <CODE>DataBuffer.TYPE_USHORT</CODE>,
-     * or <CODE>DataBuffer.TYPE_INT</CODE>.
+     * {@code DataBuffer.TYPE_BYTE}, {@code DataBuffer.TYPE_USHORT},
+     * or {@code DataBuffer.TYPE_INT}.
      *
      * @see WritableRaster#setDataElements
      * @see SampleModel#setDataElements
      */
     public Object getDataElements(int[] components, int offset, Object obj) {

@@ -2013,32 +2013,32 @@
                                         transferType);
         }
     }
 
     /**
-     * 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>).
+     * {@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}).
      * @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) {
         if (numComponents > 1) {
             throw new

@@ -2074,38 +2074,38 @@
         }
     }
 
     /**
      * 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>.
+     * {@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}.
      * @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,

@@ -2296,50 +2296,50 @@
         }
     }
 
     /**
      * 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>).
+     * (starting at {@code normOffset}).
      * <p>
      * This method must be overridden by a subclass if that subclass
      * is designed to translate pixel sample values to color component values
      * in a non-default way.  The default translations implemented by this
      * class is described in the class comments.  Any subclass implementing
      * a non-default translation must follow the constraints on allowable
      * translations defined there.
      * @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}.
      * @since 1.4
      */
     public float[] getNormalizedComponents(Object pixel,
                                            float[] normComponents,
                                            int normOffset) {

@@ -2424,30 +2424,30 @@
         return normComponents;
     }
 
     /**
      * 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>.
+     * {@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 also returns an instance of
-     * this <CODE>ColorModel</CODE> with
-     * the <CODE>isAlphaPremultiplied</CODE> flag set appropriately.
-     * Since <code>ColorModel</code> can be subclassed, subclasses inherit
+     * this {@code ColorModel} with
+     * the {@code isAlphaPremultiplied} flag set appropriately.
+     * 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
-     * <code>transferType</code>.
+     * {@code transferType}.
      *
-     * @throws NullPointerException if <code>raster</code> is
-     * <code>null</code> and data coercion is required.
+     * @throws NullPointerException if {@code raster} is
+     * {@code null} and data coercion is required.
      * @throws UnsupportedOperationException if the transfer type of
-     * this <CODE>ComponentColorModel</CODE>
+     * this {@code ComponentColorModel}
      * is not one of the supported transfer types:
-     * <CODE>DataBuffer.TYPE_BYTE</CODE>, <CODE>DataBuffer.TYPE_USHORT</CODE>,
-     * <CODE>DataBuffer.TYPE_INT</CODE>, <CODE>DataBuffer.TYPE_SHORT</CODE>,
-     * <CODE>DataBuffer.TYPE_FLOAT</CODE>, or <CODE>DataBuffer.TYPE_DOUBLE</CODE>.
+     * {@code DataBuffer.TYPE_BYTE}, {@code DataBuffer.TYPE_USHORT},
+     * {@code DataBuffer.TYPE_INT}, {@code DataBuffer.TYPE_SHORT},
+     * {@code DataBuffer.TYPE_FLOAT}, or {@code DataBuffer.TYPE_DOUBLE}.
      */
     public ColorModel coerceData (WritableRaster raster,
                                   boolean isAlphaPremultiplied) {
         if ((supportsAlpha == false) ||
             (this.isAlphaPremultiplied == isAlphaPremultiplied))

@@ -2772,17 +2772,17 @@
         }
 
     }
 
     /**
-      * Returns true if <CODE>raster</CODE> is compatible with this
-      * <CODE>ColorModel</CODE>; false if it is not.
+      * Returns true if {@code raster} is compatible with this
+      * {@code ColorModel}; false if it is not.
       *
-      * @param raster The <CODE>Raster</CODE> object to test for compatibility.
+      * @param raster The {@code Raster} object to test for compatibility.
       *
-      * @return <CODE>true</CODE> if <CODE>raster</CODE> is compatible with this
-      * <CODE>ColorModel</CODE>, <CODE>false</CODE> if it is not.
+      * @return {@code true} if {@code raster} is compatible with this
+      * {@code ColorModel}, {@code false} if it is not.
       */
     public boolean isCompatibleRaster(Raster raster) {
 
         SampleModel sm = raster.getSampleModel();
 

@@ -2801,19 +2801,19 @@
             return false;
         }
     }
 
     /**
-     * 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>.
+     * 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 of the <CODE>WritableRaster</CODE> you want to create.
-     * @param h The height of the <CODE>WritableRaster</CODE> you want to create.
+     * @param w The width of the {@code WritableRaster} you want to create.
+     * @param h The height of the {@code WritableRaster} you want to create.
      *
-     * @return A <CODE>WritableRaster</CODE> that is compatible with
-     * this <CODE>ColorModel</CODE>.
+     * @return A {@code WritableRaster} that is compatible with
+     * this {@code ColorModel}.
      * @see WritableRaster
      * @see SampleModel
      */
     public WritableRaster createCompatibleWritableRaster (int w, int h) {
         int dataSize = w*h*numComponents;

@@ -2834,18 +2834,18 @@
 
         return raster;
     }
 
     /**
-     * Creates a <CODE>SampleModel</CODE> with the specified width and height,
-     * that  has a data layout compatible with this <CODE>ColorModel</CODE>.
+     * Creates a {@code SampleModel} with the specified width and height,
+     * that  has a data layout compatible with this {@code ColorModel}.
      *
-     * @param w The width of the <CODE>SampleModel</CODE> you want to create.
-     * @param h The height of the <CODE>SampleModel</CODE> you want to create.
+     * @param w The width of the {@code SampleModel} you want to create.
+     * @param h The height of the {@code SampleModel} you want to create.
      *
-     * @return A <CODE>SampleModel</CODE> that is compatible with this
-     * <CODE>ColorModel</CODE>.
+     * @return A {@code SampleModel} that is compatible with this
+     * {@code ColorModel}.
      *
      * @see SampleModel
      */
     public SampleModel createCompatibleSampleModel(int w, int h) {
         int[] bandOffsets = new int[numComponents];

@@ -2866,17 +2866,17 @@
                                             bandOffsets);
         }
     }
 
     /**
-     * Checks whether or not the specified <CODE>SampleModel</CODE>
-     * is compatible with this <CODE>ColorModel</CODE>.
+     * Checks whether or not the specified {@code SampleModel}
+     * is compatible with this {@code ColorModel}.
      *
-     * @param sm The <CODE>SampleModel</CODE> to test for compatibility.
+     * @param sm The {@code SampleModel} to test for compatibility.
      *
-     * @return <CODE>true</CODE> if the <CODE>SampleModel</CODE> is
-     * compatible with this <CODE>ColorModel</CODE>, <CODE>false</CODE>
+     * @return {@code true} if the {@code SampleModel} is
+     * compatible with this {@code ColorModel}, {@code false}
      * if it is not.
      *
      * @see SampleModel
      */
     public boolean isCompatibleSampleModel(SampleModel sm) {

@@ -2895,23 +2895,23 @@
 
         return true;
     }
 
     /**
-     * Returns a <CODE>Raster</CODE> representing the alpha channel of an image,
-     * extracted from the input <CODE>Raster</CODE>.
-     * This method assumes that <CODE>Raster</CODE> objects associated with
-     * this <CODE>ColorModel</CODE> store the alpha band, if present, as
+     * Returns a {@code Raster} representing the alpha channel of an image,
+     * extracted from the input {@code Raster}.
+     * This method assumes that {@code Raster} objects associated with
+     * this {@code ColorModel} store the alpha band, if present, as
      * the last band of image data. Returns null if there is no separate spatial
-     * alpha channel associated with this <CODE>ColorModel</CODE>.
-     * This method creates a new <CODE>Raster</CODE>, but will share the data
+     * alpha channel associated with this {@code ColorModel}.
+     * This method creates a new {@code Raster}, but will share the data
      * array.
      *
-     * @param raster The <CODE>WritableRaster</CODE> from which to extract the
+     * @param raster The {@code WritableRaster} from which to extract the
      * alpha  channel.
      *
-     * @return A <CODE>WritableRaster</CODE> containing the image's alpha channel.
+     * @return A {@code WritableRaster} containing the image's alpha channel.
      *
      */
     public WritableRaster getAlphaRaster(WritableRaster raster) {
         if (hasAlpha() == false) {
             return null;

@@ -2928,12 +2928,12 @@
 
     /**
      * Compares this color model with another for equality.
      *
      * @param obj The object to compare with this color model.
-     * @return <CODE>true</CODE> if the color model objects are equal,
-     * <CODE>false</CODE> if they are not.
+     * @return {@code true} if the color model objects are equal,
+     * {@code false} if they are not.
      */
     public boolean equals(Object obj) {
         if (!super.equals(obj)) {
             return false;
         }
< prev index next >