DirectColorModel (Java Platform SE 8 )
Keywords: java.awt.image.DirectColorModel class
Date: 2015-11-19

java.awt.image

## Class DirectColorModel

- java.lang.Object
- - java.awt.image.ColorModel
  - - java.awt.image.PackedColorModel
    - - java.awt.image.DirectColorModel

- All Implemented Interfaces:
    Transparency

      public class DirectColorModel
      extends PackedColorModel

  The `DirectColorModel` class is a `ColorModel` class that works with pixel values that represent RGB color and alpha information as separate samples and that pack all samples for a single pixel into a single int, short, or byte quantity. This class can be used only with ColorSpaces of type ColorSpace.TYPE_RGB. In addition, for each component of the ColorSpace, the minimum normalized component value obtained via the `getMinValue()` method of ColorSpace must be 0.0, and the maximum value obtained via the `getMaxValue()` method must be 1.0 (these min/max values are typical for RGB spaces). There must be three color samples in the pixel values and there can be a single alpha sample. For those methods that use a primitive array pixel representation of type `transferType`, the array length is always one. The transfer types supported are DataBuffer.TYPE_BYTE, DataBuffer.TYPE_USHORT, and DataBuffer.TYPE_INT. Color and alpha samples are stored in the single element of the array in bits indicated by bit masks. Each bit mask must be contiguous and masks must not overlap. The same masks apply to the single int pixel representation used by other methods. The correspondence of masks and color/alpha samples is as follows:
  - Masks are identified by indices running from 0 through 2 if no alpha is present, or 3 if an alpha is present.
  - The first three indices refer to color samples; index 0 corresponds to red, index 1 to green, and index 2 to blue.
  - Index 3 corresponds to the alpha sample, if present.

  The translation from pixel values to color/alpha components for display or processing purposes is a one-to-one correspondence of samples to components. A `DirectColorModel` is typically used with image data which uses masks to define packed samples. For example, a `DirectColorModel` can be used in conjunction with a `SinglePixelPackedSampleModel` to construct a `BufferedImage`. Normally the masks used by the `SampleModel` and the `ColorModel` would be the same. However, if they are different, the color interpretation of pixel data will be done according to the masks of the `ColorModel`.

  A single int pixel representation is valid for all objects of this class, since it is always possible to represent pixel values used with this class in a single int. Therefore, methods which use this representation will not throw an `IllegalArgumentException` due to an invalid pixel value.

  This color model is similar to an X11 TrueColor visual. The default RGB ColorModel specified by the `getRGBdefault` method is a `DirectColorModel` with the following parameters:

       Number of bits:        32
       Red mask:              0x00ff0000
       Green mask:            0x0000ff00
       Blue mask:             0x000000ff
       Alpha mask:            0xff000000
       Color space:           sRGB
       isAlphaPremultiplied:  False
       Transparency:          Transparency.TRANSLUCENT
       transferType:          DataBuffer.TYPE_INT

  Many of the methods in this class are final. This is because 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 reasons, but you cannot override or modify the behavior of those methods.

  See Also:
    `ColorModel`, `ColorSpace`, `SinglePixelPackedSampleModel`, `BufferedImage`, `ColorModel.getRGBdefault()`

- - ### Field Summary

    - ### Fields inherited from class java.awt.image.ColorModel

      `pixel_bits, transferType`

    - ### Fields inherited from interface java.awt.Transparency

      `BITMASK, OPAQUE, TRANSLUCENT`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `DirectColorModel(ColorSpace space, int bits, int rmask, int gmask, int bmask, int amask, boolean isAlphaPremultiplied, int transferType)` Constructs a `DirectColorModel` from the specified parameters.
    `DirectColorModel(int bits, int rmask, int gmask, int bmask)` Constructs a `DirectColorModel` from the specified masks that indicate which bits in an `int` pixel representation contain the red, green and blue color samples.
    `DirectColorModel(int bits, int rmask, int gmask, int bmask, int amask)` Constructs a `DirectColorModel` from the specified masks that indicate which bits in an `int` pixel representation contain the red, green and blue color samples and the alpha sample, if present.

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `ColorModel` | `coerceData(WritableRaster raster, boolean isAlphaPremultiplied)` Forces the raster data to match the state specified in the `isAlphaPremultiplied` variable, assuming the data is currently correctly described by this `ColorModel`.
    `WritableRaster` | `createCompatibleWritableRaster(int w, int h)` Creates a `WritableRaster` with the specified width and height that has a data layout (`SampleModel`) compatible with this `ColorModel`.
    `int` | `getAlpha(int pixel)` Returns the alpha component for the specified pixel, scaled from 0 to 255.
    `int` | `getAlpha(Object inData)` Returns the alpha component for the specified pixel, scaled from 0 to 255.
    `int` | `getAlphaMask()` Returns the mask indicating which bits in an `int` pixel representation contain the alpha component.
    `int` | `getBlue(int pixel)` Returns the blue color component for the specified pixel, scaled from 0 to 255 in the default RGB `ColorSpace`, sRGB.
    `int` | `getBlue(Object inData)` Returns the blue color component for the specified pixel, scaled from 0 to 255 in the default RGB `ColorSpace`, sRGB.
    `int` | `getBlueMask()` Returns the mask indicating which bits in an `int` pixel representation contain the blue color component.
    `int[]` | `getComponents(int pixel, int[] components, int offset)` Returns an array of unnormalized color/alpha components given a pixel in this `ColorModel`.
    `int[]` | `getComponents(Object pixel, int[] components, int offset)` Returns an array of unnormalized color/alpha components given a pixel in this `ColorModel`.
    `int` | `getDataElement(int[] components, int offset)` Returns a pixel value represented as an `int` in this `ColorModel`, given an array of unnormalized color/alpha components.
    `Object` | `getDataElements(int[] components, int offset, Object obj)` Returns a data element array representation of a pixel in this `ColorModel`, given an array of unnormalized color/alpha components.
    `Object` | `getDataElements(int rgb, Object pixel)` Returns a data element array representation of a pixel in this `ColorModel`, given an integer pixel representation in the default RGB color model.
    `int` | `getGreen(int pixel)` Returns the green color component for the specified pixel, scaled from 0 to 255 in the default RGB `ColorSpace`, sRGB.
    `int` | `getGreen(Object inData)` Returns the green color component for the specified pixel, scaled from 0 to 255 in the default RGB `ColorSpace`, sRGB.
    `int` | `getGreenMask()` Returns the mask indicating which bits in an `int` pixel representation contain the green color component.
    `int` | `getRed(int pixel)` Returns the red color component for the specified pixel, scaled from 0 to 255 in the default RGB `ColorSpace`, sRGB.
    `int` | `getRed(Object inData)` Returns the red color component for the specified pixel, scaled from 0 to 255 in the default RGB `ColorSpace`, sRGB.
    `int` | `getRedMask()` Returns the mask indicating which bits in an `int` pixel representation contain the red color component.
    `int` | `getRGB(int pixel)` Returns the color/alpha components of the pixel in the default RGB color model format.
    `int` | `getRGB(Object inData)` Returns the color/alpha components for the specified pixel in the default RGB color model format.
    `boolean` | `isCompatibleRaster(Raster raster)` Returns `true` if `raster` is compatible with this `ColorModel` and `false` if it is not.
    `String` | `toString()` Returns a `String` that represents this `DirectColorModel`.

    - ### Methods inherited from class java.awt.image.PackedColorModel

      `createCompatibleSampleModel, equals, getAlphaRaster, getMask, getMasks, isCompatibleSampleModel`

    - ### Methods inherited from class java.awt.image.ColorModel

      `finalize, getColorSpace, getComponentSize, getComponentSize, getDataElement, getDataElements, getNormalizedComponents, getNormalizedComponents, getNumColorComponents, getNumComponents, getPixelSize, getRGBdefault, getTransferType, getTransparency, getUnnormalizedComponents, hasAlpha, hashCode, isAlphaPremultiplied`

    - ### Methods inherited from class java.lang.Object

      `clone, getClass, notify, notifyAll, wait, wait, wait`

- - ### Constructor Detail

    - #### DirectColorModel

          public DirectColorModel(int bits,
                                  int rmask,
                                  int gmask,
                                  int bmask)

      Constructs a `DirectColorModel` from the specified masks that indicate which bits in an `int` pixel representation contain the red, green and blue color samples. As pixel values do not contain alpha information, all pixels are treated as opaque, which means that alpha = 1.0. All of the bits in each mask must be contiguous and fit in the specified number of least significant bits of an `int` pixel representation. The `ColorSpace` is the default sRGB space. The transparency value is Transparency.OPAQUE. The transfer type is the smallest of DataBuffer.TYPE_BYTE, DataBuffer.TYPE_USHORT, or DataBuffer.TYPE_INT that can hold a single pixel.
      Parameters:
        `bits` - the number of bits in the pixel values; for example, the sum of the number of bits in the masks.
        `rmask` - specifies a mask indicating which bits in an integer pixel contain the red component
        `gmask` - specifies a mask indicating which bits in an integer pixel contain the green component
        `bmask` - specifies a mask indicating which bits in an integer pixel contain the blue component

    - #### DirectColorModel

          public DirectColorModel(int bits,
                                  int rmask,
                                  int gmask,
                                  int bmask,
                                  int amask)

      Constructs a `DirectColorModel` from the specified masks that indicate which bits in an `int` pixel representation contain the red, green and blue color samples and the alpha sample, if present. If `amask` is 0, pixel values do not contain alpha information and all pixels are treated as opaque, which means that alpha = 1.0. All of the bits in each mask must be contiguous and fit in the specified number of least significant bits of an `int` pixel representation. Alpha, if present, is not premultiplied. The `ColorSpace` is the default sRGB space. The transparency value is Transparency.OPAQUE if no alpha is present, or Transparency.TRANSLUCENT otherwise. The transfer type is the smallest of DataBuffer.TYPE_BYTE, DataBuffer.TYPE_USHORT, or DataBuffer.TYPE_INT that can hold a single pixel.
      Parameters:
        `bits` - the number of bits in the pixel values; for example, the sum of the number of bits in the masks.
        `rmask` - specifies a mask indicating which bits in an integer pixel contain the red component
        `gmask` - specifies a mask indicating which bits in an integer pixel contain the green component
        `bmask` - specifies a mask indicating which bits in an integer pixel contain the blue component
        `amask` - specifies a mask indicating which bits in an integer pixel contain the alpha component

    - #### DirectColorModel

          public DirectColorModel(ColorSpace space,
                                  int bits,
                                  int rmask,
                                  int gmask,
                                  int bmask,
                                  int amask,
                                  boolean isAlphaPremultiplied,
                                  int transferType)

      Constructs a `DirectColorModel` from the specified parameters. Color components are in the specified `ColorSpace`, which must be of type ColorSpace.TYPE_RGB and have minimum normalized component values which are all 0.0 and maximum values which are all 1.0. The masks specify which bits in an `int` pixel representation contain the red, green and blue color samples and the alpha sample, if present. If `amask` is 0, pixel values do not contain alpha information and all pixels are treated as opaque, which means that alpha = 1.0. All of the bits in each mask must be contiguous and fit in the specified number of least significant bits of an `int` pixel representation. If there is alpha, the `boolean` `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 transparency value is Transparency.OPAQUE, if no alpha is present, or Transparency.TRANSLUCENT otherwise. The transfer type is the type of primitive array used to represent pixel values and must be one of DataBuffer.TYPE_BYTE, DataBuffer.TYPE_USHORT, or DataBuffer.TYPE_INT.
      Parameters:
        `space` - the specified `ColorSpace`
        `bits` - the number of bits in the pixel values; for example, the sum of the number of bits in the masks.
        `rmask` - specifies a mask indicating which bits in an integer pixel contain the red component
        `gmask` - specifies a mask indicating which bits in an integer pixel contain the green component
        `bmask` - specifies a mask indicating which bits in an integer pixel contain the blue component
        `amask` - specifies a mask indicating which bits in an integer pixel contain the alpha component
        `isAlphaPremultiplied` - `true` if color samples are premultiplied by the alpha sample; `false` otherwise
        `transferType` - the type of array used to represent pixel values
      Throws:
        `IllegalArgumentException` - if `space` is not a TYPE_RGB space or if the min/max normalized component values are not 0.0/1.0.

  - ### Method Detail

    - #### getRedMask

          public final int getRedMask()

      Returns the mask indicating which bits in an `int` pixel representation contain the red color component.
      Returns:
        the mask, which indicates which bits of the `int` pixel representation contain the red color sample.

    - #### getGreenMask

          public final int getGreenMask()

      Returns the mask indicating which bits in an `int` pixel representation contain the green color component.
      Returns:
        the mask, which indicates which bits of the `int` pixel representation contain the green color sample.

    - #### getBlueMask

          public final int getBlueMask()

      Returns the mask indicating which bits in an `int` pixel representation contain the blue color component.
      Returns:
        the mask, which indicates which bits of the `int` pixel representation contain the blue color sample.

    - #### getAlphaMask

          public final int getAlphaMask()

      Returns the mask indicating which bits in an `int` pixel representation contain the alpha component.
      Returns:
        the mask, which indicates which bits of the `int` pixel representation contain the alpha sample.

    - #### 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. A color conversion is done if necessary. The pixel value is specified as an `int`. The returned value is a non pre-multiplied value. Thus, if the alpha is premultiplied, this method divides it out before returning the value. If the alpha value is 0, for example, the red value is 0.
      Specified by:
        `getRed` in class `ColorModel`
      Parameters:
        `pixel` - the specified pixel
      Returns:
        the red color component for the specified pixel, from 0 to 255 in the sRGB `ColorSpace`.

    - #### 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. A color conversion is done if necessary. The pixel value is specified as an `int`. The returned value is a non pre-multiplied value. Thus, if the alpha is premultiplied, this method divides it out before returning the value. If the alpha value is 0, for example, the green value is 0.
      Specified by:
        `getGreen` in class `ColorModel`
      Parameters:
        `pixel` - the specified pixel
      Returns:
        the green color component for the specified pixel, from 0 to 255 in the sRGB `ColorSpace`.

    - #### 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. A color conversion is done if necessary. The pixel value is specified as an `int`. The returned value is a non pre-multiplied value. Thus, if the alpha is premultiplied, this method divides it out before returning the value. If the alpha value is 0, for example, the blue value is 0.
      Specified by:
        `getBlue` in class `ColorModel`
      Parameters:
        `pixel` - the specified pixel
      Returns:
        the blue color component for the specified pixel, from 0 to 255 in the sRGB `ColorSpace`.

    - #### 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 of `pixel` from 0 to 255.

    - #### getRGB

          public final int getRGB(int pixel)

      Returns the color/alpha components of the pixel in the default RGB color model format. A color conversion is done if necessary. The pixel value is specified as an `int`. The returned value is in a non pre-multiplied format. Thus, if the alpha is premultiplied, this method divides it out of the color components. If the alpha value is 0, for example, the color values are each 0.
      Overrides:
        `getRGB` in class `ColorModel`
      Parameters:
        `pixel` - the specified pixel
      Returns:
        the RGB value of the color/alpha components of the specified pixel.
      See Also:
        `ColorModel.getRGBdefault()`

    - #### getRed

          public int getRed(Object inData)

      Returns the red color component for the specified pixel, scaled from 0 to 255 in the default RGB `ColorSpace`, sRGB. A color conversion is done if necessary. The pixel value is specified by an array of data elements of type `transferType` passed in as an object reference. The returned value is a non pre-multiplied value. Thus, if the alpha is premultiplied, this method divides it out before returning the value. If the alpha value is 0, for example, the red value is 0. If `inData` is not a primitive array of type `transferType`, a `ClassCastException` is thrown. An `ArrayIndexOutOfBoundsException` is thrown if `inData` is not large enough to hold a pixel value for this `ColorModel`. Since `DirectColorModel` can be subclassed, subclasses inherit the implementation of this method and if they don't override it then they throw an exception if they use an unsupported `transferType`. An `UnsupportedOperationException` is thrown if this `transferType` is not supported by this `ColorModel`.
      Overrides:
        `getRed` in class `ColorModel`
      Parameters:
        `inData` - the array containing the pixel value
      Returns:
        the value of the red component of the specified pixel.
      Throws:
        `ArrayIndexOutOfBoundsException` - if `inData` is not large enough to hold a pixel value for this color model
        `ClassCastException` - if `inData` is not a primitive array of type `transferType`
        `UnsupportedOperationException` - if this `transferType` is not supported by this color model

    - #### getGreen

          public int getGreen(Object inData)

      Returns the green color component for the specified pixel, scaled from 0 to 255 in the default RGB `ColorSpace`, sRGB. A color conversion is done if necessary. The pixel value is specified by an array of data elements of type `transferType` passed in as an object reference. The returned value is a non pre-multiplied value. Thus, if the alpha is premultiplied, this method divides it out before returning the value. If the alpha value is 0, for example, the green value is 0. If `inData` is not a primitive array of type `transferType`, a `ClassCastException` is thrown. An `ArrayIndexOutOfBoundsException` is thrown if `inData` is not large enough to hold a pixel value for this `ColorModel`. Since `DirectColorModel` can be subclassed, subclasses inherit the implementation of this method and if they don't override it then they throw an exception if they use an unsupported `transferType`. An `UnsupportedOperationException` is thrown if this `transferType` is not supported by this `ColorModel`.
      Overrides:
        `getGreen` in class `ColorModel`
      Parameters:
        `inData` - the array containing the pixel value
      Returns:
        the value of the green component of the specified pixel.
      Throws:
        `ArrayIndexOutOfBoundsException` - if `inData` is not large enough to hold a pixel value for this color model
        `ClassCastException` - if `inData` is not a primitive array of type `transferType`
        `UnsupportedOperationException` - if this `transferType` is not supported by this color model

    - #### getBlue

          public int getBlue(Object inData)

      Returns the blue color component for the specified pixel, scaled from 0 to 255 in the default RGB `ColorSpace`, sRGB. A color conversion is done if necessary. The pixel value is specified by an array of data elements of type `transferType` passed in as an object reference. The returned value is a non pre-multiplied value. Thus, if the alpha is premultiplied, this method divides it out before returning the value. If the alpha value is 0, for example, the blue value is 0. If `inData` is not a primitive array of type `transferType`, a `ClassCastException` is thrown. An `ArrayIndexOutOfBoundsException` is thrown if `inData` is not large enough to hold a pixel value for this `ColorModel`. Since `DirectColorModel` can be subclassed, subclasses inherit the implementation of this method and if they don't override it then they throw an exception if they use an unsupported `transferType`. An `UnsupportedOperationException` is thrown if this `transferType` is not supported by this `ColorModel`.
      Overrides:
        `getBlue` in class `ColorModel`
      Parameters:
        `inData` - the array containing the pixel value
      Returns:
        the value of the blue component of the specified pixel.
      Throws:
        `ArrayIndexOutOfBoundsException` - if `inData` is not large enough to hold a pixel value for this color model
        `ClassCastException` - if `inData` is not a primitive array of type `transferType`
        `UnsupportedOperationException` - if this `transferType` is not supported by this color model

    - #### getAlpha

          public int getAlpha(Object inData)

      Returns the alpha component for the specified pixel, scaled from 0 to 255. The pixel value is specified by an array of data elements of type `transferType` passed in as an object reference. If `inData` is not a primitive array of type `transferType`, a `ClassCastException` is thrown. An `ArrayIndexOutOfBoundsException` is thrown if `inData` is not large enough to hold a pixel value for this `ColorModel`. Since `DirectColorModel` can be subclassed, subclasses inherit the implementation of this method and if they don't override it then they throw an exception if they use an unsupported `transferType`. If this `transferType` is not supported, an `UnsupportedOperationException` is thrown.
      Overrides:
        `getAlpha` in class `ColorModel`
      Parameters:
        `inData` - the specified pixel
      Returns:
        the alpha component of the specified pixel, scaled from 0 to 255.
      Throws:
        `ClassCastException` - if `inData` is not a primitive array of type `transferType`
        `ArrayIndexOutOfBoundsException` - if `inData` is not large enough to hold a pixel value for this `ColorModel`
        `UnsupportedOperationException` - if this `tranferType` is not supported by this `ColorModel`

    - #### getRGB

          public int getRGB(Object inData)

      Returns the color/alpha components for the specified pixel in the default RGB color model format. A color conversion is done if necessary. The pixel value is specified by an array of data elements of type `transferType` passed in as an object reference. If `inData` is not a primitive array of type `transferType`, a `ClassCastException` is thrown. An `ArrayIndexOutOfBoundsException` is thrown if `inData` is not large enough to hold a pixel value for this `ColorModel`. The returned value is in a non pre-multiplied format. Thus, if the alpha is premultiplied, this method divides it out of the color components. If the alpha value is 0, for example, the color values is 0. Since `DirectColorModel` can be subclassed, subclasses inherit the implementation of this method and if they don't override it then they throw an exception if they use an unsupported `transferType`.
      Overrides:
        `getRGB` in class `ColorModel`
      Parameters:
        `inData` - the specified pixel
      Returns:
        the color and alpha components of the specified pixel.
      Throws:
        `UnsupportedOperationException` - if this `transferType` is not supported by this `ColorModel`
      See Also:
        `ColorModel.getRGBdefault()`

    - #### getDataElements

          public Object getDataElements(int rgb,
                                        Object pixel)

      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 `setDataElements` method of a `WritableRaster` object. If the pixel variable is `null`, a new array is allocated. If `pixel` is not `null`, it must be a primitive array of type `transferType`; otherwise, a `ClassCastException` is thrown. An `ArrayIndexOutOfBoundsException` is thrown if `pixel` is not large enough to hold a pixel value for this `ColorModel`. The pixel array is returned. Since `DirectColorModel` can be subclassed, subclasses inherit the implementation of this method and if they don't override it then they throw an exception if they use an unsupported `transferType`.
      Overrides:
        `getDataElements` in class `ColorModel`
      Parameters:
        `rgb` - the integer pixel representation in the default RGB color model
        `pixel` - the specified pixel
      Returns:
        an array representation of the specified pixel in this `ColorModel`
      Throws:
        `ClassCastException` - if `pixel` is not a primitive array of type `transferType`
        `ArrayIndexOutOfBoundsException` - if `pixel` is not large enough to hold a pixel value for this `ColorModel`
        `UnsupportedOperationException` - if this `transferType` is not supported by this `ColorModel`
      See Also:
        `WritableRaster.setDataElements(int, int, java.lang.Object)`, `SampleModel.setDataElements(int, int, java.lang.Object, java.awt.image.DataBuffer)`

    - #### getComponents

          public final int[] getComponents(int pixel,
                                           int[] components,
                                           int offset)

      Returns an array of unnormalized color/alpha components given a pixel in this `ColorModel`. The pixel value is specified as an `int`. If the `components` array is `null`, a new array is allocated. The `components` array is returned. Color/alpha components are stored in the `components` array starting at `offset`, even if the array is allocated by this method. An `ArrayIndexOutOfBoundsException` is thrown if the `components` array is not `null` and is not large enough to hold all the color and alpha components, starting at `offset`.
      Overrides:
        `getComponents` in class `ColorModel`
      Parameters:
        `pixel` - the specified pixel
        `components` - the array to receive the color and alpha components of the specified pixel
        `offset` - the offset into the `components` array at which to start storing the color and alpha components
      Returns:
        an array containing the color and alpha components of the specified pixel starting at the specified offset.

    - #### getComponents

          public final int[] getComponents(Object pixel,
                                           int[] components,
                                           int offset)

      Returns an array of unnormalized color/alpha components given a pixel in this `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 `ClassCastException` is thrown. An `ArrayIndexOutOfBoundsException` is thrown if `pixel` is not large enough to hold a pixel value for this `ColorModel`. If the `components` array is `null`, a new array is allocated. The `components` array is returned. Color/alpha components are stored in the `components` array starting at `offset`, even if the array is allocated by this method. An `ArrayIndexOutOfBoundsException` is thrown if the `components` array is not `null` and is not large enough to hold all the color and alpha components, starting at `offset`. Since `DirectColorModel` can be subclassed, subclasses inherit the implementation of this method and if they don't override it then they throw an exception if they use an unsupported `transferType`.
      Overrides:
        `getComponents` in class `ColorModel`
      Parameters:
        `pixel` - the specified pixel
        `components` - the array to receive the color and alpha components of the specified pixel
        `offset` - the offset into the `components` array at which to start storing the color and alpha components
      Returns:
        an array containing the color and alpha components of the specified pixel starting at the specified offset.
      Throws:
        `ClassCastException` - if `pixel` is not a primitive array of type `transferType`
        `ArrayIndexOutOfBoundsException` - if `pixel` is not large enough to hold a pixel value for this `ColorModel`, or if `components` is not `null` and is not large enough to hold all the color and alpha components, starting at `offset`
        `UnsupportedOperationException` - if this `transferType` is not supported by this color model

    - #### createCompatibleWritableRaster

          public final WritableRaster createCompatibleWritableRaster(int w,
                                                                     int h)

      Creates a `WritableRaster` with the specified width and height that has a data layout (`SampleModel`) compatible with this `ColorModel`.
      Overrides:
        `createCompatibleWritableRaster` in class `ColorModel`
      Parameters:
        `w` - the width to apply to the new `WritableRaster`
        `h` - the height to apply to the new `WritableRaster`
      Returns:
        a `WritableRaster` object with the specified width and height.
      Throws:
        `IllegalArgumentException` - if `w` or `h` is less than or equal to zero
      See Also:
        `WritableRaster`, `SampleModel`

    - #### getDataElement

          public int getDataElement(int[] components,
                                    int offset)

      Returns a pixel value represented as an `int` in this `ColorModel`, given an array of unnormalized color/alpha components. An `ArrayIndexOutOfBoundsException` is thrown if the `components` array is not large enough to hold all the color and alpha components, starting at `offset`.
      Overrides:
        `getDataElement` in class `ColorModel`
      Parameters:
        `components` - an array of unnormalized color and alpha components
        `offset` - the index into `components` at which to begin retrieving the color and alpha components
      Returns:
        an `int` pixel value in this `ColorModel` corresponding to the specified components.
      Throws:
        `ArrayIndexOutOfBoundsException` - if the `components` array is not large enough to hold all of the color and alpha components starting at `offset`

    - #### getDataElements

          public Object getDataElements(int[] components,
                                        int offset,
                                        Object obj)

      Returns a data element array representation of a pixel in this `ColorModel`, given an array of unnormalized color/alpha components. This array can then be passed to the `setDataElements` method of a `WritableRaster` object. An `ArrayIndexOutOfBoundsException` is thrown if the `components` array is not large enough to hold all the color and alpha components, starting at offset. If the `obj` variable is `null`, a new array is allocated. If `obj` is not `null`, it must be a primitive array of type `transferType`; otherwise, a `ClassCastException` is thrown. An `ArrayIndexOutOfBoundsException` is thrown if `obj` is not large enough to hold a pixel value for this `ColorModel`. Since `DirectColorModel` can be subclassed, subclasses inherit the implementation of this method and if they don't override it then they throw an exception if they use an unsupported `transferType`.
      Overrides:
        `getDataElements` in class `ColorModel`
      Parameters:
        `components` - an array of unnormalized color and alpha components
        `offset` - the index into `components` at which to begin retrieving color and alpha components
        `obj` - the `Object` representing an array of color and alpha components
      Returns:
        an `Object` representing an array of color and alpha components.
      Throws:
        `ClassCastException` - if `obj` is not a primitive array of type `transferType`
        `ArrayIndexOutOfBoundsException` - if `obj` is not large enough to hold a pixel value for this `ColorModel` or the `components` array is not large enough to hold all of the color and alpha components starting at `offset`
        `UnsupportedOperationException` - if this `transferType` is not supported by this color model
      See Also:
        `WritableRaster.setDataElements(int, int, java.lang.Object)`, `SampleModel.setDataElements(int, int, java.lang.Object, java.awt.image.DataBuffer)`

    - #### coerceData

          public final ColorModel coerceData(WritableRaster raster,
                                             boolean isAlphaPremultiplied)

      Forces the raster data to match the state specified in the `isAlphaPremultiplied` variable, assuming the data is currently correctly described by this `ColorModel`. It may multiply or divide the color raster data by alpha, or do nothing if the data is in the correct state. If the data needs to be coerced, this method will also return an instance of this `ColorModel` with the `isAlphaPremultiplied` flag set appropriately. This method will throw a `UnsupportedOperationException` if this transferType is not supported by this `ColorModel`. Since `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.
      Overrides:
        `coerceData` in class `ColorModel`
      Parameters:
        `raster` - the `WritableRaster` data
        `isAlphaPremultiplied` - `true` if the alpha is premultiplied; `false` otherwise
      Returns:
        a `ColorModel` object that represents the coerced data.
      Throws:
        `UnsupportedOperationException` - if this `transferType` is not supported by this color model

    - #### isCompatibleRaster

          public boolean isCompatibleRaster(Raster raster)

      Returns `true` if `raster` is compatible with this `ColorModel` and `false` if it is not.
      Overrides:
        `isCompatibleRaster` in class `ColorModel`
      Parameters:
        `raster` - the `Raster` object to test for compatibility
      Returns:
        `true` if `raster` is compatible with this `ColorModel`; `false` otherwise.

    - #### toString

          public String toString()

      Returns a `String` that represents this `DirectColorModel`.
      Overrides:
        `toString` in class `ColorModel`
      Returns:
        a `String` representing this `DirectColorModel`.

Submit a bug or feature
For further API reference and developer documentation, see Java SE Documentation. That documentation contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples.
Copyright © 1993, 2015, Oracle and/or its affiliates. All rights reserved.