java.awt.image

## Class ComponentColorModel

- java.lang.Object
- - java.awt.image.ColorModel
  - - java.awt.image.ComponentColorModel

All Implemented Interfaces:
  Transparency

    public class ComponentColorModel
    extends ColorModel

A `ColorModel` class that works with pixel values that represent color and alpha information as separate samples and that store each sample in a separate data element. This class can be used with an arbitrary `ColorSpace`. The number of color samples in the pixel values must be same as the number of color components in the `ColorSpace`. There may be a single alpha sample.

For those methods that use a primitive array pixel representation of type `transferType`, the array length is the same as the number of color and alpha samples. Color samples are stored first in the array followed by the alpha sample, if present. The order of the color samples is specified by the `ColorSpace`. Typically, this order reflects the name of the color space type. For example, for `TYPE_RGB`, index 0 corresponds to red, index 1 to green, and index 2 to blue.

The translation from pixel sample values to color/alpha components for display or processing purposes is based on a one-to-one correspondence of samples to components. Depending on the transfer type used to create an instance of `ComponentColorModel`, the pixel sample values represented by that instance may be signed or unsigned and may be of integral type or float or double (see below for details). The translation from sample values to normalized color/alpha components must follow certain rules. For float and double samples, the translation is an identity, i.e. normalized component values are equal to the corresponding sample values. For integral samples, the translation should be only a simple scale and offset, where the scale and offset constants may be different for each component. The result of applying the scale and offset constants is a set of color/alpha component values, which are guaranteed to fall within a certain range. Typically, the range for a color component will be the range defined by the `getMinValue` and `getMaxValue` methods of the `ColorSpace` class. The range for an alpha component should be 0.0 to 1.0.

Instances of `ComponentColorModel` created with transfer types `DataBuffer.TYPE_BYTE`, `DataBuffer.TYPE_USHORT`, and `DataBuffer.TYPE_INT` have pixel sample values which are treated as unsigned integral values. The number of bits in a color or alpha sample of a pixel value might not be the same as the number of bits for the corresponding color or alpha sample passed to the `ComponentColorModel(ColorSpace, int[], boolean, boolean, int, int)` constructor. In that case, this class assumes that the least significant n bits of a sample value hold the component value, where n is the number of significant bits for the component passed to the constructor. It also assumes that any higher-order bits in a sample value are zero. Thus, sample values range from 0 to 2n - 1. This class maps these sample values to normalized color component values such that 0 maps to the value obtained from the `ColorSpace's` `getMinValue` method for each component and 2n - 1 maps to the value obtained from `getMaxValue`. To create a `ComponentColorModel` with a different color sample mapping requires subclassing this class and overriding the `getNormalizedComponents(Object, float[], int)` method. The mapping for an alpha sample always maps 0 to 0.0 and 2n - 1 to 1.0.

For instances with unsigned sample values, the unnormalized color/alpha component representation is only supported if two conditions hold. First, sample value value 0 must map to normalized component value 0.0 and sample value 2n - 1 to 1.0. Second the min/max range of all color components of the `ColorSpace` must be 0.0 to 1.0. In this case, the component representation is the n least significant bits of the corresponding sample. Thus each component is an unsigned integral value between 0 and 2n - 1, where n is the number of significant bits for a particular component. If these conditions are not met, any method taking an unnormalized component argument will throw an `IllegalArgumentException`.

Instances of `ComponentColorModel` created with transfer types `DataBuffer.TYPE_SHORT`, `DataBuffer.TYPE_FLOAT`, and `DataBuffer.TYPE_DOUBLE` have pixel sample values which are treated as signed short, float, or double values. Such instances do not support the unnormalized color/alpha component representation, so any methods taking such a representation as an argument will throw an `IllegalArgumentException` when called on one of these instances. The normalized component values of instances of this class have a range which depends on the transfer type as follows: for float samples, the full range of the float data type; for double samples, the full range of the float data type (resulting from casting double to float); for short samples, from approximately -maxVal to +maxVal, where maxVal is the per component maximum value for the `ColorSpace` (-32767 maps to -maxVal, 0 maps to 0.0, and 32767 maps to +maxVal). A subclass may override the scaling for short sample values to normalized component values by overriding the `getNormalizedComponents(Object, float[], int)` method. For float and double samples, the normalized component values are taken to be equal to the corresponding sample values, and subclasses should not attempt to add any non-identity scaling for these transfer types.

