Chapter 18. The java.awt.image Package

AffineTransformOp	Java 1.2
java.awt.image

This class is a BufferedImageOp and a RasterOp that performs an arbitrary java.awt.geom.AffineTransform on a BufferedImage or Raster. To create an AffineTransformOp, you must specify the desired AffineTransform and the interpolation mode to use when interpolation is necessary to determine the pixel or color values of the destination. TYPE_NEAREST_NEIGHBOR is the quicker form of interpolation, but TYPE_BILINEAR produces better results. You may also specify the type of interpolation to use by specifying a java.awt.RenderingHints object that contains an interpolation hint.

To use an AffineTransformOp, simply pass a BufferedImage or Raster to the filter() method. Note that for this operation the destination image or raster cannot be the same as the source image or raster. See BufferedImageOp for further details.

Hierarchy: Object-->AffineTransformOp(BufferedImageOp,RasterOp)

AreaAveragingScaleFilter	Java 1.1
java.awt.image	cloneable PJ1.1

This class implements an ImageFilter that scales an image to a specified pixel size. It uses a scaling algorithm that averages adjacent pixel values when shrinking an image, which produces relatively smooth scaled images. Its superclass, ReplicateScaleFilter, implements a faster, less smooth scaling algorithm. The easiest way to use this filter is to call the getScaledInstance() method of java.awt.Image, specifying an appropriate hint constant.

The methods of this class are ImageConsumer methods intended for communication between the image filter and the FilteredImageSource that uses it. Applications do not usually call these methods directly.

Hierarchy: Object-->ImageFilter(Cloneable,ImageConsumer)-->ReplicateScaleFilter-->AreaAveragingScaleFilter

BandCombineOp	Java 1.2
java.awt.image

This RasterOp allows the bands of image data in a Raster to be arbitrarily combined using a matrix. For example, you can use a BandCombineOp to convert three bands of color image data to a single band of grayscale image data. The number of columns of the matrix should be equal to the number of bands in the source raster or the number of bands plus one, if you are adding constant values as part of the combination. The number of rows in the matrix should be equal to the number of bands in the destination Raster.

As an example, consider the following matrix with four columns and three rows, used to convert a Raster with three bands to another three-banded raster: This matrix is used to convert the source bands s1, s2, and s3 into destination bands d1, d2, and d3, using the following formulas:

d1 = s1*m11 + s2*m21 + s3*m31 + c1;
d2 = s1*m12 + s2*m22 + s3*m32 + c2;
d3 = s1*m13 + s2*m23 + s3*m33 + c3;

If the constants c1, c2, and c3 are all 0, they can be omitted from the vector.

After creating a BandCombineOp for a specified vector, you perform the operation by passing a source and optional destination Raster to the filter() method. Because this operation processes each pixel independently, you can specify the same Raster object as both source and destination. BandCombineOp does not implement BufferedImageOp and cannot be used to process BufferedImage objects. See RasterOp for further details.

Hierarchy: Object-->BandCombineOp(RasterOp)

BandedSampleModel	Java 1.2
java.awt.image

This SampleModel represents image data stored so that each color component is in a separate data element of a DataBuffer and each band of color components is in a separate bank of the DataBuffer. For example, it can be used to represent RGB colors stored in three separate banks of short values. Most applications never need to use this class. See SampleModel for further information.

Hierarchy: Object-->SampleModel-->ComponentSampleModel-->BandedSampleModel

BufferedImage	Java 1.2
java.awt.image

This is the central class in the simplified, immediate-mode imaging API introduced in Java 1.2 as part of Java 2D. A BufferedImage represents an image as a rectangular array of pixels in a Raster object and a ColorModel object that is capable of interpreting the pixel values of the Raster. BufferedImage extends java.awt.Image and can therefore be used anywhere that an Image can. However, a BufferedImage always holds its image data in memory, so there is no need for the complicated ImageObserver interface to handle asynchronous notifications as image data loads over a network.

