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

Creates a new ComponentSampleModel with the specified width and height. The new SampleModel will have the same number of bands storage data type interleaving scheme and pixel stride as this SampleModel. @param w the width of the resulting SampleModel @param h the height of the resulting SampleModel @return a new ComponentSampleModel with the specified size @throws IllegalArgumentException if w or h is not greater than 0

Creates a DataBuffer that corresponds to this ComponentSampleModel. The DataBuffer object's data type number of banks and size willare be consistent with this ComponentSampleModel. @return a DataBuffer whose data type number of banks and size are consistent with this ComponentSampleModel.

ThisCreates creates a new ComponentSampleModel with a subset of the bands of this ComponentSampleModel. The new ComponentSampleModel can be used with any DataBuffer that the existing ComponentSampleModel can be used with. The new ComponentSampleModel/DataBuffer combination will represent an image with a subset of the bands of the original ComponentSampleModel/DataBuffer combination. @param bands a subset of bands from this ComponentSampleModel @return a ComponentSampleModel created with a subset of bands from this ComponentSampleModel.

Returns the band offset for all bands. @return the band offsets for all bands.

Returns the bank indices for all bands. @return the bank indices for all bands.

Returns data for a single pixel in a primitive array of type TransferType. For a ComponentSampleModel this will beis the same as the data type and samples will beare returned one per array element. Generally obj should be passed in as null so that the Object will beis created automatically and will be ofis the right primitive data type.

The following code illustrates transferring data for one pixel from DataBuffer db1 whose storage layout is described by ComponentSampleModel csm1 to DataBuffer db2 whose storage layout is described by ComponentSampleModel csm2. The transfer will generallyis beusually more efficient than using getPixel/ and setPixel.

 ComponentSampleModel csm1 csm2; DataBufferInt db1 db2; csm2.setDataElements(x y csm1.getDataElements(x y null db1) db2); 

Using getDataElements/ and setDataElements to transfer between two DataBuffer/SampleModel pairs is legitimate if the SampleModelsSampleModel objects have the same number of bands corresponding bands have the same number of bits per sample and the TransferTypesTransferTypes are the same.

If obj is non-not null it should be a primitive array of type TransferType. Otherwise a ClassCastException is thrown. An ArrayIndexOutOfBoundsException maymight be thrown if the coordinates are not in bounds or if obj is non-not null and is not large enough to hold the pixel data. @param x The X coordinate of the pixel location. @param  y The Ythe coordinatecoordinates of the pixel location. @param obj Ifif non-null a primitive array in which to return the pixel data. @param data Thethe DataBuffer containing the image data @return the data of the specified pixel @see #setDataElements(int int Object DataBuffer) @throws NullPointerException if data is null. @throws ArrayIndexOutOfBoundsException if the coordinates are not in bounds or if obj is too small to hold the ouput.

Returns the number of data elements needed to transfer a pixel viawith the getDataElementsin Object DataBuffer) } and setDataElementsin Object DataBuffer) } methods. For a ComponentSampleModel this is identical to the number of bands. @return the number of data elements needed to transfer a pixel with the getDataElements and setDataElements methods. @see java.awt.image.SampleModel#getNumDataElements @see #getNumBands

Gets the offset for the first band of pixel (x y). A sample of the first band can be retrieved from a DataBuffer data with a ComponentSampleModel csm as

 data.getElem(csm.getOffset(x y)); 

@param x  y the location of the pixel @return the offset for the first band of the specified pixel.

Gets the offset for band b of pixel (x y). A sample of band b can be retrieved from a DataBuffer data with a ComponentSampleModel csm as

 data.getElem(csm.getOffset(x y b)); 

@param x  y the location of the specified pixel @param b the specified band @return the offset for the specified band of the specified pixel.

Returns all samples for the specified pixel in an int array one sample per array element. An ArrayIndexOutOfBoundsException maymight be thrown if the coordinates are not in bounds. @param x The X coordinate of the pixel location. @param  y The Y coordinatecoordinates of the pixel location. @param iArray If non-null returns the samples in this array. @param data The DataBuffer containing the image data @return the samples of the specified pixel. @see #setPixel(int int int[] DataBuffer) @throws NullPointerException if data is null. @throws ArrayIndexOutOfBoundsException if the coordinates are not in bounds or if iArray is too small to hold the output.

Returns the pixel stride of this ComponentSampleModel. @return the pixel stride of this ComponentSampleModel.

Returns all samples for the specified rectangle of pixels in an int array one sample per array element. An ArrayIndexOutOfBoundsException maymight be thrown if the coordinates are not in bounds. @param x The X coordinate of the upper left pixel location. @param  y The Ythe coordinatecoordinates of the upper left pixel location. @param w The width of the pixel rectangle. @param h The height of the pixel rectangle. @param iArray If non-null returns the samples in this array. @param data The DataBuffer containing the image data @return the samples of the pixels within the specified region. @see #setPixels(int int int int int[] DataBuffer)

Returns as int the sample in a specified band for the pixel located at (x y). An ArrayIndexOutOfBoundsException maymight be thrown if the coordinates are not in bounds. @param x The X coordinate of the pixel location. @param  y The Ythe coordinatecoordinates of the pixel location. @param b Thethe band to return. @param data Thethe DataBuffer containing the image data. @return the sample in a specified band for the specified pixel @see #setSample(int int int int DataBuffer)

Returns the sample in a specified band for a pixel located at (x y) as a double. An ArrayIndexOutOfBoundsException maymight be thrown if the coordinates are not in bounds. @param x The X coordinate of the pixel location. @param  y The Y coordinatecoordinates of the pixel location. @param b The band to return. @param data The DataBuffer containing the image data @return a double value representing the sample in the specified band for the specified pixel.

Returns the sample in a specified band for the pixel located at (x y) as a float. An ArrayIndexOutOfBoundsException maymight be thrown if the coordinates are not in bounds. @param x The X coordinate of the pixel location. @param  y The Y coordinatecoordinates of the pixel location. @param b The band to return. @param data The DataBuffer containing the image data @return a float value representing the sample in the specified band for the specified pixel.

Returns the number of bits per sample for all bands. @return an array containing the number of bits per sample for all bands where each element in the array represents a band.

Returns the number of bits per sample for the specified band. @param band the specified band @return the number of bits per sample for the specified band.

Returns the samples in a specified band for the specified rectangle of pixels in an int array one sample per data array element. An ArrayIndexOutOfBoundsException maymight be thrown if the coordinates are not in bounds. @param x The X coordinate of the upper left pixel location. @param  y The Ythe coordinatecoordinates of the upper left pixel location. @param w Thethe width of the pixel rectangle. @param h Thethe height of the pixel rectangle. @param b Thethe band to return. @param iArray Ifif non-null returns the samples in this array. @param data Thethe DataBuffer containing the image data. @return the samples in the specified band of the specified pixel @see #setSamples(int int int int int int[] DataBuffer)

Returns the scanline stride of this ComponentSampleModel. @return the scanline stride of this ComponentSampleModel.

Sets the data for a single pixel in the specified DataBuffer from a primitive array of type TransferType. For a ComponentSampleModel this will beis the same as the data type and samples are transferred one per array element.

The following code illustrates transferring data for one pixel from DataBuffer db1 whose storage layout is described by ComponentSampleModel csm1 to DataBuffer db2 whose storage layout is described by ComponentSampleModel csm2. The transfer will generallyis beusually more efficient than using getPixel/ and setPixel.

 ComponentSampleModel csm1 csm2; DataBufferInt db1 db2; csm2.setDataElements(x y csm1.getDataElements(x y null db1) db2); 

Using getDataElements/ and setDataElements to transfer between two DataBuffer/SampleModel pairs is legitimate if the SampleModelsSampleModel objects have the same number of bands corresponding bands have the same number of bits per sample and the TransferTypesTransferTypes are the same.