Instances of `ComponentColorModel` created with transfer types `DataBuffer.TYPE_SHORT`, `DataBuffer.TYPE_FLOAT`, and `DataBuffer.TYPE_DOUBLE` use all the bits of all sample values. Thus all color/alpha components have 16 bits when using `DataBuffer.TYPE_SHORT`, 32 bits when using `DataBuffer.TYPE_FLOAT`, and 64 bits when using `DataBuffer.TYPE_DOUBLE`. When the `ComponentColorModel(ColorSpace, int[], boolean, boolean, int, int)` form of constructor is used with one of these transfer types, the bits array argument is ignored.

It is possible to have color/alpha sample values which cannot be reasonably interpreted as component values for rendering. This can happen when `ComponentColorModel` is subclassed to override the mapping of unsigned sample values to normalized color component values or when signed sample values outside a certain range are used. (As an example, specifying an alpha component as a signed short value outside the range 0 to 32767, normalized range 0.0 to 1.0, can lead to unexpected results.) It is the responsibility of applications to appropriately scale pixel data before rendering such that color components fall within the normalized range of the `ColorSpace` (obtained using the `getMinValue` and `getMaxValue` methods of the `ColorSpace` class) and the alpha component is between 0.0 and 1.0. If color or alpha component values fall outside these ranges, rendering results are indeterminate.

Methods that use a single int pixel representation throw an `IllegalArgumentException`, unless the number of components for the `ComponentColorModel` is one and the component value is unsigned -- in other words, a single color component using a transfer type of `DataBuffer.TYPE_BYTE`, `DataBuffer.TYPE_USHORT`, or `DataBuffer.TYPE_INT` and no alpha.

A `ComponentColorModel` can be used in conjunction with a `ComponentSampleModel`, a `BandedSampleModel`, or a `PixelInterleavedSampleModel` to construct a `BufferedImage`.

See Also:
  `ColorModel`, `ColorSpace`, `ComponentSampleModel`, `BandedSampleModel`, `PixelInterleavedSampleModel`, `BufferedImage`

### 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
`ComponentColorModel(ColorSpace colorSpace, boolean hasAlpha, boolean isAlphaPremultiplied, int transparency, int transferType)` Constructs a `ComponentColorModel` from the specified parameters.
`ComponentColorModel(ColorSpace colorSpace, int[] bits, boolean hasAlpha, boolean isAlphaPremultiplied, int transparency, int transferType)` Constructs a `ComponentColorModel` from the specified parameters.

### Method Summary

Methods
`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`.
`SampleModel` `createCompatibleSampleModel(int w, int h)` Creates a `SampleModel` with the specified width and height, that has a data layout compatible with 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`.
`boolean` `equals(Object obj)` Compares this color model with another for equality.
`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.
`WritableRaster` `getAlphaRaster(WritableRaster raster)` Returns a `Raster` representing the alpha channel of an image, extracted from the input `Raster`.
`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[]` `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(float[] normComponents, int normOffset)` Returns a pixel value represented as an `int` in this `ColorModel`, given an array of normalized color/alpha components.
`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(float[] normComponents, int normOffset, Object obj)` Returns a data element array representation of a pixel in this `ColorModel`, given an array of normalized 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.
`float[]` `getNormalizedComponents(int[] components, int offset, float[] normComponents, int normOffset)` Returns an array of all of the color/alpha components in normalized form, given an unnormalized component array.
`float[]` `getNormalizedComponents(Object pixel, float[] normComponents, int normOffset)` Returns an array of all of the color/alpha components in normalized form, given a pixel in this `ColorModel`.
`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` `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.
`int[]` `getUnnormalizedComponents(float[] normComponents, int normOffset, int[] components, int offset)` Returns an array of all of the color/alpha components in unnormalized form, given a normalized component array.
`boolean` `isCompatibleRaster(Raster raster)` Returns true if `raster` is compatible with this `ColorModel`; false if it is not.
`boolean` `isCompatibleSampleModel(SampleModel sm)` Checks whether or not the specified `SampleModel` is compatible with this `ColorModel`.

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

`finalize, getColorSpace, getComponentSize, getComponentSize, getNumColorComponents, getNumComponents, getPixelSize, getRGBdefault, getTransferType, getTransparency, hasAlpha, hashCode, isAlphaPremultiplied, toString`

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

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

### Constructor Detail

#### ComponentColorModel

    public ComponentColorModel(ColorSpace colorSpace,
                       int[] bits,
                       boolean hasAlpha,
                       boolean isAlphaPremultiplied,
                       int transparency,
                       int transferType)

Constructs a `ComponentColorModel` from the specified parameters. Color components will be in the specified `ColorSpace`. The supported transfer types are `DataBuffer.TYPE_BYTE`, `DataBuffer.TYPE_USHORT`, `DataBuffer.TYPE_INT`, `DataBuffer.TYPE_SHORT`, `DataBuffer.TYPE_FLOAT`, and `DataBuffer.TYPE_DOUBLE`. If not null, the `bits` array specifies the number of significant bits per color and alpha component and its length should be at least the number of components in the `ColorSpace` if there is no alpha information in the pixel values, or one more than this number if there is alpha information. When the `transferType` is `DataBuffer.TYPE_SHORT`, `DataBuffer.TYPE_FLOAT`, or `DataBuffer.TYPE_DOUBLE` the `bits` array argument is ignored. `hasAlpha` indicates whether alpha information is present. If `hasAlpha` is true, then 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` specifies what alpha values can be represented by this color model. The acceptable `transparency` values are `OPAQUE`, `BITMASK` or `TRANSLUCENT`. The `transferType` is the type of primitive array used to represent pixel values.

Parameters:
  `colorSpace` - The `ColorSpace` associated with this color model.
  `bits` - The number of significant bits per component. May be null, in which case all bits of all component samples will be significant. Ignored if transferType is one of `DataBuffer.TYPE_SHORT`, `DataBuffer.TYPE_FLOAT`, or `DataBuffer.TYPE_DOUBLE`, in which case all bits of all component samples will be significant.
  `hasAlpha` - If true, this color model supports alpha.
  `isAlphaPremultiplied` - If true, alpha is premultiplied.
  `transparency` - Specifies what alpha values can be represented by this color model.
  `transferType` - Specifies the type of primitive array used to represent pixel values.
Throws:
  `IllegalArgumentException` - If the `bits` array argument is not null, its length is less than the number of color and alpha components, and transferType is one of `DataBuffer.TYPE_BYTE`, `DataBuffer.TYPE_USHORT`, or `DataBuffer.TYPE_INT`.
  `IllegalArgumentException` - If transferType is not one of `DataBuffer.TYPE_BYTE`, `DataBuffer.TYPE_USHORT`, `DataBuffer.TYPE_INT`, `DataBuffer.TYPE_SHORT`, `DataBuffer.TYPE_FLOAT`, or `DataBuffer.TYPE_DOUBLE`.
See Also:
  `ColorSpace`, `Transparency`

#### ComponentColorModel

    public ComponentColorModel(ColorSpace colorSpace,
                       boolean hasAlpha,
                       boolean isAlphaPremultiplied,
                       int transparency,
                       int transferType)