If you know the data format of the image you need, you can create a BufferedImage by calling the BufferedImage() constructor. For example, to create an off-screen image with an alpha channel for use in complex color compositing operations, you can call BufferedImage() with the desired image size and an image type of TYPE_INT_ARGB. If you want to create an off-screen image and you do not need an alpha channel, it is easier to simply call the createImage() method of a java.awt.Component. Although this method is declared to return an Image, in Java 1.2 it is guaranteed to return a BufferedImage. The advantage to using this method is that it creates a BufferedImage with a type that is the same as (or can be efficiently converted to) the type used on your screen. If you do not have a Component handy, you can achieve the same effect by calling the createCompatibleImage() method of the java.awt.GraphicsConfiguration object that represents your screen configuration.

Once you have created a BufferedImage, you can call createGraphics() to obtain a Graphics2D object that you can use to draw into the image. You can draw a BufferedImage onto the screen or into any other image, using any of the drawImage() methods of Graphics or Graphics2D. You can perform image processing on a BufferedImage by passing it to the filter() method of any BufferedImageOp object. Finally, you can query and set individual pixels (or blocks of pixels) in a BufferedImage with getRGB() and setRGB(). These methods use the default ARGB color model: each pixel contains 8 bits of alpha, red, green, and blue data.

BufferedImage implements WritableRenderedImage, which in turn implements RenderedImage. These interfaces are used primarily by the forthcoming Java Advanced Imaging (JAI) API (javax.jai.*). Their methods allow an image to be divided up into multiple rectangular tiles. The BufferedImage class defines each image as a single tile, so most of these methods have trivial implementations. Most applications can simply ignore the RenderedImage and WritableRenderedImage methods of this class.

Hierarchy: Object-->Image-->BufferedImage(WritableRenderedImage(RenderedImage))

Passed To: Too many methods to list.

Returned By: Too many methods to list.

BufferedImageFilter	Java 1.2
java.awt.image	cloneable

This class allows a Java 1.2 BufferedImageOp image-processing operation to be used as an ImageFilter in the Java 1.0 and Java 1.1 image processing model. Create a BufferedImageFilter by passing a BufferedImageOp to the constructor. Then use the resulting BufferedImageFilter with a FilteredImageSource exactly as you would use RGBImageFilter, CropImageFilter, or any other Java 1.0 or Java 1.1 image filter.

Hierarchy: Object-->ImageFilter(Cloneable,ImageConsumer)-->BufferedImageFilter(Cloneable)

BufferedImageOp	Java 1.2
java.awt.image

This interface describes an image-processing operation that can be performed on any BufferedImage. Java 2D includes a number of versatile implementations of this interface that most applications can rely for all their image-processing needs.

To use a BufferedImageOp, call its filter() method. This method processes a specified source image and stores the results in a specified destination image. If no destination image is specified, the method creates and returns an appropriate one. You can pass a source image to getBounds2D() to get the bounding box of the destination image that would be produced if that source image were to be passed to filter(). Given a point in a (hypothetical) source image, getPoint2D() returns the corresponding point in the destination image. If a destination Point2D object is provided, it is used to return the destination point; otherwise a Point2D object is allocated for this purpose. getRenderingHints() returns the rendering hints associated with this implementation of BufferedImageOp, or null if it has no rendering hints. Finally, createCompatibleDestImage() is an internal method that implementations must define but that applications never need to call.

Implementations: AffineTransformOp, ColorConvertOp, ConvolveOp, LookupOp, RescaleOp

Passed To: Graphics2D.drawImage(), BufferedImageFilter.BufferedImageFilter()

Returned By: BufferedImageFilter.getBufferedImageOp()

ByteLookupTable	Java 1.2
java.awt.image

This concrete subclass of LookupTable contains one or more byte arrays that serve as lookup tables for a LookupOp image-processing operation. Applications never need to use a ByteLookupTable directly; they need to create one only to pass to the LookupOp() constructor. Create a ByteLookupTable by passing the byte array or arrays to the ByteLookupTable() constructor, along with an offset that is subtracted from each source color component before the lookup is performed. See also LookupTable.

Hierarchy: Object-->LookupTable-->ByteLookupTable

ColorConvertOp	Java 1.2
java.awt.image