A ClassCastException is thrown if obj must beis not a primitive array of type TransferType. Otherwise a ClassCastException is thrown. An ArrayIndexOutOfBoundsException maymight be thrown if the coordinates are not in bounds or if obj is not large enough to hold the pixel data. @param x The X coordinate of the pixel location. @param  y The Ythe coordinatecoordinates of the pixel location. @param obj Aa primitive array containing pixel data. @param data Thethe DataBuffer containing the image data. @see #getDataElements(int int Object DataBuffer)

Sets a pixel in the DataBuffer using an int array of samples for input. An ArrayIndexOutOfBoundsException maymight be thrown if the coordinates are not in bounds. @param x The X coordinate of the pixel location. @param  y The Y coordinatecoordinates of the pixel location. @param iArray The input samples in an int array. @param data The DataBuffer containing the image data. @see #getPixel(int int int[] DataBuffer)

Sets all samples for a rectangle of pixels from an int array containing one sample per array element. An ArrayIndexOutOfBoundsException maymight be thrown if the coordinates are not in bounds. @param x The X coordinate of the upper left pixel location. @param  y The Y coordinatecoordinates of the upper left pixel location. @param w The width of the pixel rectangle. @param h The height of the pixel rectangle. @param iArray The input samples in an int array. @param data The DataBuffer containing the image data. @see #getPixels(int int int int int[] DataBuffer)

Sets a sample in the specified band for the pixel located at (x y) in the DataBuffer using a double for input. An ArrayIndexOutOfBoundsException maymight be thrown if the coordinates are not in bounds. @param x The X coordinate of the pixel location. @param  y The Y coordinatecoordinates of the pixel location. @param b The band to set. @param s The input sample as a double. @param data The DataBuffer containing the image data. @see #getSample(int int int DataBuffer)

Sets a sample in the specified band for the pixel located at (x y) in the DataBuffer using a float for input. An ArrayIndexOutOfBoundsException maymight be thrown if the coordinates are not in bounds. @param x The X coordinate of the pixel location. @param  y The Y coordinatecoordinates of the pixel location. @param b The band to set. @param s The input sample as a float. @param data The DataBuffer containing the image data. @see #getSample(int int int DataBuffer)

Sets a sample in the specified band for the pixel located at (x y) in the DataBuffer using an int for input. An ArrayIndexOutOfBoundsException maymight be thrown if the coordinates are not in bounds. @param x The X coordinate of the pixel location. @param  y The Ythe coordinatecoordinates of the pixel location. @param b Thethe band to set. @param s Thethe input sample as an int. @param data Thethe DataBuffer containing the image data. @see #getSample(int int int DataBuffer)

Sets the samples in the specified band for the specified rectangle of pixels from an int array containing one sample per data array element. An ArrayIndexOutOfBoundsException maymight be thrown if the coordinates are not in bounds. @param x The X coordinate of the upper left pixel location. @param  y The Y coordinatecoordinates of the upper left pixel location. @param w The width of the pixel rectangle. @param h The height of the pixel rectangle. @param b The band to set. @param iArray The input samples in an int array. @param data The DataBuffer containing the image data. @see #getSamples(int int int int int int[] DataBuffer)

Constructs a ConvolveOp given a Kernel. The edge condition will be EDGE_ZERO_FILL. @param kernel the specified Kernel @see Kernel @see #EDGE_ZERO_FILL

Constructs a ConvolveOp given a Kernel an edge condition and a RenderingHints object (which may be null). @param kernel the specified Kernel @param edgeCondition the specified edge condition @param hints the specified RenderingHints object @see Kernel @see #EDGE_NO_OP @see #EDGE_ZERO_FILL @see java.awt.RenderingHints

Creates a zeroed destination image with the correct size and number of bands. If destCM is null an appropriate ColorModel will be used. @param src Source image for the filter operation. @param destCM ColorModel of the destination. Can be null. @return a destination BufferedImage with the correct size and number of bands.

Returns the edge condition. @return the edge condition of this ConvolveOp. @see #EDGE_NO_OP @see #EDGE_ZERO_FILL

Returns the Kernel. @return the Kernel of this ConvolveOp.

An ImageFilter class for cropping images. This class extends the basic ImageFilter Class to extract a given rectangular region of an existing Image and provide a source for a new image containing just the extracted region. It is meant to be used in conjunction with a FilteredImageSource object to produce cropped versions of existing images. @see FilteredImageSource @see ImageFilter @version 1.11 0212 12/0203/0001 @author Jim Graham

This class exists to wrap one or more data arrays. Each data array in the DataBuffer is referred to as a bank. Accessor methods for getting and setting elements of the DataBuffer's banks exist with and without a bank specifier. The methods without a bank specifier use the default 0th bank. The DataBuffer can optionally take an offset per bank so that data in an existing array can be used even if the interesting data doesn't start at array location zero. Getting or setting the 0th element of a bank uses the (0+offset)th element of the array. The size field specifies how much of the data array is available for use. Size + offset for a given bank should never be greater than the length of the associated data array. The data type of a data buffer indicates the type of the data array(s) and may also indicate additional semantics e.g. storing unsigned 8-bit data in elements of a byte array. The data type may be TYPE_UNDEFINED or one of the types defined below. Other types may be added in the future. Generally an object of class DataBuffer will be cast down to one of its data type specific subclasses to access data type specific methods for improved performance. Currently the Java 2D(tm) API image classes use only TYPE_BYTE TYPE_USHORT TYPE_INT TYPE_SHORT TYPE_FLOAT and TYPE_INTDOUBLE DataBuffers to store image data. @see java.awt.image.Raster @see java.awt.image.SampleModel

Returns the data type of this DataBuffer. @return the data type of this DataBuffer.

Returns the requested data array element from the first (default) bank as an integer. @param i the index of the requested data array element @return the data array element at the specified index. @see #setElem(int int) @see #setElem(int int int)

Returns the requested data array element from the specified bank as an integer. @param bank the specified bank @param i the index of the requested data array element @return the data array element at the specified index from the specified bank at the specified index. @see #setElem(int int) @see #setElem(int int int)

Returns the requested data array element from the first (default) bank as a double. The implementation in this class is to cast #getElem(iint) to a double. Subclasses maycan override this method if another implementation is needed. @param i the specified index @return a double value representing the element at the specified index in the data array. @see #setElemDouble(int double) @see #setElemDouble(int int double)

Returns the requested data array element from the specified bank as a double. The implementation in this class is to cast getElem(bank i) to a double. Subclasses may override this method if another implementation is needed. @param bank the specified bank @param i the specified index @return a double value representing the element from the specified bank at the specified index in the data array. @see #setElemDouble(int double) @see #setElemDouble(int int double)

Returns the requested data array element from the first (default) bank as a float. The implementation in this class is to cast getElem(i) to a float. Subclasses may override this method if another implementation is needed. @param i the index of the requested data array element @return a float value representing the data array element at the specified index. @see #setElemFloat(int float) @see #setElemFloat(int int float)

Returns the requested data array element from the specified bank as a float. The implementation in this class is to cast getElem(bank iint) to a float. Subclasses maycan override this method if another implementation is needed. @param bank the specified bank @param i the index of the requested data array element @return a float value representing the data array element from the specified bank at the specified index. @see #setElemFloat(int float) @see #setElemFloat(int int float)

Returns the number of banks in this DataBuffer. @return the number of banks.

Returns the offset of the default bank in array elements. @return the offset of the default bank.

Returns the offsets (in array elements) of all the banks. @return the offsets of all banks.

Returns the size (in array elements) of all banks. @return the size of all banks.

Sets the requested data array element in the first (default) bank from the given integer. @param i the specified index into the data array @param val the data to set the element at the specified index in the data array @see #getElem(int) @see #getElem(int int)

