IndexColorModel

Overview | Package | Class | Use | Tree | Deprecated | Index | Help

PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## java.awt.image
Class IndexColorModel

    java.lang.Object
      java.awt.image.ColorModel
          java.awt.image.IndexColorModel

All Implemented Interfaces:
  Transparency

    public class IndexColorModel

extends ColorModel

The `IndexColorModel` class is a `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 `BigInteger` object. This color model is similar to an X11 PseudoColor visual.

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 colormap data contains alpha values. If no alpha is supplied to the constructor, an opaque alpha component (alpha = 1.0) is assumed for each entry. An optional transparent pixel value can be supplied that indicates a completely transparent pixel, regardless of any alpha component supplied or assumed for that pixel value. Note that the color components in the colormap of an `IndexColorModel` objects are never pre-multiplied with the alpha components.

The transparency of an `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 `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 `Transparency.BITMASK`. Otherwise, the value is `Transparency.TRANSLUCENT`, indicating that some valid color has an alpha component that is neither completely transparent nor completely opaque (0.0 < alpha < 1.0).

The index represented by a pixel value is stored in the least significant n bits of the pixel representations passed to the methods of this class, where n is the pixel size specified to the constructor for a particular `IndexColorModel` object; n must be between 1 and 16, inclusive. Higher order bits in pixel representations are assumed to be zero. For those methods that use a primitive array pixel representation of type `transferType`, the array length is always one. The transfer types supported are `DataBuffer.TYPE_BYTE` and `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 `IllegalArgumentException` due to an invalid pixel value.

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 are reflected in the implementations of the methods here that are marked final. You can subclass this class for other reaons, but you cannot override or modify the behaviour of those methods.

Version:
  10 Feb 1997
See Also:
  `ColorModel`, `ColorSpace`, `DataBuffer`

Field Summary

Fields inherited from interface java.awt.Transparency
`BITMASK, OPAQUE, TRANSLUCENT`

Constructor Summary
`IndexColorModel(int bits, int size, byte[] r, byte[] g, byte[] b)` Constructs an `IndexColorModel` from the specified arrays of red, green, and blue components.
`IndexColorModel(int bits, int size, byte[] r, byte[] g, byte[] b, byte[] a)` Constructs an `IndexColorModel` from the given arrays of red, green, blue and alpha components.
`IndexColorModel(int bits, int size, byte[] r, byte[] g, byte[] b, int trans)` Constructs an `IndexColorModel` from the given arrays of red, green, and blue components.
`IndexColorModel(int bits, int size, byte[] cmap, int start, boolean hasalpha)` Constructs an `IndexColorModel` from a single array of interleaved red, green, blue and optional alpha components.
`IndexColorModel(int bits, int size, byte[] cmap, int start, boolean hasalpha, int trans)` Constructs an `IndexColorModel` from a single array of interleaved red, green, blue and optional alpha components.

Method Summary
`void` | `finalize()` Disposes of system resources associated with this `ColorModel` once this `ColorModel` is no longer referenced.
`int` | `getAlpha(int pixel)` Returns the alpha component for the specified pixel, scaled from 0 to 255.
`void` | `getAlphas(byte[] a)` Copies the array of alpha transparency components into the specified array.
`int` | `getBlue(int pixel)` Returns the blue color component for the specified pixel, scaled from 0 to 255 in the default RGB ColorSpace, sRGB.
`void` | `getBlues(byte[] b)` Copies the array of blue color components into the specified array.
`int` | `getGreen(int pixel)` Returns the green color component for the specified pixel, scaled from 0 to 255 in the default RGB ColorSpace, sRGB.
`void` | `getGreens(byte[] g)` Copies the array of green color components into the specified array.
`int` | `getMapSize()` Returns the size of the color/alpha component arrays in this `IndexColorModel`.
`int` | `getRed(int pixel)` Returns the red color component for the specified pixel, scaled from 0 to 255 in the default RGB ColorSpace, sRGB.
`void` | `getReds(byte[] r)` Copies the array of red color components into the specified array.
`int` | `getRGB(int pixel)` Returns the color/alpha components of the pixel in the default RGB color model format.
`int` | `getTransparentPixel()` Returns the index of the transparent pixel in this `IndexColorModel` or -1 if there is no transparent pixel.
`String` | `toString()` Returns the `String` representation of the contents of this `ColorModel`object.