This class is a BufferedImageOp and a RasterOp that converts the colors of a BufferedImage or a Raster from one color space to another color space. If the filter() method is called with two distinct source and destination BufferedImage objects specified, it converts the colors from the java.awt.color.ColorSpace of the source image to the ColorSpace of the destination image. If no destination image is passed to filter(), the destination ColorSpace must have been specified when the ColorConvertOp() constructor was called. Finally, if this ColorConvertOp is to be used to filter Raster object, both the source and destination color spaces must be specified, either in the form of ColorSpace objects or as an array of two java.awt.color.ICC_PROFILE objects.

In addition to optionally specifying the source and destination color spaces when you invoke the ColorConvertOp() constructor, you may also specify a RenderingHints object. If the hints object is non-null, the ColorConvertOp may use the color rendering and dithering hints it contains.

To use a ColorConvertOp, simply pass a source and optional destination image or raster to the filter() method. Because the ColorConvertOp works on each pixel of the image or raster independently, you may specify the same object for both source and destination. In this case, the image or raster is modified in place. See BufferedImageOp for further details.

Hierarchy: Object-->ColorConvertOp(BufferedImageOp,RasterOp)

ColorModel	Java 1.0
java.awt.image	PJ1.1

This abstract class defines a scheme for representing colors as pixels. The primary job of a ColorModel object is to extract individual color components from pixel values. Most applications do not need to work with ColorModel objects directly; those that do usually need only to instantiate an appropriate ColorModel subclass for use by some other method or constructor.

In Java 1.0 and 1.1, this is a fairly simple class: pixel values are supplied as int values, and the getRed(), getGreen(), getBlue(), and getAlpha() methods return the red, green, blue, and alpha components of the pixel. The getRGB() method converts a pixel to the pixel format used by the default ARGB color model. This color model is returned by the static getRGBDefault() method; it packs 8-bit color and alpha components into a 32-bit int in 0xAARRGGBB format.

With the introduction of Java 2D in Java 1.2, this class has become more complicated. Now the ColorModel is not tied to the default RGB java.awt.color.ColorSpace and provides methods for extracting color components from any color space. The getComponents() method and its variants return an array of color components for a given pixel value. If the ColorModel is defined in terms of the CMYK color space, for example, these components are not red, green, and blue, but cyan, magenta, yellow, and black. Note, however, that because every ColorSpace can convert colors to the default RGB color space, the getRed(), getGreen(), getBlue(), and getRGB() methods still work, regardless of color space.

Another generalization to the ColorModel class in Java 1.2 is that pixel values are no longer assumed to fit in int values. Each method that extracts color components from pixels comes in two forms. In the first, the pixel value is specified as an int. In the second form, it is specified as a Object. This object is an array of primitive values. The type of these values is known as the transfer type of the color model and is specified by one of the constants DataBuffer.TYPE_BYTE, Databuffer.TYPE_USHORT, or DataBuffer.TYPE_INT. In simple cases, the elements of the transfer type arrays contain color components, and the ColorModel object provides a trivial mapping between pixel values and color component values.

Other ColorModel additions in Java 1.2 include the implementation of the Transparency interface and its getTransparency() method. This method returns a Transparency constant that specifies the level of transparency supported by the ColorModel. For ColorModel objects that support transparency, the isAlphaPremultiplied() method specifies whether the color components have been premultiplied by the alpha component. (Premultiplication makes alpha compositing operations more efficient.) Also, the getNormalizedComponents() and getUnnormalizedComponents() convert back and forth between normalized and unnormalized color component values. A normalized component is a float value between 0.0 and 1.0 that has not been premultiplied by an alpha value. An unnormalized component is an integral value with a range that depends on the number of bits used by the color model, possibly premultiplied by the alpha value.

There are a number of ColorModel subclasses, suitable for distinctly different types of color models. See also ComponentColorModel, DirectColorModel, IndexColorModel, and PackedColorModel.

Hierarchy: Object-->ColorModel(Transparency)

Subclasses: ComponentColorModel, IndexColorModel, PackedColorModel

Passed To: Too many methods to list.