Sets the requested data array element in the specified bank from the given integer. @param bank the specified bank @param i the specified index into the data array @param val the data to set the element in the specified bank at the specified index in the data array @see #getElem(int) @see #getElem(int int)

Sets the requested data array element in the first (default) bank from the given double. The implementation in this class is to cast val to an int and call setElem.int) Subclasses maycan override this method if another implementation is needed. @param i the specified index @param val the value to set the element at the specified index in the data array @see #getElemDouble(int) @see #getElemDouble(int int)

Sets the requested data array element in the specified bank from the given double. The implementation in this class is to cast val to an int and call setElem.int) Subclasses maycan override this method if another implementation is needed. @param bank the specified bank @param i the specified index @param val the value to set the element in the specified bank at the specified index of the data array @see #getElemDouble(int) @see #getElemDouble(int int)

Sets the requested data array element in the first (default) bank from the given float. The implementation in this class is to cast val to an int and call setElem.int) Subclasses maycan override this method if another implementation is needed. @param i the specified index @param val the value to set the element at the specified index in the data array @see #getElemFloat(int) @see #getElemFloat(int int)

Sets the requested data array element in the specified bank from the given float. The implementation in this class is to cast * val to an int and call setElem.int) Subclasses maycan override this method if another implementation is needed. @param bank the specified bank @param i the specified index @param val the value to set the element in the specified bank at the specified index in the data array @see #getElemFloat(int) @see #getElemFloat(int int)

Tag for undefined data.

Returns the requested data array element from the first (default) bank. @param i The data array element you want to get. @return The requested data array element as an integer. @see #setElem(int int) @see #setElem(int int int)

Returns the requested data array element from the specified bank. @param bank The bank from which you want to get a data array element. @param i The data array element you want to get. @return The requested data array element as an integer. @see #setElem(int int) @see #setElem(int int int)

Sets the requested data array element in the first (default) bank to the specified value. @param i The data array element you want to set. @param val The integer value to which you want to set the data array element. @see #getElem(int) @see #getElem(int int)

Sets the requested data array element in the specified bank from the given integer. @param bank The bank in which you want to set the data array element. @param i The data array element you want to set. @param val The integer value to which you want to set the specified data array element. @see #getElem(int) @see #getElem(int int)

Returns the requested data array element from the first (default) bank. @param i The data array element you want to get. @return The requested data array element as an integer. @see #setElem(int int) @see #setElem(int int int)

Returns the requested data array element from the specified bank. @param bank The bank from which you want to get a data array element. @param i The data array element you want to get. @return The requested data array element as an integer. @see #setElem(int int) @see #setElem(int int int)

Sets the requested data array element in the first (default) bank to the specified value. @param i The data array element you want to set. @param val The integer value to which you want to set the data array element. @see #getElem(int) @see #getElem(int int)

Sets the requested data array element in the specified bank to the integer value i. @param bank The bank in which you want to set the data array element. @param i The data array element you want to set. @param val The integer value to which you want to set the specified data array element. @see #getElem(int) @see #getElem(int int)

Returns the requested data array element from the first (default) bank. @param i The data array element you want to get. @return The requested data array element as an integer. @see #setElem(int int) @see #setElem(int int int)

Returns the requested data array element from the specified bank. @param bank The bank from which you want to get a data array element. @param i The data array element you want to get. @return The requested data array element as an integer. @see #setElem(int int) @see #setElem(int int int)

Sets the requested data array element in the first (default) bank to the specified value. @param i The data array element you want to set. @param val The integer value to which you want to set the data array element. @see #getElem(int) @see #getElem(int int)

Sets the requested data array element in the specified bank from the given integer. @param bank The bank in which you want to set the data array element. @param i The data array element you want to set. @param val The integer value to which you want to set the specified data array element. @see #getElem(int) @see #getElem(int int)

Returns the requested data array element from the first (default) bank. @param i The data array element you want to get. @return The requested data array element as an integer. @see #setElem(int int) @see #setElem(int int int)

Returns the requested data array element from the specified bank. @param bank The bank from which you want to get a data array element. @param i The data array element you want to get. @return The requested data array element as an integer. @see #setElem(int int) @see #setElem(int int int)

Sets the requested data array element in the first (default) bank to the specified value. @param i The data array element you want to set. @param val The integer value to which you want to set the data array element. @see #getElem(int) @see #getElem(int int)

Sets the requested data array element in the specified bank from the given integer. @param bank The bank in which you want to set the data array element. @param i The data array element you want to set. @param val The integer value to which you want to set the specified data array element. @see #getElem(int) @see #getElem(int int)

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

• Masks are identified by indices running from 0 through 2 if no alpha is present or 3 if an alpha is present.
• The first three indices refer to color samples; index 0 corresponds to red index 1 to green and index 2 to blue.
• Index 3 corresponds to the alpha sample if present.

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

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

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

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

Many of the methods in this class are final. This is because the underlying native graphics code makes assumptions about the layout and operation of this class and those assumptions are reflected in the implementations of the methods here that are marked final. You can subclass this class for other reasons but you cannot override or modify the behavior of those methods. @see ColorModel @see ColorSpace @see SinglePixelPackedSampleModel @see BufferedImage @see ColorModel#getRGBdefault @version 10 Feb 1997

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

Returns an array of unnormalized color/alpha components given a pixel in this ColorModel. The pixel value is specified by an array of data elements of type transferType passed in as an object reference. If pixel is not a primitive array of type transferType a ClassCastException is thrown. An ArrayIndexOutOfBoundsException is thrown if pixel is not large enough to hold a pixel value for this ColorModel. If the components array is null a new array is allocated. The components array is returned. Color/alpha components are stored in the components array starting at offset even if the array is allocated by this method. An ArrayIndexOutOfBoundsException is thrown if the components array is not null and is not large enough to hold all the color and alpha components starting at offset. Since DirectColorModel can be subclassed subclasses inherit the implementation of this method and if they don't override it then they throw an exception if they use an unsupported transferType. @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. @exception ClassCastException if pixel is not a primitive array of type transferType @exception ArrayIndexOutOfBoundsException if pixel is not large enough to hold a pixel value for this ColorModel or if components is not null and is not large enough to hold all the color and alpha components starting at offset @exception UnsupportedOperationException if this transferType is not supported by this color model

This class is an implementation of the ImageProducer interface which takes an existing image and a filter object and uses them to produce image data for a new filtered version of the original image. Here is an example which filters an image by swapping the red and blue compents:

 Image src = getImage("doc:///demo/images/duke/T1.gif"); ImageFilter colorfilter = new RedBlueSwapFilter(); Image img = createImage(new FilteredImageSource(src.getSource() colorfilter)); 

@see ImageProducer @version 1.22 0224 12/0203/0001 @author Jim Graham

Constructs an ImageProducer object from an existing ImageProducer and a filter object. @param orig the specified ImageProducer @param imgf the specified ImageFilter @see ImageFilter @see java.awt.Component#createImage

Determines whether an ImageConsumer is on the list of consumers currently interested in data for this image. @param ic the specified ImageConsumer @return true if the ImageConsumer is on the list; false otherwise @see ImageConsumer

The interface for objects expressing interest in image data through the ImageProducer interfaces. When a consumer is added to an image producer the producer delivers all of the data about the image using the method calls defined in this interface. @see ImageProducer @version 1.17 0219 12/0203/0001 @author Jim Graham

The imageComplete method is called when the ImageProducer is finished delivering all of the pixels that the source image contains or when a single frame of a multi-frame animation has been completed or when an error in loading or producing the image has occured. The ImageConsumer should remove itself from the list of consumers registered with the ImageProducer at this time unless it is interested in successive frames. @param status the status of image loading @see ImageProducer#removeConsumer

TheSets the ColorModel object used for the majority of the pixels reported using the setPixels method calls. Note that each set of pixels delivered using setPixels contains its own ColorModel object so no assumption should be made that this model will be the only one used in delivering pixel values. A notable case where multiple ColorModel objects may be seen is a filtered image when for each set of pixels that it filters the filter determines whether the pixels can be sent on untouched using the original ColorModel or whether the pixels should be modified (filtered) and passed on using a ColorModel more convenient for the filtering process. @param model the specified ColorModel @see ColorModel

The dimensions of the source image are reported using the setDimensions method call. @param width the width of the source image @param height the height of the source image

Sets the hints that the ImageConsumer uses to process the pixels delivered by the ImageProducer. The ImageProducer can deliver the pixels in any order but the ImageConsumer may be able to scale or convert the pixels to the destination ColorModel more efficiently or with higher quality if it knows some information about how the pixels will be delivered up front. The setHints method should be called before any calls to any of the setPixels methods with a bit mask of hints about the manner in which the pixels will be delivered. If the ImageProducer does not follow the guidelines for the indicated hint the results are undefined. @param hintflags a set of hints that the ImageConsumer uses to process the pixels

TheDelivers the pixels of the image are delivered usingwith one or more calls to the setPixelsthis method. Each call specifies the location and size of the rectangle of source pixels that are contained in the array of pixels. The specified ColorModel object should be used to convert the pixels into their corresponding color and alpha components. Pixel (m n) is stored in the pixels array at index (n * scansize + m + off). The pixels delivered using this method are all stored as bytes. @param x  y the coordinates of the upper-left corner of the area of pixels to be set @param w the width of the area of pixels @param h the height of the area of pixels @param model the specified ColorModel @param pixels the array of pixels @param off the offset into the pixels array @param scansize the distance from one row of pixels to the next in the pixels array @see ColorModel

The pixels of the image are delivered using one or more calls to the setPixels method. Each call specifies the location and size of the rectangle of source pixels that are contained in the array of pixels. The specified ColorModel object should be used to convert the pixels into their corresponding color and alpha components. Pixel (m n) is stored in the pixels array at index (n * scansize + m + off). The pixels delivered using this method are all stored as ints. this method are all stored as ints. @param x  y the coordinates of the upper-left corner of the area of pixels to be set @param w the width of the area of pixels @param h the height of the area of pixels @param model the specified ColorModel @param pixels the array of pixels @param off the offset into the pixels array @param scansize the distance from one row of pixels to the next in the pixels array @see ColorModel

Sets the extensible list of properties associated with this image. @param props the list of properties to be associated with this image

This class implements a filter for the set of interface methods that are used to deliver data from an ImageProducer to an ImageConsumer. It is meant to be used in conjunction with a FilteredImageSource object to produce filtered versions of existing images. It is a base class that provides the calls needed to implement a "Null filter" which has no effect on the data being passed through. Filters should subclass this class and override the methods which deal with the data that needs to be filtered and modify it as necessary. @see FilteredImageSource @see ImageConsumer @version 1.23 0225 12/0203/0001 @author Jim Graham

Returns a unique instance of an ImageFilter object which will actually perform the filtering for the specified ImageConsumer. The default implementation just clones this object.

Note: This method is intended to be called by the ImageProducer of the Image whose pixels are being filtered. Developers using this class to filter pixels from an image should avoid calling this method directly since that operation could interfere with the filtering operation. @param ic the specified ImageConsumer @return an ImageFilter used to perform the filtering for the specified ImageConsumer.

An asynchronous update interface for receiving notifications about Image information as the Image is constructed. @version 1.24 0225 12/0203/0001 @author Jim Graham

The interface for objects which can produce the image data for Images. Each image contains an ImageProducer which is used to reconstruct the image whenever it is needed for example when a new size of the Image is scaled or when the width or height of the Image is being requested. @see ImageConsumer @version 1.16 0218 12/0203/0001 @author Jim Graham

ThisRegisters method is used to register an ImageConsumer with the ImageProducer for access to the image data during a later reconstruction of the Image. The ImageProducer may at its discretion start delivering the image data to the consumer using the ImageConsumer interface immediately or when the next available image reconstruction is triggered by a call to the startProduction method. @param ic the specified ImageConsumer @see #startProduction

ThisDetermines method determines if a givenspecified ImageConsumer object is currently registered with this ImageProducer as one of its consumers. @param ic the specified ImageConsumer @return true if the specified ImageConsumer is registered with this ImageProducer; false otherwise.

ThisRemoves method removes the givenspecified ImageConsumer object from the list of consumers currently registered to receive image data. It is not considered an error to remove a consumer that is not currently registered. The ImageProducer should stop sending data to this consumer as soon as is feasible. @param ic the specified ImageConsumer

ThisRequests method ison used by anbehalf of the ImageConsumer to request that the ImageProducer attempt to resend the image data one more time in TOPDOWNLEFTRIGHT order so that higher quality conversion algorithms which depend on receiving pixels in order can be used to produce a better output version of the image. The ImageProducer is free to ignore this call if it cannot resend the data in that order. If the data can be resent then the ImageProducer should respond by executing the following minimum set of ImageConsumer method calls:

 ic.setHints(TOPDOWNLEFTRIGHT | ); ic.setPixels(...); // As many times as needed ic.imageComplete(); 

@param ic the specified ImageConsumer @see ImageConsumer#setHints

This method bothRegisters registers the givenspecified ImageConsumer object as a consumer and starts an immediate reconstruction of the image data which will then be delivered to this consumer and any other consumer which maymight have already been registered with the producer. This method differs from the addConsumer method in that a reproduction of the image data should be triggered as soon as possible. @param ic the specified ImageConsumer @see #addConsumer

Constructs an IndexColorModel from an array of ints where each int is comprised of red green blue and optional alpha components in the default RGB color model format. The specified transparent index represents a pixel that is considered entirely transparent regardless of any alpha value specified for it. The array must have enough values in it to fill all of the needed component arrays of the specified size. The ColorSpace is the default sRGB space. The transparency value is Transparency.TRANSLUCENT if hasAlpha is true; otherwise it is Transparency.BITMASK if trans is a valid index into the colormap (between 0 and size - 1) or Transparency.OPAQUE if trans is not a valid index. @param bits the number of bits each pixel occupies @param size the size of the color component arrays @param cmap the array of color components @param start the starting offset of the first color component @param hasalpha indicates whether alpha values are contained in the cmap array @param trans the index of the fully transparent pixel @param transferType the data type of the array used to represent pixel values. The data type must be either DataBuffer.TYPE_BYTE or DataBuffer.TYPE_USHORT. @throws IllegalArgumentException if bits is less than 1 or greater than 16 @throws IllegalArgumentException if size is less than 1 @throws IllegalArgumentException if transferType is not one of DataBuffer.TYPE_BYTE or DataBuffer.TYPE_USHORT

Constructs an IndexColorModel from an int array where each int is comprised of red green blue and alpha components in the default RGB color model format. The array must have enough values in it to fill all of the needed component arrays of the specified size. The ColorSpace is the default sRGB space. The transfer type is the smallestmust be one of DataBuffer.TYPE_BYTE DataBuffer.TYPE_USHORT or DataBuffer.TYPE_INT that can hold a single pixel. The BigInteger object specifies the valid/invalid pixels in the cmap array. A pixel is valid if the BigInteger value at that index is set and is invalid if the BigInteger bit at that index is not set. @param bits the number of bits each pixel occupies @param size the size of the color component array @param cmap the array of color components @param start the starting offset of the first color component @param transferType the specified data type @param validBits a BigInteger object. If a bit is set in the BigInteger the pixel at that index is valid. If a bit is not set the pixel at that index is considered invalid. If null all pixels are valid. Only bits from 0 to map_size will be considered. @throws IllegalArgumentException if bits is less than 1 or greater than 16 @throws IllegalArgumentException if size is less than 1 @throws IllegalArgumentException if transferType is not one of DataBuffer.TYPE_BYTE or DataBuffer.TYPE_USHORT