Methods inherited from class java.awt.image.ColorModel
`equals, getColorSpace, getComponentSize, getComponentSize, getNumColorComponents, getNumComponents, getPixelSize, getRGBdefault, getTransferType, getTransparency, hasAlpha, hashCode, isAlphaPremultiplied`

Methods inherited from class java.lang.Object
`getClass, notify, notifyAll, wait, wait, wait`

Constructor Detail

### IndexColorModel

    public IndexColorModel(int bits,
                           int size,
                           byte[] r,
                           byte[] g,
                           byte[] b)

  Constructs an `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 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 `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 `Transparency.OPAQUE`. The transfer type is the smallest of `DataBuffer.TYPE_BYTE` or `DataBuffer.TYPE_USHORT` that can hold a single pixel.

  Parameters:
    `bits` - the number of bits each pixel occupies
    `size` - the size of the color component arrays
    `r` - the array of red color components
    `g` - the array of green color components
    `b` - the array of blue color components
  Throws:
    `IllegalArgumentException` - if `bits` is less than 1 or greater than 16
    `IllegalArgumentException` - if `size` is less than 1

### IndexColorModel

    public IndexColorModel(int bits,
                           int size,
                           byte[] r,
                           byte[] g,
                           byte[] b,
                           int trans)

  Constructs an `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 normalized), which means they are fully opaque, except for the indicated transparent pixel. All of the arrays specifying the color components must have at least the specified number of entries. The `ColorSpace` is the default sRGB space. The transparency value may be `Transparency.OPAQUE` or `Transparency.BITMASK` depending on the arguments, as specified in the class description above. The transfer type is the smallest of `DataBuffer.TYPE_BYTE` or `DataBuffer.TYPE_USHORT` that can hold a single pixel.

  Parameters:
    `bits` - the number of bits each pixel occupies
    `size` - the size of the color component arrays
    `r` - the array of red color components
    `g` - the array of green color components
    `b` - the array of blue color components
    `trans` - the index of the transparent pixel
  Throws:
    `IllegalArgumentException` - if `bits` is less than 1 or greater than 16
    `IllegalArgumentException` - if `size` is less than 1

### IndexColorModel

    public IndexColorModel(int bits,
                           int size,
                           byte[] r,
                           byte[] g,
                           byte[] b,
                           byte[] a)

  Constructs an `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 `ColorSpace` is the default sRGB space. The transparency value may be any of `Transparency.OPAQUE`, `Transparency.BITMASK`, or `Transparency.TRANSLUCENT` depending on the arguments, as specified in the class description above. The transfer type is the smallest of `DataBuffer.TYPE_BYTE` or `DataBuffer.TYPE_USHORT` that can hold a single pixel.

  Parameters:
    `bits` - the number of bits each pixel occupies
    `size` - the size of the color component arrays
    `r` - the array of red color components
    `g` - the array of green color components
    `b` - the array of blue color components
    `a` - the array of alpha value components
  Throws:
    `IllegalArgumentException` - if `bits` is less than 1 or greater than 16
    `IllegalArgumentException` - if `size` is less than 1