Returned By: Component.getColorModel(), GraphicsConfiguration.getColorModel(), PaintContext.getColorModel(), Toolkit.getColorModel(), BufferedImage.getColorModel(), ColorModel.{coerceData(), getRGBdefault()}, ComponentColorModel.coerceData(), DirectColorModel.coerceData(), PixelGrabber.getColorModel(), RenderedImage.getColorModel(), java.awt.peer.ComponentPeer.getColorModel()

Type Of: RGBImageFilter.{newmodel, origmodel}

ComponentColorModel	Java 1.2
java.awt.image

This ColorModel is used with image data in which the color and transparency components of pixels are stored separately, instead of being combined together into a single int value. This class works only with pixel values specified as an array of primitive values of the specified transfer type. The number of elements in these pixel arrays must match the number of color and transparency components in the specified color space. This class performs the trivial mapping between the array elements of the pixel value and the color components of the color it represents. The methods of this class that are passed int pixel values can throw IllegalArgumentException. Only applications that are doing custom image processing need to use this, or any, ColorModel.

Hierarchy: Object-->ColorModel(Transparency)-->ComponentColorModel

ComponentSampleModel	Java 1.2
java.awt.image

This SampleModel represents image data stored so that each component of each pixel is stored in a separate element of the DataBuffer. The arguments to the ComponentSampleModel allow great flexibility in this model. For example, it can represent RGB values interleaved into a single bank of bytes or ARGB values stored in four separate banks of bytes. Additionally, it can handle offsets at the end of scanlines and an offset at the beginning of each bank.

Java 2D defines two subclasses of ComponentSampleModel that are more efficient for particular types of image data. When each band of pixel components is stored in a separate bank of the DataBuffer, it is easier and more efficient to use the BandedSampleModel subclass. When the components of a pixel are stored in adjacent data elements of a single bank of the DataBuffer, it is easier and more efficient to use PixelInterleavedSampleModel.

Most applications never need to use this class or its subclasses. See SampleModel for further information.

Hierarchy: Object-->SampleModel-->ComponentSampleModel

Subclasses: BandedSampleModel, PixelInterleavedSampleModel

ConvolveOp	Java 1.2
java.awt.image

This class is a BufferedImageOp and a RasterOp that performs an arbitrary convolution on an image. Convolution is a versatile image-processing operation that can be used, for example, to blur or sharpen an image or perform edge detection on an image. The convolution to be performed is specified by a matrix of floating-point numbers, in the form of a Kernel object. Because convolution looks at the neighbors of each pixel in an image, special care must be taken when operating on the pixels at the edges of the image. By default, a ConvolveOp uses imaginary color components of all zeros when it reaches the edges of an image. You can pass EDGE_NO_OP to the constructor to specify that the edges of the image should simply be left unprocessed. Finally, you can pass a RenderingHints object to the ConvolveOp() constructor. If this argument is not null, the ConvolveOp may use its color and dithering hints.

To use a ConvolveOp, simply pass a source and optional destination image or raster to its filter() method. Note that you cannot specify the same object as both source and destination. See BufferedImageOp for further details.

Hierarchy: Object-->ConvolveOp(BufferedImageOp,RasterOp)

CropImageFilter	Java 1.0
java.awt.image	cloneable PJ1.1

This class implements an ImageFilter that crops an image to a specified rectangle. The methods defined by this class are used for communication between the filter and its FilteredImageSource and should never be called directly.

Hierarchy: Object-->ImageFilter(Cloneable,ImageConsumer)-->CropImageFilter

DataBuffer	Java 1.2
java.awt.image

This abstract class stores image data at the lowest level. A DataBuffer stores one or more arrays, or banks, of data of a specified size and a given type. The Raster class uses a DataBuffer to store image data and a SampleModel to interpret the storage format of that data. Most applications never need to use DataBuffer objects directly.

Specific concrete subclasses of DataBuffer are implemented for specific types of data. See also DataBufferByte, DataBufferShort, DataBufferUShort, and DataBufferInt.

Subclasses: DataBufferByte, DataBufferInt, DataBufferShort, DataBufferUShort