Returns a new BufferedImage of TYPE_INT_ARGB or TYPE_INT_RGB that has a Raster with pixel data computed by expanding the indices in the source Raster using the color/alpha component arrays of this ColorModel. If forceARGB is true a TYPE_INT_ARGB image is returned regardless of whether or not this ColorModel has an alpha component array or a transparent pixel. @param raster the specified Raster @param forceARGB if true the returned BufferedImage is TYPE_INT_ARGB; otherwise it is TYPE_INT_RGB @return a BufferedImage created with the specified Raster @throws IllegalArgumentException if the raster argument is not compatible with this IndexColorModel

Constructs a LookupOp object given the lookup table and a RenderingHints object (which maymight be null). @param lookup the specified LookupTable @param hints the specified RenderingHints or null

Creates a zeroed destination image with the correct size and number of bands. If destCM is null an appropriate ColorModel will be used. @param src Source image for the filter operation. @param destCM ColorModel of the destination.'s CanColorModel which can be null. @return a filtered destination BufferedImage.

Creates a zeroed -destination Raster with the correct size and number of bands given this source. @param src the Raster to be transformed @return the zeroed-destination Raster.

Performs a lookup operation on a BufferedImage. If the color model in the source image is not the same as that in the destination image the pixels will be converted in the destination. If the destination image is null a BufferedImage will be created with an appropriate ColorModel. An IllegalArgumentException maymight be thrown if the number of arrays in the LookupTable does not meet the restrictions stated in the class comment above or if the source image has an IndexColorModel. @param src the BufferedImage to be filtered @param dst the BufferedImage in which to store the results of the filter operation @return the filtered BufferedImage. @throws IllegalArgumentException if the number of arrays in the LookupTable does not meet the restrictions described in the class comments or if the source image has an IndexColorModel.

Performs a lookup operation on a Raster. If the destination Raster is null a new Raster will be created. The IllegalArgumentException maymight be thrown if the source Raster and the destination RastersRaster do not have differentthe same numbersnumber of bands or if the number of arrays in the LookupTable does not meet the restrictions stated in the class comment above. @param src the source Raster to filter @param dst the destination WritableRaster for the filtered src @return the filtered WritableRaster. @throws IllegalArgumentException if the source and destinations rasters do not have the same number of bands or the number of arrays in the LookupTable does not meet the restrictions described in the class comments.

Returns the bounding box of the filtered destination image. Since this is not a geometric operation the bounding box does not change. @param src the BufferedImage to be filtered @return the bounds of the filtered definition image.

Returns the bounding box of the filtered destination Raster. Since this is not a geometric operation the bounding box does not change. @param src the Raster to be filtered @return the bounds of the filtered definition Raster.

Returns the location of the destination point given a point in the source. If dstPt is non-not null it will be used to hold the return value. Since this is not a geometric operation the srcPt will equal the dstPt. @param srcPt a Point2D that represents a point in the source image @param dstPt a Point2Dthat represents the location in the destination @return the Point2D in the destination that corresponds to the specified point in the source.

Returns the rendering hints for this op. @return the RenderingHints object associated with this op.

Returns the LookupTable. @return the LookupTable of this LookupOp.

Returns the number of components in the lookup table. @return the number of components in this LookupTable.

Returns the offset. @return the offset of this LookupTable.

Returns an int array of components for one pixel. SourceThe anddest destination may bearray contains the equal.result The destof the arraylookup and is returned. If dest is null a new array willis allocated. The source and destination can be allocatedequal. @param src the source array of components of one pixel @param dest the destination array of components for one pixel translated with this LookupTable @return an int array of components for one pixel.

This class is an implementation of the ImageProducer interface which uses an array to produce pixel values for an Image. Here is an example which calculates a 100x100 image representing a fade from black to blue along the X axis and a fade from black to red along the Y axis:

 int w = 100; int h = 100; int pix[] = new int[w * h]; int index = 0; for (int y = 0; y  The MemoryImageSource is also capable of managing a memory image which varies over time to allow animation or custom rendering. Here is an example showing how to set up the animation source and signal changes in the data (adapted from the MemoryAnimationSourceDemo by Garth Dickie): 
 int pixels[]; MemoryImageSource source; public void init() { int width = 50; int height = 50; int size = width * height; pixels = new int[size]; int value = getBackground().getRGB(); for (int i = 0; i  @see ImageProducer @version 1.23 0227 12/0203/0001 @author Jim Graham @author Animation capabilities inspired by the MemoryAnimationSource class written by Garth Dickie

Constructs an ImageProducer object which uses an array of bytes to produce data for an Image object. @param w the width of the rectangle of pixels @param h the height of the rectangle of pixels @param cm the specified ColorModel @param pix an array of pixels @param off the offset into the array of where to store the first pixel @param scan the distance from one row of pixels to the next in the array @see java.awt.Component#createImage

Constructs an ImageProducer object which uses an array of bytes to produce data for an Image object. @param w the width of the rectangle of pixels @param h the height of the rectangle of pixels @param cm the specified ColorModel @param pix an array of pixels @param off the offset into the array of where to store the first pixel @param scan the distance from one row of pixels to the next in the array @param props a list of properties that the ImageProducer uses to process an image @see java.awt.Component#createImage

Constructs an ImageProducer object which uses an array of integers to produce data for an Image object. @param w the width of the rectangle of pixels @param h the height of the rectangle of pixels @param cm the specified ColorModel @param pix an array of pixels @param off the offset into the array of where to store the first pixel @param scan the distance from one row of pixels to the next in the array @see java.awt.Component#createImage

Constructs an ImageProducer object which uses an array of integers to produce data for an Image object. @param w the width of the rectangle of pixels @param h the height of the rectangle of pixels @param cm the specified ColorModel @param pix an array of pixels @param off the offset into the array of where to store the first pixel @param scan the distance from one row of pixels to the next in the array @param props a list of properties that the ImageProducer uses to process an image @see java.awt.Component#createImage

Constructs an ImageProducer object which uses an array of integers in the default RGB ColorModel to produce data for an Image object. @param w the width of the rectangle of pixels @param h the height of the rectangle of pixels @param pix an array of pixels @param off the offset into the array of where to store the first pixel @param scan the distance from one row of pixels to the next in the array @see java.awt.Component#createImage @see ColorModel#getRGBdefault

Constructs an ImageProducer object which uses an array of integers in the default RGB ColorModel to produce data for an Image object. @param w the width of the rectangle of pixels @param h the height of the rectangle of pixels @param pix an array of pixels @param off the offset into the array of where to store the first pixel @param scan the distance from one row of pixels to the next in the array @param props a list of properties that the ImageProducer uses to process an image @see java.awt.Component#createImage @see ColorModel#getRGBdefault

Adds an ImageConsumer to the list of consumers interested in data for this image. @param ic the specified ImageConsumer @see ImageConsumer

DetermineDetermines if an ImageConsumer is on the list of consumers currently interested in data for this image. @param ic the specified ImageConsumer @return true if the ImageConsumer is on the list; false otherwise. @see ImageConsumer

SendSends a whole new buffer of pixels to any ImageConsumers that are currently interested in the data for this image and notify them that an animation frame is complete. This method only has effect if the animation flag has been turned on through the setAnimated() method. @see #newPixels(int int int int boolean) @see ImageConsumer @see #setAnimated

ChangeChanges to a new byte array to hold the pixels for this image. If the animation flag has been turned on through the setAnimated() method then the new pixels will be immediately delivered to any ImageConsumers that are currently interested in the data for this image. @param newpix the new pixel array @param newmodel the specified ColorModel @param offset the offset into the array @param scansize the distance from one row of pixels to the next in the array @see #newPixels(int int int int boolean) @see #setAnimated

SendSends a rectangular region of the buffer of pixels to any ImageConsumers that are currently interested in the data for this image and notify them that an animation frame is complete. This method only has effect if the animation flag has been turned on through the setAnimated() method. If the full buffer update flag was turned on with the setFullBufferUpdates() method then the rectangle parameters will be ignored and the entire buffer will always be sent. @param x the x coordinate of the upper left corner of the rectangle of pixels to be sent @param y the y coordinate of the upper left corner of the rectangle of pixels to be sent @param w the width of the rectangle of pixels to be sent @param h the height of the rectangle of pixels to be sent @see #newPixels(int int int int boolean) @see ImageConsumer @see #setAnimated @see #setFullBufferUpdates

SendSends a rectangular region of the buffer of pixels to any ImageConsumers that are currently interested in the data for this image. If the framenotify parameter is true then the consumers are also notified that an animation frame is complete. This method only has effect if the animation flag has been turned on through the setAnimated() method. If the full buffer update flag was turned on with the setFullBufferUpdates() method then the rectangle parameters will be ignored and the entire buffer will always be sent. @param x the x coordinate of the upper left corner of the rectangle of pixels to be sent @param y the y coordinate of the upper left corner of the rectangle of pixels to be sent @param w the width of the rectangle of pixels to be sent @param h the height of the rectangle of pixels to be sent @param framenotify true if the consumers should be sent a SINGLEFRAMEDONE notification @see ImageConsumer @see #setAnimated @see #setFullBufferUpdates

ChangeChanges to a new int array to hold the pixels for this image. If the animation flag has been turned on through the setAnimated() method then the new pixels will be immediately delivered to any ImageConsumers that are currently interested in the data for this image. @param newpix the new pixel array @param newmodel the specified ColorModel @param offset the offset into the array @param scansize the distance from one row of pixels to the next in the array @see #newPixels(int int int int boolean) @see #setAnimated

RemoveRemoves an ImageConsumer from the list of consumers interested in data for this image. @param ic the specified ImageConsumer @see ImageConsumer

Requests that a given ImageConsumer have the image data delivered one more time in top-down left-right order. @param ic the specified ImageConsumer @see ImageConsumer

ChangeChanges this memory image into a multi-frame animation or a single-frame static image depending on the animated parameter.

This method should be called immediately after the MemoryImageSource is constructed and before an image is created with it to ensure that all ImageConsumers will receive the correct multi-frame data. If an ImageConsumer is added to this ImageProducer before this flag is set then that ImageConsumer will see only a snapshot of the pixel data that was available when it connected. @param animated true if the image is a multi-frame animation

SpecifySpecifies whether this animated memory image should always be updated by sending the complete buffer of pixels whenever there is a change. This flag is ignored if the animation flag is not turned on through the setAnimated() method.

This method should be called immediately after the MemoryImageSource is constructed and before an image is created with it to ensure that all ImageConsumers will receive the correct pixel delivery hints. @param fullbuffers true if the complete pixel buffer should always be sent @see #setAnimated

Adds an ImageConsumer to the list of consumers interested in data for this image and immediately startstarts delivery of the image data through the ImageConsumer interface. @param ic the specified ImageConsumer image data through the ImageConsumer interface. @see ImageConsumer

Returns data for a single pixel in a primitive array of type TransferType. For a MultiPixelPackedSampleModel the array has one element and the type is the smallest of DataBuffer.TYPE_BYTE DataBuffer.TYPE_USHORT or DataBuffer.TYPE_INT that can hold a single pixel. Generally obj should be passed in as null so that the Object is created automatically and is the correct primitive data type.

The following code illustrates transferring data for one pixel from DataBuffer db1 whose storage layout is described by MultiPixelPackedSampleModel mppsm1 to DataBuffer db2 whose storage layout is described by MultiPixelPackedSampleModel mppsm2. The transfer is generally more efficient than using getPixel or setPixel.

 MultiPixelPackedSampleModel mppsm1 mppsm2; DataBufferInt db1 db2; mppsm2.setDataElements(x y mppsm1.getDataElements(x y null db1) db2); 

Using getDataElements or setDataElements to transfer between two DataBuffer/SampleModel pairs is legitimate if the SampleModels have the same number of bands corresponding bands have the same number of bits per sample and the TransferTypes are the same.

If obj is not null it should be a primitive array of type TransferType. Otherwise a ClassCastException is thrown. An ArrayIndexOutOfBoundsException is thrown if the coordinates are not in bounds or if obj is not null and is not large enough to hold the pixel data. @param x  y coordinates of the pixel location. @param obj a primitive array in which to return the pixel data or null. @param data the DataBuffer containing the image data. @return an Object containing data for the specified pixel. @exception ClassCastException if obj is not a primitive array of type TransferType or is not null @exception ArrayIndexOutOfBoundsException if the coordinates are not in bounds or if obj is not null or not large enough to hold the pixel data @see #setDataElements(int int Object DataBuffer)

Returns the specified single band pixel in the first element of an int array. ArrayIndexOutOfBoundsException is thrown if the coordinates are not in bounds. @param x  y the coordinates of the pixel location @param iArray the array containing the pixel to be returned or null @param data the DataBuffer where image data is stored @return an array containing the specified pixel. @exception ArrayIndexOutOfBoundsException if the coordinates are not in bounds @see #setPixel(int int int[] DataBuffer)

Returns as int the sample in a specified band for the pixel located at (x  y). An ArrayIndexOutOfBoundsException is thrown if the coordinates are not in bounds. @param x  y the coordinates of the specified pixel @param b the band to return which is assumed to be 0 @param data the DataBuffer containing the image data @return the specified band containing the sample of the specified pixel. @exception ArrayIndexOutOfBoundException if the specified coordinates are not in bounds. @see #setSample(int int int int DataBuffer)

Sets the data for a single pixel in the specified DataBuffer from a primitive array of type TransferType. For a MultiPixelPackedSampleModel only the first element of the array holds valid data and the type must be the smallest of DataBuffer.TYPE_BYTE DataBuffer.TYPE_USHORT or DataBuffer.TYPE_INT that can hold a single pixel.

The following code illustrates transferring data for one pixel from DataBuffer db1 whose storage layout is described by MultiPixelPackedSampleModel mppsm1 to DataBuffer db2 whose storage layout is described by MultiPixelPackedSampleModel mppsm2. The transfer is generally more efficient than using getPixel or setPixel.

 MultiPixelPackedSampleModel mppsm1 mppsm2; DataBufferInt db1 db2; mppsm2.setDataElements(x y mppsm1.getDataElements(x y null db1) db2); 

Using getDataElements or setDataElements to transfer between two DataBuffer/SampleModel pairs is legitimate if the SampleModel objects have the same number of bands corresponding bands have the same number of bits per sample and the TransferTypes are the same.

obj must be a primitive array of type TransferType. Otherwise a ClassCastException is thrown. An ArrayIndexOutOfBoundsException is thrown if the coordinates are not in bounds or if obj is not large enough to hold the pixel data. @param x  y the coordinates of the pixel location @param obj a primitive array containing pixel data @param data the DataBuffer containing the image data @see #getDataElements(int int Object DataBuffer)

Sets a pixel in the DataBuffer using an int array for input. ArrayIndexOutOfBoundsException is thrown if the coordinates are not in bounds. @param x  y the coordinates of the pixel location @param iArray the input pixel in an int array @param data the DataBuffer containing the image data @see #getPixel(int int int[] DataBuffer)

Sets a sample in the specified band for the pixel located at (x  y) in the DataBuffer using an int for input. An ArrayIndexOutOfBoundsException is thrown if the coordinates are not in bounds. @param x  y the coordinates of the specified pixel @param b the band to return which is assumed to be 0 @param s the input sample as an int @param data the DataBuffer where image data is stored @exception ArrayIndexOutOfBoundsException if the coordinates are not in bounds. @see #getSample(int int int DataBuffer)

The PixelGrabber class implements an ImageConsumer which can be attached to an Image or ImageProducer object to retrieve a subset of the pixels in that image. Here is an example:

 public void handlesinglepixel(int x int y int pixel) { int alpha = (pixel >> 24) & 0xff; int red = (pixel >> 16) & 0xff; int green = (pixel >> 8) & 0xff; int blue = (pixel ) & 0xff; // Deal with the pixel as necessary... } public void handlepixels(Image img int x int y int w int h) { int[] pixels = new int[w * h]; PixelGrabber pg = new PixelGrabber(img x y w h pixels 0 w); try { pg.grabPixels(); } catch (InterruptedException e) { System.err.println("interrupted waiting for pixels "); return; } if ((pg.getStatus() & ImageObserver.ABORT) = 0) { System.err.println("image fetch aborted or errored"); return; } for (int j = 0; j  @see ColorModel#getRGBdefault @version 1.19 0221 12/0203/0001 @author Jim Graham

Create a PixelGrabber object to grab the (x y w h) rectangular section of pixels from the image produced by the specified ImageProducer into the given array. The pixels are stored into the array in the default RGB ColorModel. The RGB data for pixel (i j) where (i j) is inside the rectangle (x y w h) is stored in the array at pix[(j - y) * scansize + (i - x) + off]. @seeparam ColorModel#getRGBdefaultip @paramthe ImageProducer that imgproduces the image from which to retrieve pixels from @param x the x coordinate of the upper left corner of the rectangle of pixels to retrieve from the image relative to the default (unscaled) size of the image @param y the y coordinate of the upper left corner of the rectangle of pixels to retrieve from the image @param w the width of the rectangle of pixels to retrieve @param h the height of the rectangle of pixels to retrieve @param pix the array of integers which are to be used to hold the RGB pixels retrieved from the image @param off the offset into the array of where to store the first pixel @param scansize the distance from one row of pixels to the next in the array @see ColorModel#getRGBdefault

Get the ColorModel for the pixels stored in the array. If the PixelGrabber was constructed with an explicit pixel buffer then this method will always return the default RGB ColorModel otherwise it may return null until the ColorModel used by the ImageProducer is known. Since the PixelGrabber may fall back on accumulating the data in the default RGB ColorModel at any time if the source image uses more than one ColorModel to deliver the data the ColorModel object returned by this method may change over time until the image grab is complete and may not reflect any of the ColorModel objects that was used by the ImageProducer to deliver the pixels. @return the ColorModel object used for storing the pixels @see #getStatus @see ColorModel#getRGBdefault @see #setColorModel(ColorModel)

Get the pixel buffer. If the PixelGrabber was not constructed with an explicit pixel buffer to hold the pixels then this method will return null until the size and format of the image data is known. Since the PixelGrabber may fall back on accumulating the data in the default RGB ColorModel at any time if the source image uses more than one ColorModel to deliver the data the array object returned by this method may change over time until the image grab is complete. @return either a byte array or an int array @see #getStatus @see #setPixels(int int int int ColorModel byte[] int int) @see #setPixels(int int int int ColorModel int[] int int)

Return the status of the pixels. The ImageObserver flags representing the available pixel information are returned. @see ImageObserver @return the bitwise OR of all relevant ImageObserver flags @see ImageObserver

The imageComplete method is part of the ImageConsumer API which this class must implement to retrieve the pixels.

Note: This method is intended to be called by the ImageProducer of the Image whose pixels are being grabbed. Developers using this class to retrieve pixels from an image should avoid calling this method directly since that operation could result in problems with retrieving the requested pixels. @param status the status of image loading

The setColorModel method is part of the ImageConsumer API which this class must implement to retrieve the pixels.

Note: This method is intended to be called by the ImageProducer of the Image whose pixels are being grabbed. Developers using this class to retrieve pixels from an image should avoid calling this method directly since that operation could result in problems with retrieving the requested pixels. @param model the specified ColorModel @see #getColorModel

The setDimensions method is part of the ImageConsumer API which this class must implement to retrieve the pixels.

Note: This method is intended to be called by the ImageProducer of the Image whose pixels are being grabbed. Developers using this class to retrieve pixels from an image should avoid calling this method directly since that operation could result in problems with retrieving the requested pixels. @param width the width of the dimension @param height the height of the dimension

The setHints method is part of the ImageConsumer API which this class must implement to retrieve the pixels.

Note: This method is intended to be called by the ImageProducer of the Image whose pixels are being grabbed. Developers using this class to retrieve pixels from an image should avoid calling this method directly since that operation could result in problems with retrieving the requested pixels. @param hints a set of hints used to process the pixels

The setPixels method is part of the ImageConsumer API which this class must implement to retrieve the pixels.

Note: This method is intended to be called by the ImageProducer of the Image whose pixels are being grabbed. Developers using this class to retrieve pixels from an image should avoid calling this method directly since that operation could result in problems with retrieving the requested pixels. @param srcX  srcY the coordinates of the upper-left corner of the area of pixels to be set @param srcW the width of the area of pixels @param srcH the height of the area of pixels @param model the specified ColorModel @param pixels the array of pixels @param srcOff the offset into the pixels array @param srcScan the distance from one row of pixels to the next in the pixels array @see #getPixels

The setPixels method is part of the ImageConsumer API which this class must implement to retrieve the pixels.

Note: This method is intended to be called by the ImageProducer of the Image whose pixels are being grabbed. Developers using this class to retrieve pixels from an image should avoid calling this method directly since that operation could result in problems with retrieving the requested pixels. @param srcX  srcY the coordinates of the upper-left corner of the area of pixels to be set @param srcW the width of the area of pixels @param srcH the height of the area of pixels @param model the specified ColorModel @param pixels the array of pixels @param srcOff the offset into the pixels array @param srcScan the distance from one row of pixels to the next in the pixels array @see #getPixels

The setProperties method is part of the ImageConsumer API which this class must implement to retrieve the pixels.

Note: This method is intended to be called by the ImageProducer of the Image whose pixels are being grabbed. Developers using this class to retrieve pixels from an image should avoid calling this method directly since that operation could result in problems with retrieving the requested pixels. @param props the list of properties

Creates a new PixelInterleavedSampleModel with the specified width and height. The new PixelInterleavedSampleModel will have the same number of bands storage data type and pixel stride as this PixelInterleavedSampleModel. The band offsets may be compressed such that the minimum of all of the band offsets is zero. @param w the width of the resulting SampleModel @param h the height of the resulting SampleModel @return a new SampleModel with the specified width and height. @throws IllegalArgumentException if w or h is not greater than 0

This class provides an easy way to create an ImageFilter which modifies the pixels of an image in the default RGB ColorModel. It is meant to be used in conjunction with a FilteredImageSource object to produce filtered versions of existing images. It is an abstract class that provides the calls needed to channel all of the pixel data through a single method which converts pixels one at a time in the default RGB ColorModel regardless of the ColorModel being used by the ImageProducer. The only method which needs to be defined to create a useable image filter is the filterRGB method. Here is an example of a definition of a filter which swaps the red and blue components of an image:

 class RedBlueSwapFilter extends RGBImageFilter { public RedBlueSwapFilter() { // The filter's operation does not depend on the // pixel's location so IndexColorModels can be // filtered directly. canFilterIndexColorModel = true; } public int filterRGB(int x int y int rgb) { return ((rgb & 0xff00ff00) | ((rgb & 0xff0000) >> 16) | ((rgb & 0xff) < 16)); } } 

@see FilteredImageSource @see ImageFilter @see ColorModel#getRGBdefault @version 1.19 0221 12/0203/0001 @author Jim Graham

Subclasses must specify a method to convert a single input pixel in the default RGB ColorModel to a single output pixel. @param x  y the coordinates of the pixel @param rgb the integer pixel representation in the default RGB color model @return a filtered pixel in the default RGB color model. @see ColorModel#getRGBdefault @see #filterRGBPixels

Filters a buffer of pixels in the default RGB ColorModel by passing them one by one through the filterRGB method. @param x  y the coordinates of the upper-left corner of the region of pixels @param w the width of the region of pixels @param h the height of the region of pixels @param pixels the array of pixels @param off the offset into the pixels array @param scansize the distance from one row of pixels to the next in the array @see ColorModel#getRGBdefault @see #filterRGB

Constructs a Raster with the given SampleModel and DataBuffer. The Raster's upper left corner is origin and it is the same size as the SampleModel. The DataBuffer is not initialized and must be compatible with SampleModel. @param sampleModel The SampleModel that specifies the layout. @param dataBuffer The DataBuffer that contains the image data. @param origin The Point that specifies the origin @throws RasterFormatException if computing either origin.x + sampleModel.getWidth() or origin.y + sampleModel.getHeight() results in integer overflow @throws NullPointerException either sampleModel or origin is null

Constructs a Raster with the given SampleModel DataBuffer and parent. aRegion specifies the bounding rectangle of the new Raster. When translated into the base Raster's coordinate system aRegion must be contained by the base Raster. (The base Raster is the Raster's ancestor which has no parent.) sampleModelTranslate specifies the sampleModelTranslateX and sampleModelTranslateY values of the new Raster. Note that this constructor should generally be called by other constructors or create methods it should not be used directly. @param sampleModel The SampleModel that specifies the layout. @param dataBuffer The DataBuffer that contains the image data. @param aRegion The Rectangle that specifies the image area. @param sampleModelTranslate The Point that specifies the translation from SampleModel to Raster coordinates. @param parent The parent (if any) of this raster @throws NullPointerException if any of sampleModel dataBuffer aRegion or sampleModelTranslate is null @throws RasterFormatException if aRegion has width or height less than or equal to zero or computing either aRegion.x + aRegion.width or aRegion.y + aRegion.height results in integer overflow

Constructs a Raster with the given SampleModel. The Raster's upper left corner is origin and it is the same size as the SampleModel. A DataBuffer large enough to describe the Raster is automatically created. @param sampleModel The SampleModel that specifies the layout. @param origin The Point that specified the origin @throws RasterFormatException if computing either origin.x + sampleModel.getWidth() or origin.y + sampleModel.getHeight() results in integer overflow @throws NullPointerException either sampleModel or origin is null

Creates a Raster based on a BandedSampleModel with the specified DataBuffer width height scanline stride bank indices and band offsets. The number of bands is inferred from bankIndices.length and bandOffsets.length which must be the same. The upper left corner of the Raster is given by the location argument. If location is null (0 0) will be used. @param dataBuffer the DataBuffer that contains the image data @param w the width in pixels of the image data @param h the height in pixels of the image data @param scanlineStride the line stride of the image data @param bankIndices the bank indices for each band @param bandOffsets the offsets of all bands @param location the upper-left corner of the Raster @return a WritableRaster object with the specified DataBuffer width height scanline stride bank indices and band offsets. @throws RasterFormatException if w or h is less than or equal to zero or computing either location.x + w or location.y + h results in integer overflow @throws IllegalArgumentException if dataType is not one of the supported data types which are DataBuffer.TYPE_BYTE DataBuffer.TYPE_USHORT or DataBuffer.TYPE_INT @throws NullPointerException if dataBuffer is null

Creates a Raster based on a BandedSampleModel with the specified data type width height and number of bands.

The upper left corner of the Raster is given by the location argument. If location is null (0 0) will be used. The dataType parameter should be one of the enumerated values defined in the DataBuffer class.

The only dataTypes supported currently are TYPE_BYTE TYPE_USHORT and TYPE_INT. @param dataType the data type for storing samples @param w the width in pixels of the image data @param h the height in pixels of the image data @param bands the number of bands @param location the upper-left corner of the Raster @return a WritableRaster object with the specified data type width height and number of bands. @throws RasterFormatException if w or h is less than or equal to zero or computing either location.x + w or location.y + h results in integer overflow @throws ArrayIndexOutOfBoundsException if bands is less than 1

Creates a Raster based on a BandedSampleModel with the specified data type width height scanline stride bank indices and band offsets. The number of bands is inferred from bankIndices.length and bandOffsets.length which must be the same.

The upper left corner of the Raster is given by the location argument. The dataType parameter should be one of the enumerated values defined in the DataBuffer class.

The only dataTypes supported currently are TYPE_BYTE TYPE_USHORT and TYPE_INT. @param dataType the data type for storing samples @param w the width in pixels of the image data @param h the height in pixels of the image data @param scanlineStride the line stride of the image data @param bankIndices the bank indices for each band @param bandOffsets the offsets of all bands @param location the upper-left corner of the Raster @return a WritableRaster object with the specified data type width height scanline stride bank indices and band offsets. @throws RasterFormatException if w or h is less than or equal to zero or computing either location.x + w or location.y + h results in integer overflow @throws IllegalArgumentException if dataType is not one of the supported data types which are DataBuffer.TYPE_BYTE DataBuffer.TYPE_USHORT or DataBuffer.TYPE_INT @throws ArrayIndexOutOfBoundsException if bankIndices or bandOffsets is null

Returns a new Raster which shares all or part of this Raster's DataBuffer. The new Raster will possess a reference to the current Raster accessible through its getParent() method.

The parentX parentY width and height parameters form a Rectangle in this Raster's coordinate space indicating the area of pixels to be shared. An error will be thrown if this Rectangle is not contained with the bounds of the current Raster.

The new Raster may additionally be translated to a different coordinate system for the plane than that used by the current Raster. The childMinX and childMinY parameters give the new (x y) coordinate of the upper-left pixel of the returned Raster; the coordinate (childMinX childMinY) in the new Raster will map to the same pixel as the coordinate (parentX parentY) in the current Raster.

The new Raster may be defined to contain only a subset of the bands of the current Raster possibly reordered by means of the bandList parameter. If bandList is null it is taken to include all of the bands of the current Raster in their current order.

To create a new Raster that contains a subregion of the current Raster but shares its coordinate system and bands this method should be called with childMinX equal to parentX childMinY equal to parentY and bandList equal to null. @param parentX X coordinate of the upper left corner in this Raster's coordinates. @param  parentY Y coordinatecoordinates of the upper -left corner in this Raster's coordinates. @param width Width of the region starting at (parentX parentY). @param height Height of the region starting at (parentX parentY). @param childMinX X coordinate of the upper left corner of the returned Raster. @param  childMinY Y coordinatecoordinates of the upper -left corner of the returned Raster. @param bandList Array of band indices or null to use all bands @return a new Raster. @exception RasterFormatException if the specified subregion is outside of the raster bounds. @throws RasterFormatException if width or height is less than or equal to zero or computing any of parentX + width parentY + height childMinX + width or childMinY + height results in integer overflow

Create a compatible WritableRaster the same size as this Raster with the same SampleModel and a new initialized DataBuffer. @return a compatible WritableRaster with the same sample model and a new data buffer.

Create a compatible WritableRaster with location (minX minY) and size (width height) specified by rect a new SampleModel and a new initialized DataBuffer. @param rect a Rectangle that specifies the size and location of the WritableRaster @return a compatible WritableRaster with the specified size and location and a new sample model and data buffer. @throws RasterFormatException if rect has width or height less than or equal to zero or computing either rect.x + rect.width or rect.y + rect.height results in integer overflow @throws NullPointerException if rect is null