### IndexColorModel

    public IndexColorModel(int bits,
                           int size,
                           byte[] cmap,
                           int start,
                           boolean hasalpha)

  Constructs an `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 `ColorSpace` is the default sRGB space. The transparency value may be any of `Transparency.OPAQUE`, `Transparency.BITMASK`, or `Transparency.TRANSLUCENT` depending on the arguments, as specified in the class description above. The transfer type is the smallest of `DataBuffer.TYPE_BYTE` or `DataBuffer.TYPE_USHORT` that can hold a single pixel.

  Parameters:
    `bits` - the number of bits each pixel occupies
    `size` - the size of the color component arrays
    `cmap` - the array of color components
    `start` - the starting offset of the first color component
    `hasalpha` - indicates whether alpha values are contained in the `cmap` array
  Throws:
    `IllegalArgumentException` - if `bits` is less than 1 or greater than 16
    `IllegalArgumentException` - if `size` is less than 1

### IndexColorModel

    public IndexColorModel(int bits,
                           int size,
                           byte[] cmap,
                           int start,
                           boolean hasalpha,
                           int trans)

  Constructs an `IndexColorModel` from a single array of interleaved red, green, blue and optional alpha components. The specified transparent index represents a pixel that is considered 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 `ColorSpace` is the default sRGB space. The transparency value may be any of `Transparency.OPAQUE`, `Transparency.BITMASK`, or `Transparency.TRANSLUCENT` depending on the arguments, as specified in the class description above. The transfer type is the smallest of `DataBuffer.TYPE_BYTE` or `DataBuffer.TYPE_USHORT` that can hold a single pixel.

  Parameters:
    `bits` - the number of bits each pixel occupies
    `size` - the size of the color component arrays
    `cmap` - the array of color components
    `start` - the starting offset of the first color component
    `hasalpha` - indicates whether alpha values are contained in the `cmap` array
    `trans` - the index of the fully transparent pixel
  Throws:
    `IllegalArgumentException` - if `bits` is less than 1 or greater than 16
    `IllegalArgumentException` - if `size` is less than 1

Method Detail

### getMapSize

    public final int getMapSize()

  Returns the size of the color/alpha component arrays in this `IndexColorModel`.

  Returns:
    the size of the color and alpha component arrays.

### getTransparentPixel

    public final int getTransparentPixel()

  Returns the index of the transparent pixel in this `IndexColorModel` or -1 if there is no transparent pixel.

  Returns:
    the index of this `IndexColorModel` object's transparent pixel, or -1 if there is no such pixel.

### getReds

    public final void getReds(byte[] r)

  Copies the array of red color components into the specified array. Only the initial entries of the array as specified by `getMapSize` are written.

  Parameters:
    `r` - the specified array into which the elements of the array of red color components are copied

### getGreens

    public final void getGreens(byte[] g)

  Copies the array of green color components into the specified array. Only the initial entries of the array as specified by `getMapSize` are written.

  Parameters:
    `g` - the specified array into which the elements of the array of green color components are copied

### getBlues

    public final void getBlues(byte[] b)

  Copies the array of blue color components into the specified array. Only the initial entries of the array as specified by `getMapSize` are written.

  Parameters:
    `b` - the specified array into which the elements of the array of blue color components are copied

### getAlphas

    public final void getAlphas(byte[] a)

  Copies the array of alpha transparency components into the specified array. Only the initial entries of the array as specified by `getMapSize` are written.

  Parameters:
    `a` - the specified array into which the elements of the array of alpha components are copied

### getRed

    public final int getRed(int pixel)

  Returns the red color component for the specified pixel, scaled from 0 to 255 in the default RGB ColorSpace, sRGB. The pixel value is specified as an int. The returned value is a non pre-multiplied value.

  Specified by:
    `getRed` in class `ColorModel`
  Parameters:
    `pixel` - the specified pixel
  Returns:
    the value of the red color component for the specified pixel

### getGreen

    public final int getGreen(int pixel)

  Returns the green color component for the specified pixel, scaled from 0 to 255 in the default RGB ColorSpace, sRGB. The pixel value is specified as an int. The returned value is a non pre-multiplied value.

  Specified by:
    `getGreen` in class `ColorModel`
  Parameters:
    `pixel` - the specified pixel
  Returns:
    the value of the green color component for the specified pixel

### getBlue

    public final int getBlue(int pixel)

  Returns the blue color component for the specified pixel, scaled from 0 to 255 in the default RGB ColorSpace, sRGB. The pixel value is specified as an int. The returned value is a non pre-multiplied value.

  Specified by:
    `getBlue` in class `ColorModel`
  Parameters:
    `pixel` - the specified pixel
  Returns:
    the value of the blue color component for the specified pixel

### getAlpha

    public final int getAlpha(int pixel)

  Returns the alpha component for the specified pixel, scaled from 0 to 255. The pixel value is specified as an int.

  Specified by:
    `getAlpha` in class `ColorModel`
  Parameters:
    `pixel` - the specified pixel
  Returns:
    the value of the alpha component for the specified pixel

### getRGB

    public final int getRGB(int pixel)

  Returns the color/alpha components of the pixel in the default RGB color model format. The pixel value is specified as an int. The returned value is in a non pre-multiplied format.

  Overrides:
    `getRGB` in class `ColorModel`
  Parameters:
    `pixel` - the specified pixel
  Returns:
    the color and alpha components of the specified pixel
  See Also:
    `ColorModel.getRGBdefault()`

### finalize

    public void finalize()

  Disposes of system resources associated with this `ColorModel` once this `ColorModel` is no longer referenced.

  Overrides:
    `finalize` in class `ColorModel`

### toString

    public String toString()

  Returns the `String` representation of the contents of this `ColorModel`object.

  Overrides:
    `toString` in class `ColorModel`
  Returns:
    a `String` representing the contents of this `ColorModel` object.

Overview | Package | Class | Use | Tree | Deprecated | Index | Help

PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD