Constructs a new ColorConvertOp from two ColorSpace objects. The RenderingHints argument may be null. This Op is primarily useful for calling the filter method on Rasters in which case the two ColorSpaces define the operation to be performed on the Rasters. In that case the number of bands in the source Raster must match the number of components in srcCspace and the number of bands in the destination Raster must match the number of components in dstCspace. For BufferedImages the two ColorSpaces define intermediate spaces through which the source is converted before being converted to the destination space. @param srcCspace the source ColorSpace @param dstCspace the destination ColorSpace @param hints the RenderingHints object used to control the color conversion or null @throws NullPointerException if either srcCspace or dstCspace is null

Constructs a new ColorConvertOp from a ColorSpace object. The RenderingHints argument may be null. This Op can be used only with BufferedImages and is primarily useful when the BufferedImage filter} method is invoked with a destination argument of null. In that case the ColorSpace defines the destination color space for the destination created by the filter method. Otherwise the ColorSpace defines an intermediate space to which the source is converted before being converted to the destination space. @param cspace defines the destination ColorSpace or an intermediate ColorSpace @param hints the RenderingHints object used to control the color conversion or null @throws NullPointerException if cspace is null

Constructs a new ColorConvertOp from an array of ICC_Profiles. The RenderingHints argument may be null. The sequence of profiles may include profiles that represent color spaces profiles that represent effects etc. If the whole sequence does not represent a well-defined color conversion an exception is thrown.

For BufferedImages if the ColorSpace of the source BufferedImage does not match the requirements of the first profile in the array the first conversion is to an appropriate ColorSpace. If the requirements of the last profile in the array are not met by the ColorSpace of the destination BufferedImage the last conversion is to the destination's ColorSpace.

For Rasters the number of bands in the source Raster must match the requirements of the first profile in the array and the number of bands in the destination Raster must match the requirements of the last profile in the array. The array must have at least two elements or calling the filter method for Rasters will throw an IllegalArgumentException. @param profiles the array of ICC_Profile objects @param hints the RenderingHints object used to control the color conversion or null @exception IllegalArgumentException when the profile sequence does not specify a well-defined color conversion @exception NullPointerException if profiles is null

Creates a zeroed destination image with the correct size and number of bands given this source. @param src Source image for the filter operation. @param destCM ColorModel of the destination. If null an appropriate ColorModel will be used. @return a BufferedImage with the correct size and number of bands from the specified src. @throws IllegalArgumentException if destCM is null and this ColorConvertOp was created without any ICC_Profile or ColorSpace defined for the destination

The ColorModel abstract class encapsulates the methods for translating a pixel value to color components (for example red green and blue) and an alpha component. In order to render an image to the screen a printer or another image pixel values must be converted to color and alpha components. As arguments to or return values from methods of this class pixels are represented as 32-bit ints or as arrays of primitive types. The number order and interpretation of color components for a ColorModel is specified by its ColorSpace. A ColorModel used with pixel data that does not include alpha information treats all pixels as opaque which is an alpha value of 1.0.

This ColorModel class supports two representations of pixel values. A pixel value can be a single 32-bit int or an array of primitive types. The Java(tm) Platform 1.0 and 1.1 APIs represented pixels as single byte or single int values. For purposes of the ColorModel class pixel value arguments were passed as ints. The Java(tm) 2 Platform API introduced additional classes for representing images. With BufferedImage or RenderedImage objects based on Raster and SampleModel classes pixel values might not be conveniently representable as a single int. Consequently ColorModel now has methods that accept pixel values represented as arrays of primitive types. The primitive type used by a particular ColorModel object is called its transfer type.

ColorModel objects used with images for which pixel values are not conveniently representable as a single int throw an IllegalArgumentException when methods taking a single int pixel argument are called. Subclasses of ColorModel must specify the conditions under which this occurs. This does not occur with DirectColorModel or IndexColorModel objects.

Currently the transfer types supported by the Java 2D(tm) API are DataBuffer.TYPE_BYTE DataBuffer.TYPE_USHORT DataBuffer.TYPE_INT DataBuffer.TYPE_SHORT DataBuffer.TYPE_FLOAT and DataBuffer.TYPE_INTDOUBLE. Most rendering operations will perform much faster when using ColorModels and images based on the first three of these types. In addition some image filtering operations are not supported for ColorModels and images based on the latter three types. The transfer type for a particular ColorModel object is specified when the object is created either explicitly or by default. All subclasses of ColorModel must specify what the possible transfer types are and how the number of elements in the primitive arrays representing pixels is determined.