Constructs a `ComponentColorModel` from the specified parameters. Color components will be in the specified `ColorSpace`. The supported transfer types are `DataBuffer.TYPE_BYTE`, `DataBuffer.TYPE_USHORT`, `DataBuffer.TYPE_INT`, `DataBuffer.TYPE_SHORT`, `DataBuffer.TYPE_FLOAT`, and `DataBuffer.TYPE_DOUBLE`. The number of significant bits per color and alpha component will be 8, 16, 32, 16, 32, or 64, respectively. The number of color components will be the number of components in the `ColorSpace`. There will be an alpha component if `hasAlpha` is `true`. If `hasAlpha` is true, then 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` specifies what alpha values can be represented by this color model. The acceptable `transparency` values are `OPAQUE`, `BITMASK` or `TRANSLUCENT`. The `transferType` is the type of primitive array used to represent pixel values.

Parameters:
  `colorSpace` - The `ColorSpace` associated with this color model.
  `hasAlpha` - If true, this color model supports alpha.
  `isAlphaPremultiplied` - If true, alpha is premultiplied.
  `transparency` - Specifies what alpha values can be represented by this color model.
  `transferType` - Specifies the type of primitive array used to represent pixel values.
Throws:
  `IllegalArgumentException` - If transferType is not one of `DataBuffer.TYPE_BYTE`, `DataBuffer.TYPE_USHORT`, `DataBuffer.TYPE_INT`, `DataBuffer.TYPE_SHORT`, `DataBuffer.TYPE_FLOAT`, or `DataBuffer.TYPE_DOUBLE`.
Since:
  1.4
See Also:
  `ColorSpace`, `Transparency`

### Method Detail

#### getRed

    public 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 will be a non pre-multiplied value. If the alpha is premultiplied, this method divides it out before returning the value (if the alpha value is 0, the red value will be 0).

Specified by:
  `getRed` in class `ColorModel`
Parameters:
  `pixel` - The pixel from which you want to get the red color component.
Returns:
  The red color component for the specified pixel, as an int.
Throws:
  `IllegalArgumentException` - If there is more than one component in this `ColorModel`.
  `IllegalArgumentException` - If the component value for this `ColorModel` is signed

#### getGreen

    public 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 will be a non pre-multiplied value. If the alpha is premultiplied, this method divides it out before returning the value (if the alpha value is 0, the green value will be 0).

Specified by:
  `getGreen` in class `ColorModel`
Parameters:
  `pixel` - The pixel from which you want to get the green color component.
Returns:
  The green color component for the specified pixel, as an int.
Throws:
  `IllegalArgumentException` - If there is more than one component in this `ColorModel`.
  `IllegalArgumentException` - If the component value for this `ColorModel` is signed

#### getBlue

    public 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 will be a non pre-multiplied value. If the alpha is premultiplied, this method divides it out before returning the value (if the alpha value is 0, the blue value will be 0).

Specified by:
  `getBlue` in class `ColorModel`
Parameters:
  `pixel` - The pixel from which you want to get the blue color component.
Returns:
  The blue color component for the specified pixel, as an int.
Throws:
  `IllegalArgumentException` - If there is more than one component in this `ColorModel`.
  `IllegalArgumentException` - If the component value for this `ColorModel` is signed

#### getAlpha

    public 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 pixel from which you want to get the alpha component.
Returns:
  The alpha component for the specified pixel, as an int.
Throws:
  `IllegalArgumentException` - If there is more than one component in this `ColorModel`.
  `IllegalArgumentException` - If the component value for this `ColorModel` is signed

#### getRGB

    public 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 returned value will be in a non pre-multiplied format. If the alpha is premultiplied, this method divides it out of the color components (if the alpha value is 0, the color values will be 0).

Overrides:
  `getRGB` in class `ColorModel`
Parameters:
  `pixel` - The pixel from which you want to get the color/alpha components.
Returns:
  The color/alpha components for the specified pixel, as an int.
Throws:
  `IllegalArgumentException` - If there is more than one component in this `ColorModel`.
  `IllegalArgumentException` - If the component value for this `ColorModel` is signed
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 will be a non pre-multiplied value. If the alpha is premultiplied, this method divides it out before returning the value (if the alpha value is 0, the red value will be 0). Since `ComponentColorModel` can be subclassed, subclasses inherit the implementation of this method and if they don't override it then they throw an exception if they use an unsupported `transferType`.

Overrides:
  `getRed` in class `ColorModel`
Parameters:
  `inData` - The pixel from which you want to get the red color component, specified by an array of data elements of type `transferType`.
Returns:
  The red color component for the specified pixel, as an int.
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 the transfer type of this `ComponentColorModel` is not one of the supported transfer types: `DataBuffer.TYPE_BYTE`, `DataBuffer.TYPE_USHORT`, `DataBuffer.TYPE_INT`, `DataBuffer.TYPE_SHORT`, `DataBuffer.TYPE_FLOAT`, or `DataBuffer.TYPE_DOUBLE`.

#### 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. If the alpha is premultiplied, this method divides it out before returning the value (if the alpha value is 0, the green value will be 0). Since `ComponentColorModel` can be subclassed, subclasses inherit the implementation of this method and if they don't override it then they throw an exception if they use an unsupported `transferType`.

Overrides:
  `getGreen` in class `ColorModel`
Parameters:
  `inData` - The pixel from which you want to get the green color component, specified by an array of data elements of type `transferType`.
Returns:
  The green color component for the specified pixel, as an int.
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 the transfer type of this `ComponentColorModel` is not one of the supported transfer types: `DataBuffer.TYPE_BYTE`, `DataBuffer.TYPE_USHORT`, `DataBuffer.TYPE_INT`, `DataBuffer.TYPE_SHORT`, `DataBuffer.TYPE_FLOAT`, or `DataBuffer.TYPE_DOUBLE`.

#### 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. If the alpha is premultiplied, this method divides it out before returning the value (if the alpha value is 0, the blue value will be 0). Since `ComponentColorModel` can be subclassed, subclasses inherit the implementation of this method and if they don't override it then they throw an exception if they use an unsupported `transferType`.

Overrides:
  `getBlue` in class `ColorModel`
Parameters:
  `inData` - The pixel from which you want to get the blue color component, specified by an array of data elements of type `transferType`.
Returns:
  The blue color component for the specified pixel, as an int.
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 the transfer type of this `ComponentColorModel` is not one of the supported transfer types: `DataBuffer.TYPE_BYTE`, `DataBuffer.TYPE_USHORT`, `DataBuffer.TYPE_INT`, `DataBuffer.TYPE_SHORT`, `DataBuffer.TYPE_FLOAT`, or `DataBuffer.TYPE_DOUBLE`.

#### 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. Since `ComponentColorModel` can be subclassed, subclasses inherit the implementation of this method and if they don't override it then they throw an exception if they use an unsupported `transferType`.

Overrides:
  `getAlpha` in class `ColorModel`
Parameters:
  `inData` - The pixel from which you want to get the alpha component, specified by an array of data elements of type `transferType`.
Returns:
  The alpha component for the specified pixel, as an int.
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 the transfer type of this `ComponentColorModel` is not one of the supported transfer types: `DataBuffer.TYPE_BYTE`, `DataBuffer.TYPE_USHORT`, `DataBuffer.TYPE_INT`, `DataBuffer.TYPE_SHORT`, `DataBuffer.TYPE_FLOAT`, or `DataBuffer.TYPE_DOUBLE`.

#### 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. The returned value is in a non pre-multiplied format. If the alpha is premultiplied, this method divides it out of the color components (if the alpha value is 0, the color values will be 0). Since `ComponentColorModel` can be subclassed, subclasses inherit the implementation of this method and if they don't override it then they throw an exception if they use an unsupported `transferType`.

Overrides:
  `getRGB` in class `ColorModel`
Parameters:
  `inData` - The pixel from which you want to get the color/alpha components, specified by an array of data elements of type `transferType`.
Returns:
  The color/alpha components for the specified pixel, as an int.
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 the transfer type of this `ComponentColorModel` is not one of the supported transfer types: `DataBuffer.TYPE_BYTE`, `DataBuffer.TYPE_USHORT`, `DataBuffer.TYPE_INT`, `DataBuffer.TYPE_SHORT`, `DataBuffer.TYPE_FLOAT`, or `DataBuffer.TYPE_DOUBLE`.
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` parameter is null, a new array is allocated. Since `ComponentColorModel` can be subclassed, subclasses inherit the implementation of this method and if they don't override it then they throw an exception if they use an unsupported `transferType`.

