< prev index next >

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

Print this page

        

*** 28,46 **** import java.awt.Transparency; import java.awt.color.ColorSpace; import java.math.BigInteger; /** ! * The <code>IndexColorModel</code> class is a <code>ColorModel</code> * class that works with pixel values consisting of a * single sample that is an index into a fixed colormap in the default * sRGB color space. The colormap specifies red, green, blue, and * optional alpha components corresponding to each index. All components * are represented in the colormap as 8-bit unsigned integral values. * Some constructors allow the caller to specify "holes" in the colormap * by indicating which colormap entries are valid and which represent ! * unusable colors via the bits set in a <code>BigInteger</code> object. * This color model is similar to an X11 PseudoColor visual. * <p> * Some constructors provide a means to specify an alpha component * for each pixel in the colormap, while others either provide no * such means or, in some cases, a flag to indicate whether the --- 28,46 ---- import java.awt.Transparency; import java.awt.color.ColorSpace; import java.math.BigInteger; /** ! * The {@code IndexColorModel} class is a {@code ColorModel} * class that works with pixel values consisting of a * single sample that is an index into a fixed colormap in the default * sRGB color space. The colormap specifies red, green, blue, and * optional alpha components corresponding to each index. All components * are represented in the colormap as 8-bit unsigned integral values. * Some constructors allow the caller to specify "holes" in the colormap * by indicating which colormap entries are valid and which represent ! * unusable colors via the bits set in a {@code BigInteger} object. * This color model is similar to an X11 PseudoColor visual. * <p> * Some constructors provide a means to specify an alpha component * for each pixel in the colormap, while others either provide no * such means or, in some cases, a flag to indicate whether the
*** 49,90 **** * assumed for each entry. * An optional transparent pixel value can be supplied that indicates a * pixel to be made completely transparent, regardless of any alpha * component supplied or assumed for that pixel value. * Note that the color components in the colormap of an ! * <code>IndexColorModel</code> objects are never pre-multiplied with * the alpha components. * <p> * <a name="transparency"> ! * The transparency of an <code>IndexColorModel</code> object is * determined by examining the alpha components of the colors in the * colormap and choosing the most specific value after considering * the optional alpha values and any transparent index specified. ! * The transparency value is <code>Transparency.OPAQUE</code> * only if all valid colors in * the colormap are opaque and there is no valid transparent pixel. * If all valid colors * in the colormap are either completely opaque (alpha = 1.0) or * completely transparent (alpha = 0.0), which typically occurs when * a valid transparent pixel is specified, ! * the value is <code>Transparency.BITMASK</code>. ! * Otherwise, the value is <code>Transparency.TRANSLUCENT</code>, indicating * that some valid color has an alpha component that is * neither completely transparent nor completely opaque * (0.0 &lt; alpha &lt; 1.0). * </a> * * <p> ! * If an <code>IndexColorModel</code> object has ! * a transparency value of <code>Transparency.OPAQUE</code>, ! * then the <code>hasAlpha</code> ! * and <code>getNumComponents</code> methods ! * (both inherited from <code>ColorModel</code>) * return false and 3, respectively. * For any other transparency value, ! * <code>hasAlpha</code> returns true ! * and <code>getNumComponents</code> returns 4. * * <p> * <a name="index_values"> * The values used to index into the colormap are taken from the least * significant <em>n</em> bits of pixel representations where --- 49,90 ---- * assumed for each entry. * An optional transparent pixel value can be supplied that indicates a * pixel to be made completely transparent, regardless of any alpha * component supplied or assumed for that pixel value. * Note that the color components in the colormap of an ! * {@code IndexColorModel} objects are never pre-multiplied with * the alpha components. * <p> * <a name="transparency"> ! * The transparency of an {@code IndexColorModel} object is * determined by examining the alpha components of the colors in the * colormap and choosing the most specific value after considering * the optional alpha values and any transparent index specified. ! * The transparency value is {@code Transparency.OPAQUE} * only if all valid colors in * the colormap are opaque and there is no valid transparent pixel. * If all valid colors * in the colormap are either completely opaque (alpha = 1.0) or * completely transparent (alpha = 0.0), which typically occurs when * a valid transparent pixel is specified, ! * the value is {@code Transparency.BITMASK}. ! * Otherwise, the value is {@code Transparency.TRANSLUCENT}, indicating * that some valid color has an alpha component that is * neither completely transparent nor completely opaque * (0.0 &lt; alpha &lt; 1.0). * </a> * * <p> ! * If an {@code IndexColorModel} object has ! * a transparency value of {@code Transparency.OPAQUE}, ! * then the {@code hasAlpha} ! * and {@code getNumComponents} methods ! * (both inherited from {@code ColorModel}) * return false and 3, respectively. * For any other transparency value, ! * {@code hasAlpha} returns true ! * and {@code getNumComponents} returns 4. * * <p> * <a name="index_values"> * The values used to index into the colormap are taken from the least * significant <em>n</em> bits of pixel representations where
*** 99,115 **** * 2<sup><em>n</em></sup>, are undefined and return 0 for all color and * alpha components. * </a> * <p> * For those methods that use a primitive array pixel representation of ! * type <code>transferType</code>, the array length is always one. ! * The transfer types supported are <code>DataBuffer.TYPE_BYTE</code> and ! * <code>DataBuffer.TYPE_USHORT</code>. 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 that use this representation do ! * not throw an <code>IllegalArgumentException</code> due to an invalid * pixel value. * <p> * Many of the methods in this class are final. The reason for * this is that the underlying native graphics code makes assumptions * about the layout and operation of this class and those assumptions --- 99,115 ---- * 2<sup><em>n</em></sup>, are undefined and return 0 for all color and * alpha components. * </a> * <p> * For those methods that use a primitive array pixel representation of ! * type {@code transferType}, the array length is always one. ! * The transfer types supported are {@code DataBuffer.TYPE_BYTE} and ! * {@code DataBuffer.TYPE_USHORT}. 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 that use this representation do ! * not throw an {@code IllegalArgumentException} due to an invalid * pixel value. * <p> * Many of the methods in this class are final. The reason for * this is that the underlying native graphics code makes assumptions * about the layout and operation of this class and those assumptions
*** 139,168 **** static { ColorModel.loadLibraries(); initIDs(); } /** ! * Constructs an <code>IndexColorModel</code> from the specified * arrays of red, green, and blue components. Pixels described * by this color model all have alpha components of 255 * unnormalized (1.0&nbsp;normalized), which means they * are fully opaque. All of the arrays specifying the color * components must have at least the specified number of entries. ! * The <code>ColorSpace</code> is the default sRGB space. * Since there is no alpha information in any of the arguments * to this constructor, the transparency value is always ! * <code>Transparency.OPAQUE</code>. ! * The transfer type is the smallest of <code>DataBuffer.TYPE_BYTE</code> ! * or <code>DataBuffer.TYPE_USHORT</code> that can hold a single pixel. * @param bits the number of bits each pixel occupies * @param size the size of the color component arrays * @param r the array of red color components * @param g the array of green color components * @param b the array of blue color components ! * @throws IllegalArgumentException if <code>bits</code> is less * than 1 or greater than 16 ! * @throws IllegalArgumentException if <code>size</code> is less * than 1 */ public IndexColorModel(int bits, int size, byte r[], byte g[], byte b[]) { super(bits, opaqueBits, --- 139,168 ---- static { ColorModel.loadLibraries(); initIDs(); } /** ! * Constructs an {@code IndexColorModel} from the specified * arrays of red, green, and blue components. Pixels described * by this color model all have alpha components of 255 * unnormalized (1.0&nbsp;normalized), which means they * are fully opaque. All of the arrays specifying the color * components must have at least the specified number of entries. ! * The {@code ColorSpace} is the default sRGB space. * Since there is no alpha information in any of the arguments * to this constructor, the transparency value is always ! * {@code Transparency.OPAQUE}. ! * The transfer type is the smallest of {@code DataBuffer.TYPE_BYTE} ! * or {@code DataBuffer.TYPE_USHORT} that can hold a single pixel. * @param bits the number of bits each pixel occupies * @param size the size of the color component arrays * @param r the array of red color components * @param g the array of green color components * @param b the array of blue color components ! * @throws IllegalArgumentException if {@code bits} is less * than 1 or greater than 16 ! * @throws IllegalArgumentException if {@code size} is less * than 1 */ public IndexColorModel(int bits, int size, byte r[], byte g[], byte b[]) { super(bits, opaqueBits,
*** 176,208 **** setRGBs(size, r, g, b, null); calculatePixelMask(); } /** ! * Constructs an <code>IndexColorModel</code> from the given arrays * of red, green, and blue components. Pixels described by this color * model all have alpha components of 255 unnormalized * (1.0&nbsp;normalized), which means they are fully opaque, except * for the indicated pixel to be made transparent. All of the arrays * specifying the color components must have at least the specified * number of entries. ! * The <code>ColorSpace</code> is the default sRGB space. ! * The transparency value may be <code>Transparency.OPAQUE</code> or ! * <code>Transparency.BITMASK</code> depending on the arguments, as * specified in the <a href="#transparency">class description</a> above. ! * The transfer type is the smallest of <code>DataBuffer.TYPE_BYTE</code> ! * or <code>DataBuffer.TYPE_USHORT</code> that can hold a * single pixel. * @param bits the number of bits each pixel occupies * @param size the size of the color component arrays * @param r the array of red color components * @param g the array of green color components * @param b the array of blue color components * @param trans the index of the transparent pixel ! * @throws IllegalArgumentException if <code>bits</code> is less than * 1 or greater than 16 ! * @throws IllegalArgumentException if <code>size</code> is less than * 1 */ public IndexColorModel(int bits, int size, byte r[], byte g[], byte b[], int trans) { super(bits, opaqueBits, --- 176,208 ---- setRGBs(size, r, g, b, null); calculatePixelMask(); } /** ! * Constructs an {@code IndexColorModel} from the given arrays * of red, green, and blue components. Pixels described by this color * model all have alpha components of 255 unnormalized * (1.0&nbsp;normalized), which means they are fully opaque, except * for the indicated pixel to be made transparent. All of the arrays * specifying the color components must have at least the specified * number of entries. ! * The {@code ColorSpace} is the default sRGB space. ! * The transparency value may be {@code Transparency.OPAQUE} or ! * {@code Transparency.BITMASK} depending on the arguments, as * specified in the <a href="#transparency">class description</a> above. ! * The transfer type is the smallest of {@code DataBuffer.TYPE_BYTE} ! * or {@code DataBuffer.TYPE_USHORT} that can hold a * single pixel. * @param bits the number of bits each pixel occupies * @param size the size of the color component arrays * @param r the array of red color components * @param g the array of green color components * @param b the array of blue color components * @param trans the index of the transparent pixel ! * @throws IllegalArgumentException if {@code bits} is less than * 1 or greater than 16 ! * @throws IllegalArgumentException if {@code size} is less than * 1 */ public IndexColorModel(int bits, int size, byte r[], byte g[], byte b[], int trans) { super(bits, opaqueBits,
*** 217,247 **** setTransparentPixel(trans); calculatePixelMask(); } /** ! * Constructs an <code>IndexColorModel</code> from the given * arrays of red, green, blue and alpha components. All of the * arrays specifying the components must have at least the specified * number of entries. ! * The <code>ColorSpace</code> is the default sRGB space. ! * The transparency value may be any of <code>Transparency.OPAQUE</code>, ! * <code>Transparency.BITMASK</code>, ! * or <code>Transparency.TRANSLUCENT</code> * depending on the arguments, as specified * in the <a href="#transparency">class description</a> above. ! * The transfer type is the smallest of <code>DataBuffer.TYPE_BYTE</code> ! * or <code>DataBuffer.TYPE_USHORT</code> that can hold a single pixel. * @param bits the number of bits each pixel occupies * @param size the size of the color component arrays * @param r the array of red color components * @param g the array of green color components * @param b the array of blue color components * @param a the array of alpha value components ! * @throws IllegalArgumentException if <code>bits</code> is less * than 1 or greater than 16 ! * @throws IllegalArgumentException if <code>size</code> is less * than 1 */ public IndexColorModel(int bits, int size, byte r[], byte g[], byte b[], byte a[]) { super (bits, alphaBits, --- 217,247 ---- setTransparentPixel(trans); calculatePixelMask(); } /** ! * Constructs an {@code IndexColorModel} from the given * arrays of red, green, blue and alpha components. All of the * arrays specifying the components must have at least the specified * number of entries. ! * The {@code ColorSpace} is the default sRGB space. ! * The transparency value may be any of {@code Transparency.OPAQUE}, ! * {@code Transparency.BITMASK}, ! * or {@code Transparency.TRANSLUCENT} * depending on the arguments, as specified * in the <a href="#transparency">class description</a> above. ! * The transfer type is the smallest of {@code DataBuffer.TYPE_BYTE} ! * or {@code DataBuffer.TYPE_USHORT} that can hold a single pixel. * @param bits the number of bits each pixel occupies * @param size the size of the color component arrays * @param r the array of red color components * @param g the array of green color components * @param b the array of blue color components * @param a the array of alpha value components ! * @throws IllegalArgumentException if {@code bits} is less * than 1 or greater than 16 ! * @throws IllegalArgumentException if {@code size} is less * than 1 */ public IndexColorModel(int bits, int size, byte r[], byte g[], byte b[], byte a[]) { super (bits, alphaBits,
*** 255,287 **** setRGBs (size, r, g, b, a); calculatePixelMask(); } /** ! * Constructs an <code>IndexColorModel</code> from a single * array of interleaved red, green, blue and optional alpha * components. The array must have enough values in it to * fill all of the needed component arrays of the specified ! * size. The <code>ColorSpace</code> is the default sRGB space. ! * The transparency value may be any of <code>Transparency.OPAQUE</code>, ! * <code>Transparency.BITMASK</code>, ! * or <code>Transparency.TRANSLUCENT</code> * depending on the arguments, as specified * in the <a href="#transparency">class description</a> above. * The transfer type is the smallest of ! * <code>DataBuffer.TYPE_BYTE</code> or <code>DataBuffer.TYPE_USHORT</code> * that can hold a single pixel. * * @param bits the number of bits each pixel occupies * @param size the size of the color component arrays * @param cmap the array of color components * @param start the starting offset of the first color component * @param hasalpha indicates whether alpha values are contained in ! * the <code>cmap</code> array ! * @throws IllegalArgumentException if <code>bits</code> is less * than 1 or greater than 16 ! * @throws IllegalArgumentException if <code>size</code> is less * than 1 */ public IndexColorModel(int bits, int size, byte cmap[], int start, boolean hasalpha) { this(bits, size, cmap, start, hasalpha, -1); --- 255,287 ---- setRGBs (size, r, g, b, a); calculatePixelMask(); } /** ! * Constructs an {@code IndexColorModel} from a single * array of interleaved red, green, blue and optional alpha * components. The array must have enough values in it to * fill all of the needed component arrays of the specified ! * size. The {@code ColorSpace} is the default sRGB space. ! * The transparency value may be any of {@code Transparency.OPAQUE}, ! * {@code Transparency.BITMASK}, ! * or {@code Transparency.TRANSLUCENT} * depending on the arguments, as specified * in the <a href="#transparency">class description</a> above. * The transfer type is the smallest of ! * {@code DataBuffer.TYPE_BYTE} or {@code DataBuffer.TYPE_USHORT} * that can hold a single pixel. * * @param bits the number of bits each pixel occupies * @param size the size of the color component arrays * @param cmap the array of color components * @param start the starting offset of the first color component * @param hasalpha indicates whether alpha values are contained in ! * the {@code cmap} array ! * @throws IllegalArgumentException if {@code bits} is less * than 1 or greater than 16 ! * @throws IllegalArgumentException if {@code size} is less * than 1 */ public IndexColorModel(int bits, int size, byte cmap[], int start, boolean hasalpha) { this(bits, size, cmap, start, hasalpha, -1);
*** 290,324 **** +" 1 and 16."); } } /** ! * Constructs an <code>IndexColorModel</code> from a single array of * interleaved red, green, blue and optional alpha components. The * specified transparent index represents a pixel that is made * entirely transparent regardless of any alpha value specified * for it. The array must have enough values in it to fill all * of the needed component arrays of the specified size. ! * The <code>ColorSpace</code> is the default sRGB space. ! * The transparency value may be any of <code>Transparency.OPAQUE</code>, ! * <code>Transparency.BITMASK</code>, ! * or <code>Transparency.TRANSLUCENT</code> * depending on the arguments, as specified * in the <a href="#transparency">class description</a> above. * The transfer type is the smallest of ! * <code>DataBuffer.TYPE_BYTE</code> or <code>DataBuffer.TYPE_USHORT</code> * that can hold a single pixel. * @param bits the number of bits each pixel occupies * @param size the size of the color component arrays * @param cmap the array of color components * @param start the starting offset of the first color component * @param hasalpha indicates whether alpha values are contained in ! * the <code>cmap</code> array * @param trans the index of the fully transparent pixel ! * @throws IllegalArgumentException if <code>bits</code> is less than * 1 or greater than 16 ! * @throws IllegalArgumentException if <code>size</code> is less than * 1 */ public IndexColorModel(int bits, int size, byte cmap[], int start, boolean hasalpha, int trans) { // REMIND: This assumes the ordering: RGB[A] --- 290,324 ---- +" 1 and 16."); } } /** ! * Constructs an {@code IndexColorModel} from a single array of * interleaved red, green, blue and optional alpha components. The * specified transparent index represents a pixel that is made * entirely transparent regardless of any alpha value specified * for it. The array must have enough values in it to fill all * of the needed component arrays of the specified size. ! * The {@code ColorSpace} is the default sRGB space. ! * The transparency value may be any of {@code Transparency.OPAQUE}, ! * {@code Transparency.BITMASK}, ! * or {@code Transparency.TRANSLUCENT} * depending on the arguments, as specified * in the <a href="#transparency">class description</a> above. * The transfer type is the smallest of ! * {@code DataBuffer.TYPE_BYTE} or {@code DataBuffer.TYPE_USHORT} * that can hold a single pixel. * @param bits the number of bits each pixel occupies * @param size the size of the color component arrays * @param cmap the array of color components * @param start the starting offset of the first color component * @param hasalpha indicates whether alpha values are contained in ! * the {@code cmap} array * @param trans the index of the fully transparent pixel ! * @throws IllegalArgumentException if {@code bits} is less than * 1 or greater than 16 ! * @throws IllegalArgumentException if {@code size} is less than * 1 */ public IndexColorModel(int bits, int size, byte cmap[], int start, boolean hasalpha, int trans) { // REMIND: This assumes the ordering: RGB[A]
*** 369,409 **** setTransparentPixel(trans); calculatePixelMask(); } /** ! * Constructs an <code>IndexColorModel</code> from an array of * ints where each int is comprised of red, green, blue, and * optional alpha components in the default RGB color model format. * The specified transparent index represents a pixel that is made * entirely transparent regardless of any alpha value specified * for it. The array must have enough values in it to fill all * of the needed component arrays of the specified size. ! * The <code>ColorSpace</code> is the default sRGB space. ! * The transparency value may be any of <code>Transparency.OPAQUE</code>, ! * <code>Transparency.BITMASK</code>, ! * or <code>Transparency.TRANSLUCENT</code> * depending on the arguments, as specified * in the <a href="#transparency">class description</a> above. * @param bits the number of bits each pixel occupies * @param size the size of the color component arrays * @param cmap the array of color components * @param start the starting offset of the first color component * @param hasalpha indicates whether alpha values are contained in ! * the <code>cmap</code> array * @param trans the index of the fully transparent pixel * @param transferType the data type of the array used to represent * pixel values. The data type must be either ! * <code>DataBuffer.TYPE_BYTE</code> or ! * <code>DataBuffer.TYPE_USHORT</code>. ! * @throws IllegalArgumentException if <code>bits</code> is less * than 1 or greater than 16 ! * @throws IllegalArgumentException if <code>size</code> is less * than 1 ! * @throws IllegalArgumentException if <code>transferType</code> is not ! * one of <code>DataBuffer.TYPE_BYTE</code> or ! * <code>DataBuffer.TYPE_USHORT</code> */ public IndexColorModel(int bits, int size, int cmap[], int start, boolean hasalpha, int trans, int transferType) { // REMIND: This assumes the ordering: RGB[A] --- 369,409 ---- setTransparentPixel(trans); calculatePixelMask(); } /** ! * Constructs an {@code IndexColorModel} from an array of * ints where each int is comprised of red, green, blue, and * optional alpha components in the default RGB color model format. * The specified transparent index represents a pixel that is made * entirely transparent regardless of any alpha value specified * for it. The array must have enough values in it to fill all * of the needed component arrays of the specified size. ! * The {@code ColorSpace} is the default sRGB space. ! * The transparency value may be any of {@code Transparency.OPAQUE}, ! * {@code Transparency.BITMASK}, ! * or {@code Transparency.TRANSLUCENT} * depending on the arguments, as specified * in the <a href="#transparency">class description</a> above. * @param bits the number of bits each pixel occupies * @param size the size of the color component arrays * @param cmap the array of color components * @param start the starting offset of the first color component * @param hasalpha indicates whether alpha values are contained in ! * the {@code cmap} array * @param trans the index of the fully transparent pixel * @param transferType the data type of the array used to represent * pixel values. The data type must be either ! * {@code DataBuffer.TYPE_BYTE} or ! * {@code DataBuffer.TYPE_USHORT}. ! * @throws IllegalArgumentException if {@code bits} is less * than 1 or greater than 16 ! * @throws IllegalArgumentException if {@code size} is less * than 1 ! * @throws IllegalArgumentException if {@code transferType} is not ! * one of {@code DataBuffer.TYPE_BYTE} or ! * {@code DataBuffer.TYPE_USHORT} */ public IndexColorModel(int bits, int size, int cmap[], int start, boolean hasalpha, int trans, int transferType) { // REMIND: This assumes the ordering: RGB[A]
*** 430,474 **** setTransparentPixel(trans); calculatePixelMask(); } /** ! * Constructs an <code>IndexColorModel</code> from an ! * <code>int</code> array where each <code>int</code> is * comprised of red, green, blue, and alpha * components in the default RGB color model format. * The array must have enough values in it to fill all * of the needed component arrays of the specified size. ! * The <code>ColorSpace</code> is the default sRGB space. ! * The transparency value may be any of <code>Transparency.OPAQUE</code>, ! * <code>Transparency.BITMASK</code>, ! * or <code>Transparency.TRANSLUCENT</code> * depending on the arguments, as specified * in the <a href="#transparency">class description</a> above. ! * The transfer type must be one of <code>DataBuffer.TYPE_BYTE</code> ! * <code>DataBuffer.TYPE_USHORT</code>. ! * The <code>BigInteger</code> object specifies the valid/invalid pixels ! * in the <code>cmap</code> array. A pixel is valid if the ! * <code>BigInteger</code> value at that index is set, and is invalid ! * if the <code>BigInteger</code> bit at that index is not set. * @param bits the number of bits each pixel occupies * @param size the size of the color component array * @param cmap the array of color components * @param start the starting offset of the first color component * @param transferType the specified data type ! * @param validBits a <code>BigInteger</code> object. If a bit is * set in the BigInteger, the pixel at that index is valid. * If a bit is not set, the pixel at that index * is considered invalid. If null, all pixels are valid. * Only bits from 0 to the map size are considered. ! * @throws IllegalArgumentException if <code>bits</code> is less * than 1 or greater than 16 ! * @throws IllegalArgumentException if <code>size</code> is less * than 1 ! * @throws IllegalArgumentException if <code>transferType</code> is not ! * one of <code>DataBuffer.TYPE_BYTE</code> or ! * <code>DataBuffer.TYPE_USHORT</code> * * @since 1.3 */ public IndexColorModel(int bits, int size, int cmap[], int start, int transferType, BigInteger validBits) { --- 430,474 ---- setTransparentPixel(trans); calculatePixelMask(); } /** ! * Constructs an {@code IndexColorModel} from an ! * {@code int} array where each {@code int} is * comprised of red, green, blue, and alpha * components in the default RGB color model format. * The array must have enough values in it to fill all * of the needed component arrays of the specified size. ! * The {@code ColorSpace} is the default sRGB space. ! * The transparency value may be any of {@code Transparency.OPAQUE}, ! * {@code Transparency.BITMASK}, ! * or {@code Transparency.TRANSLUCENT} * depending on the arguments, as specified * in the <a href="#transparency">class description</a> above. ! * The transfer type must be one of {@code DataBuffer.TYPE_BYTE} ! * {@code DataBuffer.TYPE_USHORT}. ! * The {@code BigInteger} object specifies the valid/invalid pixels ! * in the {@code cmap} array. A pixel is valid if the ! * {@code BigInteger} value at that index is set, and is invalid ! * if the {@code BigInteger} bit at that index is not set. * @param bits the number of bits each pixel occupies * @param size the size of the color component array * @param cmap the array of color components * @param start the starting offset of the first color component * @param transferType the specified data type ! * @param validBits a {@code BigInteger} object. If a bit is * set in the BigInteger, the pixel at that index is valid. * If a bit is not set, the pixel at that index * is considered invalid. If null, all pixels are valid. * Only bits from 0 to the map size are considered. ! * @throws IllegalArgumentException if {@code bits} is less * than 1 or greater than 16 ! * @throws IllegalArgumentException if {@code size} is less * than 1 ! * @throws IllegalArgumentException if {@code transferType} is not ! * one of {@code DataBuffer.TYPE_BYTE} or ! * {@code DataBuffer.TYPE_USHORT} * * @since 1.3 */ public IndexColorModel(int bits, int size, int cmap[], int start, int transferType, BigInteger validBits) {
*** 597,607 **** } /** * Returns the transparency. Returns either OPAQUE, BITMASK, * or TRANSLUCENT ! * @return the transparency of this <code>IndexColorModel</code> * @see Transparency#OPAQUE * @see Transparency#BITMASK * @see Transparency#TRANSLUCENT */ public int getTransparency() { --- 597,607 ---- } /** * Returns the transparency. Returns either OPAQUE, BITMASK, * or TRANSLUCENT ! * @return the transparency of this {@code IndexColorModel} * @see Transparency#OPAQUE * @see Transparency#BITMASK * @see Transparency#TRANSLUCENT */ public int getTransparency() {
*** 611,621 **** /** * Returns an array of the number of bits for each color/alpha component. * The array contains the color components in the order red, green, * blue, followed by the alpha component, if present. * @return an array containing the number of bits of each color ! * and alpha component of this <code>IndexColorModel</code> */ public int[] getComponentSize() { if (nBits == null) { if (supportsAlpha) { nBits = new int[4]; --- 611,621 ---- /** * Returns an array of the number of bits for each color/alpha component. * The array contains the color components in the order red, green, * blue, followed by the alpha component, if present. * @return an array containing the number of bits of each color ! * and alpha component of this {@code IndexColorModel} */ public int[] getComponentSize() { if (nBits == null) { if (supportsAlpha) { nBits = new int[4];
*** 629,655 **** return nBits.clone(); } /** * Returns the size of the color/alpha component arrays in this ! * <code>IndexColorModel</code>. * @return the size of the color and alpha component arrays. */ public final int getMapSize() { return map_size; } /** * Returns the index of a transparent pixel in this ! * <code>IndexColorModel</code> or -1 if there is no pixel * with an alpha value of 0. If a transparent pixel was * explicitly specified in one of the constructors by its * index, then that index will be preferred, otherwise, * the index of any pixel which happens to be fully transparent * may be returned. * @return the index of a transparent pixel in this ! * <code>IndexColorModel</code> object, or -1 if there * is no such pixel */ public final int getTransparentPixel() { return transparent_index; } --- 629,655 ---- return nBits.clone(); } /** * Returns the size of the color/alpha component arrays in this ! * {@code IndexColorModel}. * @return the size of the color and alpha component arrays. */ public final int getMapSize() { return map_size; } /** * Returns the index of a transparent pixel in this ! * {@code IndexColorModel} or -1 if there is no pixel * with an alpha value of 0. If a transparent pixel was * explicitly specified in one of the constructors by its * index, then that index will be preferred, otherwise, * the index of any pixel which happens to be fully transparent * may be returned. * @return the index of a transparent pixel in this ! * {@code IndexColorModel} object, or -1 if there * is no such pixel */ public final int getTransparentPixel() { return transparent_index; }
*** 668,678 **** } /** * Copies the array of green color components into the specified array. * Only the initial entries of the array as specified by ! * <code>getMapSize</code> are written. * @param g the specified array into which the elements of the * array of green color components are copied */ public final void getGreens(byte g[]) { for (int i = 0; i < map_size; i++) { --- 668,678 ---- } /** * Copies the array of green color components into the specified array. * Only the initial entries of the array as specified by ! * {@code getMapSize} are written. * @param g the specified array into which the elements of the * array of green color components are copied */ public final void getGreens(byte g[]) { for (int i = 0; i < map_size; i++) {
*** 681,691 **** } /** * Copies the array of blue color components into the specified array. * Only the initial entries of the array as specified by ! * <code>getMapSize</code> are written. * @param b the specified array into which the elements of the * array of blue color components are copied */ public final void getBlues(byte b[]) { for (int i = 0; i < map_size; i++) { --- 681,691 ---- } /** * Copies the array of blue color components into the specified array. * Only the initial entries of the array as specified by ! * {@code getMapSize} are written. * @param b the specified array into which the elements of the * array of blue color components are copied */ public final void getBlues(byte b[]) { for (int i = 0; i < map_size; i++) {
*** 694,704 **** } /** * Copies the array of alpha transparency components into the * specified array. Only the initial entries of the array as specified ! * by <code>getMapSize</code> are written. * @param a the specified array into which the elements of the * array of alpha components are copied */ public final void getAlphas(byte a[]) { for (int i = 0; i < map_size; i++) { --- 694,704 ---- } /** * Copies the array of alpha transparency components into the * specified array. Only the initial entries of the array as specified ! * by {@code getMapSize} are written. * @param a the specified array into which the elements of the * array of alpha components are copied */ public final void getAlphas(byte a[]) { for (int i = 0; i < map_size; i++) {
*** 709,719 **** /** * Converts data for each index from the color and alpha component * arrays to an int in the default RGB ColorModel format and copies * the resulting 32-bit ARGB values into the specified array. Only * the initial entries of the array as specified by ! * <code>getMapSize</code> are * written. * @param rgb the specified array into which the converted ARGB * values from this array of color and alpha components * are copied. */ --- 709,719 ---- /** * Converts data for each index from the color and alpha component * arrays to an int in the default RGB ColorModel format and copies * the resulting 32-bit ARGB values into the specified array. Only * the initial entries of the array as specified by ! * {@code getMapSize} are * written. * @param rgb the specified array into which the converted ARGB * values from this array of color and alpha components * are copied. */
*** 845,878 **** * Returns a data element array representation of a pixel in this * ColorModel, given an integer pixel representation in the * default RGB color model. This array can then be passed to the * {@link WritableRaster#setDataElements(int, int, java.lang.Object) setDataElements} * method of a {@link WritableRaster} 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. * <p> ! * Since <code>IndexColorModel</code> 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>. * * @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>IndexColorModel</code>. ! * @throws ClassCastException if <code>pixel</code> ! * is not a primitive array of type <code>transferType</code> * @throws ArrayIndexOutOfBoundsException if ! * <code>pixel</code> is not large enough to hold a pixel value ! * for this <code>ColorModel</code> ! * @throws UnsupportedOperationException if <code>transferType</code> * is invalid * @see WritableRaster#setDataElements * @see SampleModel#setDataElements */ public synchronized Object getDataElements(int rgb, Object pixel) { --- 845,878 ---- * Returns a data element array representation of a pixel in this * ColorModel, given an integer pixel representation in the * default RGB color model. This array can then be passed to the * {@link WritableRaster#setDataElements(int, int, java.lang.Object) setDataElements} * method of a {@link 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. * <p> ! * Since {@code IndexColorModel} 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}. * * @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 IndexColorModel}. ! * @throws ClassCastException if {@code pixel} ! * 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} ! * @throws UnsupportedOperationException if {@code transferType} * is invalid * @see WritableRaster#setDataElements * @see SampleModel#setDataElements */ public synchronized Object getDataElements(int rgb, Object pixel) {
*** 1065,1091 **** return pixel; } /** * Returns an array of unnormalized color/alpha components for a ! * specified pixel in this <code>ColorModel</code>. The pixel value ! * is specified as an int. If the <code>components</code> array is <code>null</code>, * a new array is allocated that contains ! * <code>offset + getNumComponents()</code> elements. ! * The <code>components</code> array is returned, * with the alpha component included ! * only if <code>hasAlpha</code> returns true. ! * 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>. * @param pixel the specified pixel * @param components the array to receive the color and alpha * components of the specified pixel ! * @param offset the offset into the <code>components</code> array at * which to start storing the color and alpha components * @return an array containing the color and alpha components of the * specified pixel starting at the specified offset. * @see ColorModel#hasAlpha * @see ColorModel#getNumComponents --- 1065,1091 ---- return pixel; } /** * Returns an array of unnormalized color/alpha components for a ! * specified pixel in this {@code ColorModel}. The pixel value ! * is specified as an int. If the {@code components} array is {@code null}, * a new array is allocated that contains ! * {@code offset + getNumComponents()} elements. ! * The {@code components} array is returned, * with the alpha component included ! * only if {@code hasAlpha} returns true. ! * 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}. * @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} 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. * @see ColorModel#hasAlpha * @see ColorModel#getNumComponents
*** 1106,1159 **** return components; } /** * Returns an array of unnormalized color/alpha components for ! * a specified 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 that contains ! * <code>offset + getNumComponents()</code> elements. ! * The <code>components</code> array is returned, * with the alpha component included ! * only if <code>hasAlpha</code> returns true. ! * 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 also ! * 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>. * <p> ! * Since <code>IndexColorModel</code> 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>. * * @param pixel the specified pixel * @param components an array that receives the color and alpha * components of the specified pixel ! * @param offset the index into the <code>components</code> array at * which to begin storing the color and alpha components of the * specified pixel * @return an array containing the color and alpha components of the * specified pixel starting at the specified offset. ! * @throws ArrayIndexOutOfBoundsException if <code>pixel</code> * is not large enough to hold a pixel value for this ! * <code>ColorModel</code> or 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> ! * @throws ClassCastException if <code>pixel</code> is not a ! * primitive array of type <code>transferType</code> ! * @throws UnsupportedOperationException if <code>transferType</code> * is not one of the supported transfer types * @see ColorModel#hasAlpha * @see ColorModel#getNumComponents */ public int[] getComponents(Object pixel, int[] components, int offset) { --- 1106,1159 ---- return components; } /** * Returns an array of unnormalized color/alpha components for ! * a specified pixel 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 that contains ! * {@code offset + getNumComponents()} elements. ! * The {@code components} array is returned, * with the alpha component included ! * only if {@code hasAlpha} returns true. ! * 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 also ! * 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}. * <p> ! * Since {@code IndexColorModel} 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}. * * @param pixel the specified pixel * @param components an array that receives the color and alpha * components of the specified pixel ! * @param offset the index into the {@code components} array at * which to begin storing the color and alpha components of the * specified pixel * @return an array containing the color and alpha components of the * specified pixel starting at the specified offset. ! * @throws ArrayIndexOutOfBoundsException if {@code pixel} * is not large enough to hold a pixel value for this ! * {@code ColorModel} or 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} ! * @throws ClassCastException if {@code pixel} is not a ! * primitive array of type {@code transferType} ! * @throws UnsupportedOperationException if {@code transferType} * is not one of the supported transfer types * @see ColorModel#hasAlpha * @see ColorModel#getNumComponents */ public int[] getComponents(Object pixel, int[] components, int offset) {
*** 1178,1207 **** return getComponents(intpixel, components, offset); } /** * Returns a pixel value represented as an int 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 not large * enough to hold all of the color and alpha components starting ! * at <code>offset</code>. Since ! * <code>ColorModel</code> 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 components an array of unnormalized color and alpha * components ! * @param offset the index into <code>components</code> at which to * begin retrieving the color and alpha components ! * @return an <code>int</code> pixel value in this ! * <code>ColorModel</code> corresponding to the specified components. * @throws ArrayIndexOutOfBoundsException if ! * the <code>components</code> array is not large enough to * hold all of the color and alpha components starting at ! * <code>offset</code> ! * @throws UnsupportedOperationException if <code>transferType</code> * is invalid */ public int getDataElement(int[] components, int offset) { int rgb = (components[offset+0]<<16) | (components[offset+1]<<8) | (components[offset+2]); --- 1178,1207 ---- return getComponents(intpixel, components, offset); } /** * Returns a pixel value represented as an 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 of the color and alpha components starting ! * at {@code offset}. 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 components an array of unnormalized color and alpha * components ! * @param offset the index into {@code components} at which to * begin retrieving the color and alpha components ! * @return an {@code int} pixel value in this ! * {@code ColorModel} corresponding to the specified components. * @throws ArrayIndexOutOfBoundsException if ! * the {@code components} array is not large enough to * hold all of the color and alpha components starting at ! * {@code offset} ! * @throws UnsupportedOperationException if {@code transferType} * is invalid */ public int getDataElement(int[] components, int offset) { int rgb = (components[offset+0]<<16) | (components[offset+1]<<8) | (components[offset+2]);
*** 1233,1278 **** return pixel; } /** * 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. An <code>ArrayIndexOutOfBoundsException</code> is * thrown if the ! * <code>components</code> array is not large enough to hold all of the ! * color and alpha components starting at <code>offset</code>. ! * 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 pixel * is not large enough to hold a pixel value for this ! * <code>ColorModel</code>. * <p> ! * Since <code>IndexColorModel</code> 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> * * @param components an array of unnormalized color and alpha * components ! * @param offset the index into <code>components</code> at which to * begin retrieving color and alpha components ! * @param pixel the <code>Object</code> representing an array of color * and alpha components ! * @return an <code>Object</code> representing an array of color and * alpha components. ! * @throws ClassCastException if <code>pixel</code> ! * is not a primitive array of type <code>transferType</code> * @throws ArrayIndexOutOfBoundsException if ! * <code>pixel</code> is not large enough to hold a pixel value ! * for this <code>ColorModel</code> or the <code>components</code> * array is not large enough to hold all of the color and alpha ! * components starting at <code>offset</code> ! * @throws UnsupportedOperationException if <code>transferType</code> * is not one of the supported transfer types * @see WritableRaster#setDataElements * @see SampleModel#setDataElements */ public Object getDataElements(int[] components, int offset, Object pixel) { --- 1233,1278 ---- return pixel; } /** * Returns a data element array representation of a pixel in this ! * {@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. An {@code ArrayIndexOutOfBoundsException} is * thrown if the ! * {@code components} array is not large enough to hold all of the ! * color and alpha components starting at {@code offset}. ! * 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 pixel * is not large enough to hold a pixel value for this ! * {@code ColorModel}. * <p> ! * Since {@code IndexColorModel} 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} * * @param components an array of unnormalized color and alpha * components ! * @param offset the index into {@code components} at which to * begin retrieving color and alpha components ! * @param pixel the {@code Object} representing an array of color * and alpha components ! * @return an {@code Object} representing an array of color and * alpha components. ! * @throws ClassCastException if {@code pixel} ! * 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} or the {@code components} * array is not large enough to hold all of the color and alpha ! * components starting at {@code offset} ! * @throws UnsupportedOperationException if {@code transferType} * is not one of the supported transfer types * @see WritableRaster#setDataElements * @see SampleModel#setDataElements */ public Object getDataElements(int[] components, int offset, Object pixel) {
*** 1286,1307 **** } return getDataElements(rgb, pixel); } /** ! * 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>. This method * only works for color models with 16 or fewer bits per pixel. * <p> ! * Since <code>IndexColorModel</code> can be subclassed, any * subclass that supports greater than 16 bits per pixel must * override this method. * ! * @param w the width to apply to the new <code>WritableRaster</code> ! * @param h the height to apply to the new <code>WritableRaster</code> ! * @return a <code>WritableRaster</code> object with the specified * width and height. * @throws UnsupportedOperationException if the number of bits in a * pixel is greater than 16 * @see WritableRaster * @see SampleModel --- 1286,1307 ---- } return getDataElements(rgb, pixel); } /** ! * Creates a {@code WritableRaster} with the specified width ! * and height that has a data layout ({@code SampleModel}) ! * compatible with this {@code ColorModel}. This method * only works for color models with 16 or fewer bits per pixel. * <p> ! * Since {@code IndexColorModel} can be subclassed, any * subclass that supports greater than 16 bits per pixel must * override this method. * ! * @param w the width to apply to the new {@code WritableRaster} ! * @param h the height to apply to the new {@code WritableRaster} ! * @return a {@code WritableRaster} object with the specified * width and height. * @throws UnsupportedOperationException if the number of bits in a * pixel is greater than 16 * @see WritableRaster * @see SampleModel
*** 1329,1363 **** } return raster; } /** ! * Returns <code>true</code> if <code>raster</code> is compatible ! * with this <code>ColorModel</code> or <code>false</code> if it ! * is not compatible with this <code>ColorModel</code>. * @param raster the {@link Raster} object to test for compatibility ! * @return <code>true</code> if <code>raster</code> is compatible ! * with this <code>ColorModel</code>; <code>false</code> otherwise. * */ public boolean isCompatibleRaster(Raster raster) { int size = raster.getSampleModel().getSampleSize(0); return ((raster.getTransferType() == transferType) && (raster.getNumBands() == 1) && ((1 << size) >= map_size)); } /** ! * Creates a <code>SampleModel</code> with the specified * width and height that has a data layout compatible with ! * this <code>ColorModel</code>. ! * @param w the width to apply to the new <code>SampleModel</code> ! * @param h the height to apply to the new <code>SampleModel</code> ! * @return a <code>SampleModel</code> object with the specified * width and height. ! * @throws IllegalArgumentException if <code>w</code> or ! * <code>h</code> is not greater than 0 * @see SampleModel */ public SampleModel createCompatibleSampleModel(int w, int h) { int[] off = new int[1]; off[0] = 0; --- 1329,1363 ---- } return raster; } /** ! * Returns {@code true} if {@code raster} is compatible ! * with this {@code ColorModel} or {@code false} if it ! * is not compatible with this {@code ColorModel}. * @param raster the {@link Raster} object to test for compatibility ! * @return {@code true} if {@code raster} is compatible ! * with this {@code ColorModel}; {@code false} otherwise. * */ public boolean isCompatibleRaster(Raster raster) { int size = raster.getSampleModel().getSampleSize(0); return ((raster.getTransferType() == transferType) && (raster.getNumBands() == 1) && ((1 << size) >= map_size)); } /** ! * Creates a {@code SampleModel} with the specified * width and height that has a data layout compatible with ! * this {@code ColorModel}. ! * @param w the width to apply to the new {@code SampleModel} ! * @param h the height to apply to the new {@code SampleModel} ! * @return a {@code SampleModel} object with the specified * width and height. ! * @throws IllegalArgumentException if {@code w} or ! * {@code h} is not greater than 0 * @see SampleModel */ public SampleModel createCompatibleSampleModel(int w, int h) { int[] off = new int[1]; off[0] = 0;
*** 1370,1386 **** off); } } /** ! * Checks if the specified <code>SampleModel</code> is compatible ! * with this <code>ColorModel</code>. If <code>sm</code> is ! * <code>null</code>, this method returns <code>false</code>. ! * @param sm the specified <code>SampleModel</code>, ! * or <code>null</code> ! * @return <code>true</code> if the specified <code>SampleModel</code> ! * is compatible with this <code>ColorModel</code>; <code>false</code> * otherwise. * @see SampleModel */ public boolean isCompatibleSampleModel(SampleModel sm) { // fix 4238629 --- 1370,1386 ---- off); } } /** ! * Checks if the specified {@code SampleModel} is compatible ! * with this {@code ColorModel}. If {@code sm} is ! * {@code null}, this method returns {@code false}. ! * @param sm the specified {@code SampleModel}, ! * or {@code null} ! * @return {@code true} if the specified {@code SampleModel} ! * is compatible with this {@code ColorModel}; {@code false} * otherwise. * @see SampleModel */ public boolean isCompatibleSampleModel(SampleModel sm) { // fix 4238629
*** 1400,1426 **** return true; } /** ! * Returns a new <code>BufferedImage</code> of TYPE_INT_ARGB or ! * TYPE_INT_RGB that has a <code>Raster</code> with pixel data ! * computed by expanding the indices in the source <code>Raster</code> ! * using the color/alpha component arrays of this <code>ColorModel</code>. * Only the lower <em>n</em> bits of each index value in the source ! * <code>Raster</code>, as specified in the * <a href="#index_values">class description</a> above, are used to * compute the color/alpha values in the returned image. ! * If <code>forceARGB</code> is <code>true</code>, a TYPE_INT_ARGB image is ! * returned regardless of whether or not this <code>ColorModel</code> * has an alpha component array or a transparent pixel. ! * @param raster the specified <code>Raster</code> ! * @param forceARGB if <code>true</code>, the returned ! * <code>BufferedImage</code> is TYPE_INT_ARGB; otherwise it is * TYPE_INT_RGB ! * @return a <code>BufferedImage</code> created with the specified ! * <code>Raster</code> * @throws IllegalArgumentException if the raster argument is not * compatible with this IndexColorModel */ public BufferedImage convertToIntDiscrete(Raster raster, boolean forceARGB) { --- 1400,1426 ---- return true; } /** ! * Returns a new {@code BufferedImage} of TYPE_INT_ARGB or ! * TYPE_INT_RGB that has a {@code Raster} with pixel data ! * computed by expanding the indices in the source {@code Raster} ! * using the color/alpha component arrays of this {@code ColorModel}. * Only the lower <em>n</em> bits of each index value in the source ! * {@code Raster}, as specified in the * <a href="#index_values">class description</a> above, are used to * compute the color/alpha values in the returned image. ! * If {@code forceARGB} is {@code true}, a TYPE_INT_ARGB image is ! * returned regardless of whether or not this {@code ColorModel} * has an alpha component array or a transparent pixel. ! * @param raster the specified {@code Raster} ! * @param forceARGB if {@code true}, the returned ! * {@code BufferedImage} is TYPE_INT_ARGB; otherwise it is * TYPE_INT_RGB ! * @return a {@code BufferedImage} created with the specified ! * {@code Raster} * @throws IllegalArgumentException if the raster argument is not * compatible with this IndexColorModel */ public BufferedImage convertToIntDiscrete(Raster raster, boolean forceARGB) {
*** 1468,1504 **** } /** * Returns whether or not the pixel is valid. * @param pixel the specified pixel value ! * @return <code>true</code> if <code>pixel</code> ! * is valid; <code>false</code> otherwise. * @since 1.3 */ public boolean isValid(int pixel) { return ((pixel >= 0 && pixel < map_size) && (validBits == null || validBits.testBit(pixel))); } /** * Returns whether or not all of the pixels are valid. ! * @return <code>true</code> if all pixels are valid; ! * <code>false</code> otherwise. * @since 1.3 */ public boolean isValid() { return (validBits == null); } /** ! * Returns a <code>BigInteger</code> that indicates the valid/invalid * pixels in the colormap. A bit is valid if the ! * <code>BigInteger</code> value at that index is set, and is invalid ! * if the <code>BigInteger</code> value at that index is not set. ! * The only valid ranges to query in the <code>BigInteger</code> are * between 0 and the map size. ! * @return a <code>BigInteger</code> indicating the valid/invalid pixels. * @since 1.3 */ public BigInteger getValidPixels() { if (validBits == null) { return getAllValid(); --- 1468,1504 ---- } /** * Returns whether or not the pixel is valid. * @param pixel the specified pixel value ! * @return {@code true} if {@code pixel} ! * is valid; {@code false} otherwise. * @since 1.3 */ public boolean isValid(int pixel) { return ((pixel >= 0 && pixel < map_size) && (validBits == null || validBits.testBit(pixel))); } /** * Returns whether or not all of the pixels are valid. ! * @return {@code true} if all pixels are valid; ! * {@code false} otherwise. * @since 1.3 */ public boolean isValid() { return (validBits == null); } /** ! * Returns a {@code BigInteger} that indicates the valid/invalid * pixels in the colormap. A bit is valid if the ! * {@code BigInteger} value at that index is set, and is invalid ! * if the {@code BigInteger} value at that index is not set. ! * The only valid ranges to query in the {@code BigInteger} are * between 0 and the map size. ! * @return a {@code BigInteger} indicating the valid/invalid pixels. * @since 1.3 */ public BigInteger getValidPixels() { if (validBits == null) { return getAllValid();
*** 1508,1528 **** } } /** * Disposes of system resources associated with this ! * <code>ColorModel</code> once this <code>ColorModel</code> is no * longer referenced. */ public void finalize() { } /** ! * Returns the <code>String</code> representation of the contents of ! * this <code>ColorModel</code>object. ! * @return a <code>String</code> representing the contents of this ! * <code>ColorModel</code> object. */ public String toString() { return new String("IndexColorModel: #pixelBits = "+pixel_bits + " numComponents = "+numComponents + " color space = "+colorSpace --- 1508,1528 ---- } } /** * Disposes of system resources associated with this ! * {@code ColorModel} once this {@code ColorModel} is no * longer referenced. */ public void finalize() { } /** ! * Returns the {@code String} representation of the contents of ! * this {@code ColorModel} object. ! * @return a {@code String} representing the contents of this ! * {@code ColorModel} object. */ public String toString() { return new String("IndexColorModel: #pixelBits = "+pixel_bits + " numComponents = "+numComponents + " color space = "+colorSpace
< prev index next >