For BufferedImages the transfer type of its Raster and of the Raster object's SampleModel (available from the getTransferType methods of these classes) must match that of the ColorModel. The number of elements in an array representing a pixel for the Raster and SampleModel (available from the getNumDataElements methods of these classes) must match that of the ColorModel.

The algorithm used to convert from pixel values to color and alpha components varies by subclass. For example there is not necessarily a one-to-one correspondence between samples obtained from the SampleModel of a BufferedImage object's Raster and color/alpha components. Even when there is such a correspondence the number of bits in a sample is not necessarily the same as the number of bits in the corresponding color/alpha component. Each subclass must specify how the translation from pixel values to color/alpha components is done.

Methods in the ColorModel class use two different representations of color and alpha components - a normalized form and an unnormalized form. In the normalized form each component is a float value between some minimum and maximum values. For the alpha component the minimum is 0.0 and the maximum is 1.0. For color components the minimum and maximum values for each component can be obtained from the ColorSpace object. These values will often be 0.0 and 1.0 (e.g. normalized component values for the default sRGB color space range from 0.0 to 1.0) but some color spaces have component values with different upper and lower limits. These limits can be obtained using the getMinValue and getMaxValue methods of the ColorSpace class. Normalized color component values are not premultiplied. All ColorModels must support the normalized form.

In the unnormalized form each component is an unsigned integral value between 0 and 2ⁿ - 1 where n is the number of significant bits for a particular component. If pixel values for a particular ColorModel represent color samples premultiplied by the alpha sample unnormalized color component values are also premultiplied. In theThe normalizedunnormalized form eachis used only with instances of ColorModel whose ColorSpace has minimum component isvalues of 0.0 for all components and maximum values of 1.0 for all components. The unnormalized form for color and alpha components can be a convenient representation for floatColorModels valuewhose normalized component values all lie between 0.0 and 1.0. NormalizedIn colorsuch cases the integral value 0 maps to 0.0 and the value 2ⁿ - 1 maps to 1.0. In other cases such as when the normalized component values arecan be either negative or positive the unnormalized form is not premultipliedconvenient. Such ColorModel objects throw an IllegalArgumentException when methods involving an unnormalized argument are called. Subclasses of ColorModel must specify the conditions under which this occurs. @see IndexColorModel @see ComponentColorModel @see PackedColorModel @see DirectColorModel @see java.awt.Image @see BufferedImage @see RenderedImage @see java.awt.color.ColorSpace @see SampleModel @see Raster @see DataBuffer @version 10 Feb 1997

Constructs a ColorModel that translates pixel values to color/alpha components. Color components will be in the specified ColorSpace. pixel_bits is the number of bits in the pixel values. The bits array specifies the number of significant bits per color and alpha component. Its length should be 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. hasAlpha indicates whether or not alpha information is present. The boolean isAlphaPremultiplied specifies how to interpret pixel values in which color and alpha information are represented as separate spatial bands. 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 transfer type is the type of primitive array used to represent pixel values. Note that the bits array contains the number of significant bits per color/alpha component after the translation from pixel values. For example for an IndexColorModel with pixel_bits equal to 16 the bits array might have four elements with each element set to 8. @param pixel_bits the number of bits in the pixel values @param bits array that specifies the number of significant bits per color and alpha component @param cspace the specified ColorSpace @param hasAlpha true if alpha information is present; false otherwise @param isAlphaPremultiplied true if color samples are assumed to be premultiplied by the alpha samples; false otherwise @param transparency what alpha values can be represented by this color model @param transferType the type of the array used to represent pixel values @throws IllegalArgumentException if the length of the bit array is less than the number of color or alpha components in this ColorModel or if the transparency is not a valid value. @throws IllegalArgumentException if the sum of the number of bits in bits is less than 1 or if any of the elements in bits is less than 0. @see java.awt.Transparency

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 IllegalArgumentException will be thrown if color component values for this ColorModel are not conveniently representable in the unnormalized form. An ArrayIndexOutOfBoundsException is thrown if pixel is not large enough to hold a pixel value for this ColorModel. This method can be used to retrieve the components for a specific pixel value in any ColorModel. 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). Since ColorModel is an abstract class any instance is an instance of a subclass. Subclasses must override this method since the implementation in this abstract class throws an UnsupportedOperationException. @param pixel the specified pixel @param components an array that receives the color and alpha components of the specified pixel @param offset the index into the components array at which to begin storing the color and alpha components of the specified pixel @return an array containing the color and alpha components of the specified pixel starting at the specified offset. @throws UnsupportedOperationException if this method is not supported by this ColorModel