Overrides:
  `getDataElements` in class `ColorModel`
Parameters:
  `rgb` - the integer representation of the pixel in the RGB color model
  `pixel` - the specified pixel
Returns:
  The data element array representation of a pixel in this `ColorModel`.
Throws:
  `ClassCastException` - If `pixel` is not null and 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 the transfer type of this `ComponentColorModel` is not one of the supported transfer types: `DataBuffer.TYPE_BYTE`, `DataBuffer.TYPE_USHORT`, `DataBuffer.TYPE_INT`, `DataBuffer.TYPE_SHORT`, `DataBuffer.TYPE_FLOAT`, or `DataBuffer.TYPE_DOUBLE`.
See Also:
  `WritableRaster.setDataElements(int, int, java.lang.Object)`, `SampleModel.setDataElements(int, int, java.lang.Object, java.awt.image.DataBuffer)`

#### getComponents

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

Returns an array of unnormalized color/alpha components given a pixel in this `ColorModel`. An IllegalArgumentException is thrown if the component value for this `ColorModel` is not conveniently representable in the unnormalized form. Color/alpha components are stored in the `components` array starting at `offset` (even if the array is allocated by this method).

Overrides:
  `getComponents` in class `ColorModel`
Parameters:
  `pixel` - The pixel value specified as an integer.
  `components` - An integer array in which to store the unnormalized color/alpha components. If the `components` array is null, a new array is allocated.
  `offset` - An offset into the `components` array.
Returns:
  The components array.
Throws:
  `IllegalArgumentException` - If there is more than one component in this `ColorModel`.
  `IllegalArgumentException` - If this `ColorModel` does not support the unnormalized form
  `ArrayIndexOutOfBoundsException` - If the `components` array is not null and is not large enough to hold all the color and alpha components (starting at offset).