Passed To: Too many methods to list.

Returned By: BandedSampleModel.createDataBuffer(), ComponentSampleModel.createDataBuffer(), MultiPixelPackedSampleModel.createDataBuffer(), Raster.getDataBuffer(), SampleModel.createDataBuffer(), SinglePixelPackedSampleModel.createDataBuffer()

Type Of: Raster.dataBuffer

DataBufferByte	Java 1.2
java.awt.image

This class stores image data in one or more byte arrays. The arrays, or banks, of data can be passed directly to the DataBufferByte() constructor, or they can be created by the constructor. You may specify an offset into each array at which the data begins. getElem() and setElem() allow you to get and set the values of a particular element of a particular bank. Most applications never use this class directly.

Hierarchy: Object-->DataBuffer-->DataBufferByte

DataBufferInt	Java 1.2
java.awt.image

This class stores image data in one or more int arrays. The arrays, or banks, of data can be passed directly to the DataBufferInt() constructor, or they can be created by the constructor. You may specify an offset into each array at which the data begins. getElem() and setElem() allow you to get and set the values of a particular element of a particular bank. Most applications never use this class directly.

Hierarchy: Object-->DataBuffer-->DataBufferInt

DataBufferShort	Java 1.2
java.awt.image

This class stores image data in one or more short arrays. The arrays, or banks, of data can be passed directly to the DataBufferShort() constructor, or they can be created by the constructor. You may specify an offset into each array at which the data begins. getElem() and setElem() allow you to get and set the values of a particular element of a particular bank. Most applications never use this class directly.

Hierarchy: Object-->DataBuffer-->DataBufferShort

DataBufferUShort	Java 1.2
java.awt.image

This class stores unsigned image data in one or more short arrays. The arrays, or banks, of data can be passed directly to the DataBufferUShort() constructor, or they can be created by the constructor. You may specify an offset into each array at which the data begins. getElem() and setElem() allow you to get and set the values of a particular element of a particular bank. Most applications never use this class directly.

Hierarchy: Object-->DataBuffer-->DataBufferUShort

DirectColorModel	Java 1.0
java.awt.image	PJ1.1

This ColorModel works only with RGB color spaces. It extracts red, green, blue, and, optionally, alpha values directly from the bits of the pixel, using bitmasks to specify which bits correspond to which color components. The default RGB color model is a DirectColorModel. Only applications that are doing custom image processing need to use this, or any, ColorModel.

Prior to Java 1.2, this class extended ColorModel directly. In Java 1.2, it extends PackedColorModel, which itself extends ColorModel. The Java 1.2 methods of this class that accept pixel values as an array of a primitive transfer type expect that array argument to have a length of 1.

Hierarchy: Object-->ColorModel(Transparency)-->PackedColorModel-->DirectColorModel

FilteredImageSource	Java 1.0
java.awt.image	PJ1.1

This class is an ImageProducer that produces image data filtered from some other ImageProducer. A FilteredImageSource is created with a specified ImageProducer and a specified ImageFilter. For example, an applet might use the following code to download and crop an image:

Image full_image = getImage(getDocumentBase(), "images/1.gif");
ImageFilter cropper = new CropImageFilter(10, 10, 100, 100);
ImageProducer prod = new FilteredImageSource(full_image.getSource(), cropper);
Image cropped_image = createImage(prod);

The methods of this class are the standard ImageProducer methods that you can invoke to add and remove ImageConsumer objects.

Hierarchy: Object-->FilteredImageSource(ImageProducer)

ImageConsumer	Java 1.0
java.awt.image	PJ1.1

This interface defines the methods necessary for a class that consumes image data to communicate with a class that produces image data. The methods defined by this interface should never be called by a program directly; instead, they are invoked by an ImageProducer to pass the image data and other information about the image to the ImageConsumer. The constants defined by this interface are values passed to the setHints() and imageComplete() methods. Unless you want to do low-level manipulation of image data, you never need to use or implement an ImageConsumer.

Implementations: ImageFilter, PixelGrabber

Passed To: Too many methods to list.

Type Of: ImageFilter.consumer

ImageFilter	Java 1.0
java.awt.image	cloneable PJ1.1

This class is used in conjunction with a FilteredImageSource. It accepts image data through the ImageConsumer interface and passes it on to an ImageConsumer specified by the controlling FilteredImageSource. ImageFilter is the superclass of all image filters; it performs no filtering itself. You must subclass it to perform the desired filtering. See also CropImageFilter and RGBImageFilter. The ImageFilter methods are the ImageConsumer methods invoked by an ImageProducer. You should not call them directly. See FilteredImageSource for an example of using an ImageFilter.

Hierarchy: Object-->ImageFilter(Cloneable,ImageConsumer)

Subclasses: BufferedImageFilter, CropImageFilter, ReplicateScaleFilter, RGBImageFilter

Passed To: FilteredImageSource.FilteredImageSource()

Returned By: ImageFilter.getFilterInstance()

ImageObserver	Java 1.0
java.awt.image	PJ1.1

This interface defines a method and associated constants used by classes that want to receive information asynchronously about the status of an image. Many methods that query information about an image take an ImageObserver as an argument. If the specified information is not available when requested, it is passed to the ImageObserver when it becomes available. Component implements this interface, and components are the most commonly used image observers.

Implementations: Component

Passed To: Too many methods to list.

Returned By: javax.swing.ImageIcon.getImageObserver()

ImageProducer	Java 1.0
java.awt.image	PJ1.1

This interface defines the methods that any class that produces image data must define to enable communication with ImageConsumer classes. An ImageConsumer registers itself as interested in a producer's image by calling the addConsumer() method. Most applications never need to use or implement this interface.

Implementations: FilteredImageSource, MemoryImageSource, java.awt.image.renderable.RenderableImageProducer

Passed To: Component.createImage(), Toolkit.createImage(), FilteredImageSource.FilteredImageSource(), ImageFilter.resendTopDownLeftRight(), PixelGrabber.PixelGrabber(), java.awt.peer.ComponentPeer.createImage()

Returned By: Image.getSource(), BufferedImage.getSource()

ImagingOpException	Java 1.2
java.awt.image	serializable unchecked

Thrown by the filter() methods of BufferedImageOp and RasterOp if, for any reason, they are unable to filter the specified image.

Hierarchy: Object-->Throwable(Serializable)-->Exception-->RuntimeException-->ImagingOpException

IndexColorModel	Java 1.0
java.awt.image	PJ1.1

This ColorModel is used with RGB color spaces and determines the red, green, blue, and, optionally, alpha components of a pixel by using the pixel value as an index into colormap arrays. If no array of alpha values is specified, all pixels are fully opaque, except for one optionally specified reserved value that is fully transparent. This color model is useful when working with image data that is defined in terms of a colormap. Only applications that are doing custom image processing need to use this, or any, ColorModel.

Hierarchy: Object-->ColorModel(Transparency)-->IndexColorModel

Passed To: BufferedImage.BufferedImage(), RGBImageFilter.filterIndexColorModel()

Returned By: RGBImageFilter.filterIndexColorModel()

Kernel	Java 1.2
java.awt.image	cloneable

This class represents a matrix of float values, for use with the ConvolveOp image-processing operation. Convolution is performed by combining a pixel value with the values of the pixels that surround it. The convolution kernel specifies the relative contribution of each pixel to the end result. For example, to blur an image, you can use a kernel like this: This matrix specifies that the destination pixel is composed of one-ninth (0.111) of the source pixel plus one-ninth of each of the eight pixels that surround it.

To create a Kernel, pass the width and height of the kernel to the constructor, along with the array of float values that comprise the kernel. The array should be organized by rows. Note that a Kernel need not have a square array. Kernels typically have an odd number of rows and columns and are placed symmetrically about the source pixel being processed. However, if the number of rows or columns is even, the origin of the Kernel is such that the extra row or column is to the bottom or the right of the pixel being processed.

Hierarchy: Object-->Kernel(Cloneable)

Passed To: ConvolveOp.ConvolveOp()

Returned By: ConvolveOp.getKernel()

LookupOp	Java 1.2
java.awt.image

This class is a BufferedImageOp and RasterOp that processes an image by one or more lookup tables to convert the value of each component of each pixel to a new value. LookupOp is useful for operations such as brightening or darkening an image, reducing the number of colors in an image, or thresholding an image. When you create a LookupOp object, you specify the lookup table or tables with a LookupTable object, typically a ByteLookupTable or ShortLookupTable. If the LookupTable contains one table, that table is used for all color bands of the image (but not alpha bands). Otherwise, the LookupTable should contain one table for each color band or one table for each of the color and transparency bands. If you specify a RenderingHints object when you create a LookupOp, the operation may use the color rendering and dithering hints it contains.

To use a LookupOp, simply pass a source and optional destination image or raster to the filter() method. Because LookupOp processes pixels independently of each other, you can use the same objects as both source and destination. Because of the nature of lookup tables, however, you cannot use LookupOp with images that use an IndexColorModel. If the lookup tables used by a LookupOp describe a simple linear function, you can also use a RescaleOp to achieve the same effect. See BufferedImageOp for further details.

Hierarchy: Object-->LookupOp(BufferedImageOp,RasterOp)

LookupTable	Java 1.2
java.awt.image

This abstract class defines one or more lookup tables used by the LookupOp image-processing operation. lookupPixel() performs the table-lookup operation. This method is passed an array of color component source values. It transforms this array into a new array of destination values by replacing each source value with the value found in the appropriate lookup table at the index that corresponds to the source value. Note, however, that an offset may be specified for the lookup tables. If so, the offset is subtracted from the source values before the lookup is performed. See the concrete subclasses ByteLookupTable and ShortLookupTable.

Subclasses: ByteLookupTable, ShortLookupTable

Passed To: LookupOp.LookupOp()

Returned By: LookupOp.getTable()

MemoryImageSource	Java 1.0
java.awt.image	PJ1.1

This class is an ImageProducer that produces an image from data stored in memory. The various constructors specify image data, color model, array offset, scanline length, and properties in slightly different ways. The instance methods implement the standard ImageProducer interface that allows an ImageConsumer object to register interest in the image.

Hierarchy: Object-->MemoryImageSource(ImageProducer)

MultiPixelPackedSampleModel	Java 1.2
java.awt.image

This SampleModel knows how to interpret single-banded image data in a DataBuffer that is organized so that more than one pixel is packed into a single element of the data buffer. For example, a MultiPixelPackedSampleModel can be used to represent a monochrome image in which eight pixels are packed in a byte or 8-bit indexed color data in which four pixels are packed into an int. Most applications never need to use this class. See also SampleModel for further information.

Hierarchy: Object-->SampleModel-->MultiPixelPackedSampleModel

PackedColorModel	Java 1.2
java.awt.image

This abstract ColorModel is used with image data in which color component and transparency values are packed into contiguous bits of a byte, short, or int. It uses bitmasks and bit-shifting operations to extract the color and transparency components from the pixel value. DirectColorModel is a concrete subclass that works with RGB color spaces. Only applications that are doing custom image processing need to use this, or any, ColorModel.

Hierarchy: Object-->ColorModel(Transparency)-->PackedColorModel

Subclasses: DirectColorModel

PixelGrabber	Java 1.0
java.awt.image	PJ1.1

This class is an ImageConsumer that extracts a specified rectangular array of pixels (in the default RGB color model) from a specified Image or ImageProducer and stores them in a specified array (using the specified offset into the array and specified scanline size). Use this class when you want to inspect or manipulate the data of an image or some rectangular portion of an image.

The method grabPixels() makes the PixelGrabber start grabbing pixels. status() returns the status of the pixel-grabbing process. The return value uses the same flag value constants that the ImageObserver class does. The remaining methods are the standard ImageConsumer methods and should not be called directly.

Hierarchy: Object-->PixelGrabber(ImageConsumer)

PixelInterleavedSampleModel	Java 1.2
java.awt.image

This SampleModel represents image data stored so that each component of each pixel is stored in a separate element of the DataBuffer and all pixel components are stored in the same bank of the DataBuffer. For example, it can be used to represent RGB pixels in which the red, green, and blue components are interleaved into a single bank of byte values. Most applications never need to use this class or its subclasses. See SampleModel for further information.

Hierarchy: Object-->SampleModel-->ComponentSampleModel-->PixelInterleavedSampleModel

Raster	Java 1.2
java.awt.image

This class represents a rectangular array of pixels. A Raster is composed of a DataBuffer that contains raw pixel data and a matching SampleModel that knows how to extract pixel data from that DataBuffer. A Raster object is used within a BufferedImage object, which also contains a ColorModel object to interpret the pixel values of the Raster as colors. Most applications can simply used BufferedImage objects and never have to work with Raster objects directly.

Raster does not have any public constructors. You can call the static method createRaster() or createWritableRaster() to create a Raster using arbitrary DataBuffer and SampleModel objects. However, you usually obtain more efficient results if you use createBandedRaster(), createInterleavedRaster(), or createPackedRaster() to create a Raster using one of the data formats supported by the built-in DataBuffer and SampleModel subclasses.

Raster contains a number of methods to read individual pixels and blocks of pixels. Note, however, that there are no methods to set pixel values. If you want to modify pixels in a Raster, you must use the WritableRaster subclass. A Raster can have a parent Raster that contains the actual data. The createChild() method uses this feature to return a Raster object that represents a rectangular subset of the current raster. (It can also return a child Raster that contains only a subset of the bands of the parent raster: for example, a Raster that contains only the alpha band of transparency values of its parent.) Finally, while BufferedImage objects have only a width and height, Raster objects have a size and location. Thus, you can specify an origin when you create a Raster.

Subclasses: WritableRaster

Passed To: Too many methods to list.

Returned By: PaintContext.getRaster(), BufferedImage.{getData(), getTile()}, Raster.{createChild(), createRaster(), createTranslatedChild(), getParent()}, RenderedImage.{getData(), getTile()}

Type Of: Raster.parent

RasterFormatException	Java 1.2
java.awt.image	serializable unchecked

Signals that a Raster is improperly configured.

Hierarchy: Object-->Throwable(Serializable)-->Exception-->RuntimeException-->RasterFormatException

RasterOp	Java 1.2
java.awt.image

This interface defines an image-processing operation that can be performed on a Raster. It is very similar to the BufferedImageOp, except that the operation is performed directly on the uninterpreted pixels of Raster data, rather than on the color values of a BufferedImage. Many of the implementations of BufferedImageOp are also implementations of RasterOp. See BufferedImageOp for details.

Implementations: AffineTransformOp, BandCombineOp, ColorConvertOp, ConvolveOp, LookupOp, RescaleOp

RenderedImage	Java 1.2
java.awt.image

This interface describes the methods of rendered images. RenderedImage exists primarily for use by the forthcoming Java Advanced Imaging API (javax.jai.*), but it is also implemented (through WritableRenderedImage) by BufferedImage, meaning that BufferedImage images will be able to interoperate with JAI-rendered images.

The getSources() method and the tile-related methods of RenderedImage are used in the JAI, and are not of interest in Java 2D. BufferedImage objects contain only a single tile, so the BufferedImage class defines implementations of these methods. Methods that are of interest include getData(), getSampleModel(), and getColorModel(). These methods return a copy of the Raster that contains pixels, the SampleModel that specifies the internal organization of the Raster, and the ColorModel that specifies how to interpret the pixels as colors, respectively. getWidth(), getHeight(), and copyData() are also useful in Java 2D programs.

Implementations: WritableRenderedImage

Passed To: Graphics2D.drawRenderedImage()

Returned By: java.awt.image.renderable.ContextualRenderedImageFactory.create(), java.awt.image.renderable.ParameterBlock.getRenderedSource(), java.awt.image.renderable.RenderableImage.{createDefaultRendering(), createRendering(), createScaledRendering()}, java.awt.image.renderable.RenderableImageOp.{createDefaultRendering(), createRendering(), createScaledRendering()}, java.awt.image.renderable.RenderedImageFactory.create()