Returns an array of unnormalized color/alpha components given a pixel in this ColorModel. The pixel value is specified as an int. An IllegalArgumentException will be thrown if pixel values for this ColorModel are not conveniently representable as a single int or if color component values for this ColorModel are not conveniently representable in the unnormalized form. For example this method can be used to retrieve the components for a specific pixel value in a DirectColorModel. 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). Since ColorModel is an abstract class any instance is an instance of a subclass. Subclasses must override this method since the implementation in this abstract class throws an UnsupportedOperationException. @param pixel the specified pixel @param components the array to receive the color and alpha components of the specified pixel @param offset the offset into the components array at which to start storing the color and alpha components @return an array containing the color and alpha components of the specified pixel starting at the specified offset. @throws UnsupportedOperationException if this method is not supported by this ColorModel

Returns an array of all of the color/alpha components in normalized form given an unnormalized component array. Unnormalized components are unsigned integral values between 0 and 2ⁿ - 1 where n is the number of bits for a particular component. Normalized components are float values between 0.0a per component minimum and 1maximum specified by the ColorSpace object for this ColorModel.0 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.

Since ColorModel is an abstract class any instance is an instance of a subclass. The default implementation of this method in this abstract class assumes that component values for this class are conveniently representable in the unnormalized form. Therefore subclasses which may have instances which do not support the unnormalized form must override this method. @param components an array containing unnormalized components @param offset the offset into the components array at which to start retrieving unnormalized components @param normComponents an array that receives the components fromnormalized components @param normOffset the index into normComponents at which to begin storing unnormalized components fromnormalized components @return an array containing normalized color and alpha components. @throws IllegalArgumentException If the component values for this ColorModel are not conveniently representable in the unnormalized form. @throws UnsupportedOperationException if the constructor of this ColorModel called the super(bits) constructor but did not override this method. See the constructor #ColorModel(int) @throws UnsupportedOperationException if this method is unable to determine the number of bits per component

Returns an array of all of the color/alpha components in unnormalized form given a normalized component array. Unnormalized components are unsigned integral values between 0 and 2ⁿ - 1 where n is the number of bits for a particular component. Normalized components are float values between 0.0a per component minimum and 1maximum specified by the ColorSpace object for this ColorModel.0 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. @param normComponents an array containing normalized components @param normOffset the offset into the normComponents array at which to start retrieving normalized components @param components an array that receives the components from normComponents @param offset the index into components at which to begin storing normalized components from normComponents @return an array containing unnormalized color and alpha components. @throws IllegalArgumentException If the component values for this ColorModel are not conveniently representable in the unnormalized form. @throws IllegalArgumentException if the length of normComponents minus normOffset is less than numComponents @throws UnsupportedOperationException if the constructor of this ColorModel called the super(bits) constructor but did not override this method. See the constructor #ColorModel(int)

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 transfer types supported are DataBuffer.TYPE_BYTE DataBuffer.TYPE_USHORT and DataBuffer.TYPE_INT.

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 componentsample passed to the ComponentColorModel(ColorSpace int[] boolean boolean int int) constructor. ThisIn that case this class assumes that the least significant n bits of a sample value hold the component value where n is the number of significant bits for the component passed to the constructor. It also assumes that any higher-order bits in a sample value are zero. Thus sample values range from 0 to 2ⁿ - 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 2ⁿ - 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 2ⁿ - 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 2ⁿ - 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 2ⁿ - 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 ColorModel @see ColorSpace @see ComponentSampleModel @see BandedSampleModel @see PixelInterleavedSampleModel @see BufferedImage @version 10 Feb 1997

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 Itsits 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. AnWhen the IllegalArgumentExceptiontransferType is thrown ifDataBuffer.TYPE_SHORT theDataBuffer.TYPE_FLOAT lengthor ofDataBuffer.TYPE_DOUBLE the array does not matchbits the number of componentsarray 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. Note@param that thecolorSpace The bitsColorSpace arrayassociated with containsthis thecolor model. @param bits The number of significant bits per color/alpha component. after the translation from pixelMay be null in which values.case @paramall colorSpace Thebits of ColorSpaceall associated with this color modelcomponent samples will be significant. @paramIgnored bits Theif transferType numberis one of significantDataBuffer.TYPE_SHORT DataBuffer.TYPE_FLOAT or DataBuffer.TYPE_DOUBLE in which case all bits perof all component samples will be significant. @param hasAlpha If true this color model supports alpha. @param isAlphaPremultiplied If true alpha is premultiplied. @param transparency Specifies what alpha values can be represented by this color model. @param transferType Specifies the type of primitive array used to represent pixel values. @throws IllegalArgumentException If the length of the bits array doesargument is not matchnull 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. @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. @see ColorSpace @see java.awt.Transparency

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. @throws NullPointerException if raster is null and data coercion is required. @throws 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_INTDOUBLE.

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. @param inData The pixel from which you want to get the alpha component specified by an array of data elements of type transferType. @return The alpha component for the specified pixel as an int. @throws ClassCastException If inData is not a primitive array of type transferType. @throws ArrayIndexOutOfBoundsException if inData is not large enough to hold a pixel value for this ColorModel. @throws 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_INTDOUBLE.