#### getComponents

    public 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. An IllegalArgumentException is thrown if the component values for this `ColorModel` are not conveniently representable in the unnormalized form. Color/alpha components are stored in the `components` array starting at `offset` (even if the array is allocated by this method). Since `ComponentColorModel` can be subclassed, subclasses inherit the implementation of this method and if they don't override it then this method might throw an exception if they use an unsupported `transferType`.

Overrides:
  `getComponents` in class `ColorModel`
Parameters:
  `pixel` - A pixel value specified by an array of data elements of type `transferType`.
  `components` - An integer array in which to store the unnormalized color/alpha components. If the `components` array is null, a new array is allocated.
  `offset` - An offset into the `components` array.
Returns:
  The `components` array.
Throws:
  `IllegalArgumentException` - If this `ComponentColorModel` does not support the unnormalized form
  `UnsupportedOperationException` - in some cases iff the transfer type of this `ComponentColorModel` is not one of the following transfer types: `DataBuffer.TYPE_BYTE`, `DataBuffer.TYPE_USHORT`, or `DataBuffer.TYPE_INT`.
  `ClassCastException` - If `pixel` is not a primitive array of type `transferType`.
  `IllegalArgumentException` - If the `components` array is not null and is not large enough to hold all the color and alpha components (starting at offset), or if `pixel` is not large enough to hold a pixel value for this ColorModel.

#### getUnnormalizedComponents

    public int[] getUnnormalizedComponents(float[] normComponents,
                                  int normOffset,
                                  int[] components,
                                  int offset)