Returns the alpha component for the specified pixel scaled from 0 to 255. The pixel value is specified as an int. @param pixel The pixel from which you want to get the alpha component. @return The alpha component for the specified pixel as an int. @throws IllegalArgumentException If there is more than one component in this ColorModel. @throws IllegalArgumentException If the component value for this ColorModel is signed

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. @param inData The pixel from which you want to get the blue color component specified by an array of data elements of type transferType. @return The blue color component for the specified pixel as an int. @throws ClassCastException If inData is not a primitive array of type transferType. @throws ArrayIndexOutOfBoundsException if inData is not large enough to hold a pixel value for this ColorModel. @throws 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_INTDOUBLE.

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). @param pixel The pixel from which you want to get the blue color component. @return The blue color component for the specified pixel as an int. @throws IllegalArgumentException If there is more than one component in this ColorModel. @throws IllegalArgumentException If the component value for this ColorModel is signed

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. @param pixel A pixel value specified by an array of data elements of type transferType. @param components An integer array in which to store the unnormalized color/alpha components. If the components array is null a new array is allocated. @param offset An offset into the components array. @return The components array. @throws IllegalArgumentException If this ComponentColorModel does not support the unnormalized form @throws UnsupportedOperationException in some cases iff the transfer type of this ComponentColorModel is not one of the supportedfollowing transfer types: DataBuffer.TYPE_BYTE DataBuffer.TYPE_USHORT or DataBuffer.TYPE_INT. @throws ClassCastException If pixel is not a primitive array of type transferType. @throws 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.

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). @param pixel The pixel value specified as an integer. @param components An integer array in which to store the unnormalized color/alpha components. If the components array is null a new array is allocated. @param offset An offset into the components array. @return The components array. @throws IllegalArgumentException If there is more than one component in this ColorModel. @throws IllegalArgumentException If this ColorModel does not support the unnormalized form @throws ArrayIndexOutOfBoundsException If the components array is not null and is not large enough to hold all the color and alpha components (starting at offset).

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. @param inData The pixel from which you want to get the green color component specified by an array of data elements of type transferType. @return The green color component for the specified pixel as an int. @throws ClassCastException If inData is not a primitive array of type transferType. @throws ArrayIndexOutOfBoundsException if inData is not large enough to hold a pixel value for this ColorModel. @throws 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_INTDOUBLE.

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). @param pixel The pixel from which you want to get the green color component. @return The green color component for the specified pixel as an int. @throws IllegalArgumentException If there is more than one component in this ColorModel. @throws IllegalArgumentException If the component value for this ColorModel is signed

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. @param inData The pixel from which you want to get the color/alpha components specified by an array of data elements of type transferType. @return The color/alpha components for the specified pixel as an int. @throws ClassCastException If inData is not a primitive array of type transferType. @throws ArrayIndexOutOfBoundsException if inData is not large enough to hold a pixel value for this ColorModel. @throws 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_INTDOUBLE. @see ColorModel#getRGBdefault

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). @param pixel The pixel from which you want to get the color/alpha components. @return The color/alpha components for the specified pixel as an int. @throws IllegalArgumentException If there is more than one component in this ColorModel. @throws IllegalArgumentException If the component value for this ColorModel is signed

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. @param inData The pixel from which you want to get the red color component specified by an array of data elements of type transferType. @return The red color component for the specified pixel as an int. @throws ClassCastException If inData is not a primitive array of type transferType. @throws ArrayIndexOutOfBoundsException if inData is not large enough to hold a pixel value for this ColorModel. @throws 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_INTDOUBLE.

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). @param pixel The pixel from which you want to get the red color component. @return The red color component for the specified pixel as an int. @throws IllegalArgumentException If there is more than one component in this ColorModel. @throws IllegalArgumentException If the component value for this ColorModel is signed

Returns an array of all of the color/alpha components in unnormalized form given a normalized component array. Unnormalized components are unsigned integral values between 0 and 2ⁿ - 1 where n is the number of bits for a particular component. Normalized components are float values between 0.0a per component minimum and 1maximum specified by the ColorSpace object for this ColorModel.0 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. @param normComponents an array containing normalized components @param normOffset the offset into the normComponents array at which to start retrieving normalized components @param components an array that receives the components from normComponents @param offset the index into components at which to begin storing normalized components from normComponents @return an array containing unnormalized color and alpha components. @throws IllegalArgumentException if the lengthIf ofthis normComponentsComponentColorModel minusdoes normOffsetnot is less thansupport the unnormalized numComponentsform @throws UnsupportedOperationExceptionIllegalArgumentException if the constructorlength of this ColorModelnormComponents called theminus super(bits)normOffset constructor but did not override this method. Seeis the constructorless than #ColorModel(int)numComponents

This class represents image data which is stored such that each sample of a pixel occupies one data element of the DataBuffer. It stores the N samples which make up a pixel in N separate data array elements. Different bands may be in different banks of the DataBuffer. Accessor methods are provided so that image data can be manipulated directly. This class can support different kinds of interleaving e.g. band interleaving scanline interleaving and pixel interleaving. Pixel stride is the number of data array elements between two samples for the same band on the same scanline. Scanline stride is the number of data array elements between a given sample and the corresponding sample in the same column of the next scanline. Band offsets denote the number of data array elements from the first data array element of the bank of the DataBuffer holding each band to the first sample of the band. The bands are numbered from 0 to N-1. This class can represent image data for which each sample is an unsigned integral number which can be stored in 8 16 or 32 bits (allusing DataBuffer.TYPE_BYTE DataBuffer.TYPE_USHORT or DataBuffer.TYPE_INT respectively) data for which each sample is a signed integral number which can be stored in 16 bits (using DataBuffer.TYPE_SHORT) or data for which each sample is a signed float or double quantity (using DataBuffer.TYPE_FLOAT or DataBuffer.TYPE_DOUBLE respectively). All samples of a given ComponentSampleModel are stored with the same precision). All strides and offsets must be non-negative. This class supports TYPE_BYTE TYPE_USHORT TYPE_SHORT TYPE_INT TYPE_FLOAT TYPE_DOUBLE @see java.awt.image.PixelInterleavedSampleModel @see java.awt.image.BandedSampleModel

Constructs a ComponentSampleModel with the specified parameters. The number of bands will be given by the length of the bandOffsets array. All bands will be stored in the first bank of the DataBuffer. @param dataType Thethe data type for storing samples. @param w Thethe width (in pixels) of the region of image data described. @param h Thethe height (in pixels) of the region of image data described. @param pixelStride Thethe pixel stride of the region of image data described. @param scanlineStride Thethe line stride of the region of image data described. @param bandOffsets Thethe offsets of all bands. @throws IllegalArgumentException if w or h is not greater than 0 @throws IllegalArgumentException if pixelStride is less than 0 @throws IllegalArgumentException if scanlineStride is less than 0 @throws IllegalArgumentException if numBands is less than 1 @throws IllegalArgumentException if the product of w and h is greater than Integer.MAX_VALUE @throws IllegalArgumentException if dataType is not one of the supported data types

Constructs a ComponentSampleModel with the specified parameters. The number of bands will be given by the length of the bandOffsets array. Different bands may be stored in different banks of the DataBuffer. @param dataType Thethe data type for storing samples. @param w Thethe width (in pixels) of the region of image data described. @param h Thethe height (in pixels) of the region of image data described. @param pixelStride Thethe pixel stride of the region of image data described. @param scanlineStride The line stride of the region of image data described. @param bandIndices ThebankIndices the bank indices of all bands. @param bandOffsets Thethe band offsets of all bands. @throws IllegalArgumentException if w or h is not greater than 0 @throws IllegalArgumentException if pixelStride is less than 0 @throws IllegalArgumentException if scanlineStride is less than 0 @throws IllegalArgumentException if the length of bankIndices does not equal the length of bankOffsets @throws IllegalArgumentException if any of the bank indices of bandIndices is less than 0 @throws IllegalArgumentException if dataType is not one of the supported data types