Returns an array of all of the color/alpha components in unnormalized form, given a normalized component array. Unnormalized components are unsigned integral values between 0 and 2n - 1, where n is the number of bits for a particular component. Normalized components are float values between a per component minimum and maximum specified by the `ColorSpace` object for this `ColorModel`. An `IllegalArgumentException` will be thrown if color component values for this `ColorModel` are not conveniently representable in the unnormalized form. If the `components` array is `null`, a new array will be allocated. The `components` array will be 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`). An `IllegalArgumentException` is thrown if the `normComponents` array is not large enough to hold all the color and alpha components starting at `normOffset`.

Overrides:
  `getUnnormalizedComponents` in class `ColorModel`
Parameters:
  `normComponents` - an array containing normalized components
  `normOffset` - the offset into the `normComponents` array at which to start retrieving normalized components
  `components` - an array that receives the components from `normComponents`
  `offset` - the index into `components` at which to begin storing normalized components from `normComponents`
Returns:
  an array containing unnormalized color and alpha components.
Throws:
  `IllegalArgumentException` - If this `ComponentColorModel` does not support the unnormalized form
  `IllegalArgumentException` - if the length of `normComponents` minus `normOffset` is less than `numComponents`

#### getNormalizedComponents

    public float[] getNormalizedComponents(int[] components,
                                  int offset,
                                  float[] normComponents,
                                  int normOffset)

Returns an array of all of the color/alpha components in normalized form, given an unnormalized component array. Unnormalized components are unsigned integral values between 0 and 2n - 1, where n is the number of bits for a particular component. Normalized components are float values between a per component minimum and maximum specified by the `ColorSpace` object for this `ColorModel`. An `IllegalArgumentException` will be thrown if color component values for this `ColorModel` are not conveniently representable in the unnormalized form. If the `normComponents` array is `null`, a new array will be allocated. The `normComponents` array will be returned. Color/alpha components are stored in the `normComponents` array starting at `normOffset` (even if the array is allocated by this method). An `ArrayIndexOutOfBoundsException` is thrown if the `normComponents` array is not `null` and is not large enough to hold all the color and alpha components (starting at `normOffset`). An `IllegalArgumentException` is thrown if the `components` array is not large enough to hold all the color and alpha components starting at `offset`.

Overrides:
  `getNormalizedComponents` in class `ColorModel`
Parameters:
  `components` - an array containing unnormalized components
  `offset` - the offset into the `components` array at which to start retrieving unnormalized components
  `normComponents` - an array that receives the normalized components
  `normOffset` - the index into `normComponents` at which to begin storing normalized components
Returns:
  an array containing normalized color and alpha components.
Throws:
  `IllegalArgumentException` - If this `ComponentColorModel` does not support the unnormalized form

#### 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.

Overrides:
  `getDataElement` in class `ColorModel`
Parameters:
  `components` - An array of unnormalized color/alpha components.
  `offset` - An offset into the `components` array.
Returns:
  A pixel value represented as an int.
Throws:
  `IllegalArgumentException` - If there is more than one component in this `ColorModel`.
  `IllegalArgumentException` - If this `ComponentColorModel` does not support the unnormalized form

#### 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.

Overrides:
  `getDataElements` in class `ColorModel`
Parameters:
  `components` - An array of unnormalized color/alpha components.
  `offset` - The integer offset into the `components` array.
  `obj` - The object in which to store the data element array representation of the pixel. If `obj` variable is null, a new array is allocated. If `obj` is not null, it must be a primitive array of type `transferType`. An `ArrayIndexOutOfBoundsException` is thrown if `obj` is not large enough to hold a pixel value for this `ColorModel`. Since `ComponentColorModel` can be subclassed, subclasses inherit the implementation of this method and if they don't override it then they throw an exception if they use an unsupported `transferType`.
Returns:
  The data element array representation of a pixel in this `ColorModel`.
Throws:
  `IllegalArgumentException` - If the components array is not large enough to hold all the color and alpha components (starting at offset).
  `ClassCastException` - If `obj` is not null and is not a primitive array of type `transferType`.
  `ArrayIndexOutOfBoundsException` - If `obj` is not large enough to hold a pixel value for this `ColorModel`.
  `IllegalArgumentException` - If this `ComponentColorModel` does not support the unnormalized form
  `UnsupportedOperationException` - If the transfer type of this `ComponentColorModel` is not one of the following transfer types: `DataBuffer.TYPE_BYTE`, `DataBuffer.TYPE_USHORT`, or `DataBuffer.TYPE_INT`.
See Also:
  `WritableRaster.setDataElements(int, int, java.lang.Object)`, `SampleModel.setDataElements(int, int, java.lang.Object, java.awt.image.DataBuffer)`

#### getDataElement

    public int getDataElement(float[] normComponents,
                     int normOffset)

Returns a pixel value represented as an `int` in this `ColorModel`, given an array of normalized color/alpha components. This method will throw an `IllegalArgumentException` if pixel values for this `ColorModel` are not conveniently representable as a single `int`. An `ArrayIndexOutOfBoundsException` is thrown if the `normComponents` array is not large enough to hold all the color and alpha components (starting at `normOffset`).

Overrides:
  `getDataElement` in class `ColorModel`
Parameters:
  `normComponents` - an array of normalized color and alpha components
  `normOffset` - the index into `normComponents` at which to begin retrieving the color and alpha components
Returns:
  an `int` pixel value in this `ColorModel` corresponding to the specified components.
Throws:
  `IllegalArgumentException` - if pixel values for this `ColorModel` are not conveniently representable as a single `int`
  `ArrayIndexOutOfBoundsException` - if the `normComponents` array is not large enough to hold all of the color and alpha components starting at `normOffset`
Since:
  1.4

#### getDataElements

    public Object getDataElements(float[] normComponents,
                         int normOffset,
                         Object obj)

Returns a data element array representation of a pixel in this `ColorModel`, given an array of normalized color/alpha components. This array can then be passed to the `setDataElements` method of a `WritableRaster` object. An `ArrayIndexOutOfBoundsException` is thrown if the `normComponents` array is not large enough to hold all the color and alpha components (starting at `normOffset`). If the `obj` variable is `null`, a new array will be 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`.

Overrides:
  `getDataElements` in class `ColorModel`
Parameters:
  `normComponents` - an array of normalized color and alpha components
  `normOffset` - the index into `normComponents` at which to begin retrieving color and alpha components
  `obj` - a primitive data array to hold the returned pixel
Returns:
  an `Object` which is a primitive data array representation of a pixel
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 `normComponents` array is not large enough to hold all of the color and alpha components starting at `normOffset`
Since:
  1.4
See Also:
  `WritableRaster.setDataElements(int, int, java.lang.Object)`, `SampleModel.setDataElements(int, int, java.lang.Object, java.awt.image.DataBuffer)`

#### getNormalizedComponents

    public float[] getNormalizedComponents(Object pixel,
                                  float[] normComponents,
                                  int normOffset)

Returns an array of all of the color/alpha components in normalized form, 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`. Normalized components are float values between a per component minimum and maximum specified by the `ColorSpace` object for this `ColorModel`. If the `normComponents` array is `null`, a new array will be allocated. The `normComponents` array will be returned. Color/alpha components are stored in the `normComponents` array starting at `normOffset` (even if the array is allocated by this method). An `ArrayIndexOutOfBoundsException` is thrown if the `normComponents` array is not `null` and is not large enough to hold all the color and alpha components (starting at `normOffset`).

This method must be overrridden by a subclass if that subclass is designed to translate pixel sample values to color component values in a non-default way. The default translations implemented by this class is described in the class comments. Any subclass implementing a non-default translation must follow the constraints on allowable translations defined there.

Overrides:
  `getNormalizedComponents` in class `ColorModel`
Parameters:
  `pixel` - the specified pixel
  `normComponents` - an array to receive the normalized components
  `normOffset` - the offset into the `normComponents` array at which to start storing normalized components
Returns:
  an array containing normalized color and alpha components.
Throws:
  `ClassCastException` - if `pixel` is not a primitive array of type transferType
  `ArrayIndexOutOfBoundsException` - if `normComponents` is not large enough to hold all color and alpha components starting at `normOffset`
  `ArrayIndexOutOfBoundsException` - if `pixel` is not large enough to hold a pixel value for this `ColorModel`.
Since:
  1.4

#### coerceData

    public 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 also returns an instance of this `ColorModel` with the `isAlphaPremultiplied` flag set appropriately. 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:
  `NullPointerException` - if `raster` is `null` and data coercion is required.
  `UnsupportedOperationException` - if the transfer type of this `ComponentColorModel` is not one of the supported transfer types: `DataBuffer.TYPE_BYTE`, `DataBuffer.TYPE_USHORT`, `DataBuffer.TYPE_INT`, `DataBuffer.TYPE_SHORT`, `DataBuffer.TYPE_FLOAT`, or `DataBuffer.TYPE_DOUBLE`.

#### isCompatibleRaster

    public boolean isCompatibleRaster(Raster raster)

Returns true if `raster` is compatible with this `ColorModel`; 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` if it is not.

#### createCompatibleWritableRaster

    public 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 of the `WritableRaster` you want to create.
  `h` - The height of the `WritableRaster` you want to create.
Returns:
  A `WritableRaster` that is compatible with this `ColorModel`.
See Also:
  `WritableRaster`, `SampleModel`

#### createCompatibleSampleModel

    public SampleModel createCompatibleSampleModel(int w,
                                          int h)

Creates a `SampleModel` with the specified width and height, that has a data layout compatible with this `ColorModel`.

Overrides:
  `createCompatibleSampleModel` in class `ColorModel`
Parameters:
  `w` - The width of the `SampleModel` you want to create.
  `h` - The height of the `SampleModel` you want to create.
Returns:
  A `SampleModel` that is compatible with this `ColorModel`.
See Also:
  `SampleModel`

#### isCompatibleSampleModel

    public boolean isCompatibleSampleModel(SampleModel sm)

Checks whether or not the specified `SampleModel` is compatible with this `ColorModel`.

Overrides:
  `isCompatibleSampleModel` in class `ColorModel`
Parameters:
  `sm` - The `SampleModel` to test for compatibility.
Returns:
  `true` if the `SampleModel` is compatible with this `ColorModel`, `false` if it is not.
See Also:
  `SampleModel`

#### getAlphaRaster

    public WritableRaster getAlphaRaster(WritableRaster raster)

Returns a `Raster` representing the alpha channel of an image, extracted from the input `Raster`. This method assumes that `Raster` objects associated with this `ColorModel` store the alpha band, if present, as the last band of image data. Returns null if there is no separate spatial alpha channel associated with this `ColorModel`. This method creates a new `Raster`, but will share the data array.

Overrides:
  `getAlphaRaster` in class `ColorModel`
Parameters:
  `raster` - The `WritableRaster` from which to extract the alpha channel.
Returns:
  A `WritableRaster` containing the image's alpha channel.

#### equals

    public boolean equals(Object obj)

Compares this color model with another for equality.

Overrides:
  `equals` in class `ColorModel`
Parameters:
  `obj` - The object to compare with this color model.
Returns:
  `true` if the color model objects are equal, `false` if they are not.
See Also:
  `Object.hashCode()`, `Hashtable`

Copyright © 1993, 2014, Oracle and/or its affiliates. All rights reserved.