by Debasis Samanta
The java.awt.image Package contains classes and interfaces for performing sophisticated image processing. The classes in this package provides for managaing image data, color models, cropping, color filtering, setting pixel values, and grabbing snapshots. The various component in this package is listed below :
Classes Class ColorModel Class CropImageFilter Class DirectColorModel Class FilteredImageSource Class ImageFilter Class IndexColorModel Class MemoryImageSource Class PixelGrabber Class RGBImageFilter Interfaces Interface ImageConsumer Interface ImageObserver Interface ImageProducer
This abstract class is the superclass for all classes that encapsulate methods for translating from pixel values to their alpha (transparency), red, green, and blue components. The java.awt.image classes IndexColorModel and DirectColorModel are subclasses of this class.
public abstract class java.awt.image.ColorModel extends java.lang.Object
{
// Member elements
protected int pixel_bits;
// The number of bits per pixel.
// Constructors
public ColorModel(int bits);
// Constructs a ColorModel which describes a pixel with the specified number of bits.
// Methods
public abstract int getAlpha(int pixel);
public abstract int getBlue(int pixel);
public abstract int getGreen(int pixel);
public int getPixelSize();
public abstract int getRed(int pixel);
public int getRGB(int pixel);
public static ColorModel getRGBdefault();
}
Table 5.1
Table 5.1 (contd.)
The cropped image filter is an image filter for cropping images. This class extends the basic ImageFilter class to extract a given rectangular region of an existing image and provides a source for new image containing only the extracted region.
This class is meant to be used in conjunction with a FilteredImageSource to produce cropped versions of existing images.
public class java.awt.image.CropImageFilter extends java.awt.image.ImageFilter
{
// Constructors
public CropImageFilter(int x, int y, int w, int h);
/* Constructs a cropped image filter that extracts the absolute rectangular region of pixels from its source Image as specified by the x, y, w, and h parameters.
*/
// Methods
public void setDimensions(int w, int h);
public void setPixels(int x, int y, int w, int h, ColorModel model,byte pixels[], int off, int scansize);
public void setProperties(Hashtable props);
}
Methods are stated in Table 5.2.
The DirectColorModel is a color model which specifies a translation from pixel values to alpha, red, green, and blue components using the actual bits of the pixel value.
Many of the methods in this class are final : 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. Applications can subclass this class for other reaons, but they cannot override or modify the behavior of the final methods.
public class java.awt.image.DirectColorModel extends java.awt.image.ColorModel
{
// Constructors
public DirectColorModel(int bits, int rmask, int gmask, int bmask);
/* Constructs a direct color model in which each of the given masks specify which bits in the pixels contain the red, green, and blue components.
Pixels described by this color model all have alpha components of 255, indicating that they are fully opaque.
*/
public DirectColorModel(int bits, int rmask, int gmask, int bmask,int amask);
/* Constructs a direct color model in which each of the given masks specify which bits in the pixels contain the alpha, red, green, and blue components. */
// Methods
public final int getAlpha(int pixel);
public final int getAlphaMask();
public final int getBlue(int pixel);
public final int getBlueMask();
public final int getGreen(int pixel);
public final int getGreenMask();
public final int getRed(int pixel);
public final int getRedMask();
public final int getRGB(int pixel);
}
Methods are stated in Table 5.3.
A FilteredImagedSource is an implementation of the image producer interface which takes an existing image and an image filter and uses them to produce a new filtered version of the original image.
public class java.awt.image.FilteredImageSource extends java.lang.Object
implements java.awt.image.ImageProducer
{
// Constructors
public FilteredImageSource(ImageProducer orig, ImageFilter imgf);
// Constructs a new image producer from an existing image producer and an an image filter.
// Methods
public void addConsumer(ImageConsumer ic);
public boolean isConsumer(ImageConsumer ic);
public void removeConsumer(ImageConsumer ic);
public void requestTopDownLeftRightResend(ImageConsumer ic);
public void startProduction(ImageConsumer ic);
}
Methods are stated in Table 5.4
This class is the superclass of all classes that are meant to filter the data delivered from an ImageProducer to an ImageConsumer. This class and its subclasses are meant to be used in conjunction with a FilteredImageSource object to produce filtered versions of existing images.
The image filter implemented by this class is the "null filter" which has no effect on the data passing through. Filters should subclass this class and override the methods in order to modify the data as necessary.
public class java.awt.image.ImageFilter extends java.lang.Object
implements java.awt.image.ImageConsumer
java.lang.Cloneable
{
// Member elements
protected ImageConsumer consumer;
/* The image consumer of the particular image data stream for which this image filter is filtering data. The field is not initialized by the constructor, but by the call to the getFilterInstance method. when the FilteredImageSource is creating a unique instance of this object for a particular image data stream.
*/
// Constructors
public ImageFilter();
// The default constructor for this method.
// Methods
public Object clone();
public ImageFilter getFilterInstance(ImageConsumer ic)
public void imageComplete(int status);
public void resendTopDownLeftRight(ImageProducer ip);
public void setColorModel(ColorModel model);
public void setDimensions(int width, int height);
public void setHints(int hints);
public void setPixels(int x, int y, int w, int h, ColorModel model,byte pixels[], int off, int scansize);
public void setPixels(int x, int y, int w, int h, ColorModel model,int pixels[], int off, int scansize);
public void setProperties(Hashtable props);
}
Methods are described in Table 5.5.
The index color model class specifies a color model in a which a pixel value is converted into alpha, red, green, and blue component by using the pixel value as an index into a color map. Each entry in the color map gives the alpha, red, green, and blue component for the corresponding pixel. An optional transparent pixel can be specified. This pixel is completely transparent, independent of the alpha value recorded for that pixel value. The maximum size of the color map is 256 entries. This color model is similar to an X11 PseudoColor visual..
Many of the methods in this class are final: 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. Applications can subclass this class for other reaons, but they cannot override or modify the behavior of the final methods.
public class java.awt.image.IndexColorModel extends java.awt.image.ColorModel
{
// Constructors
public IndexColorModel(int bits, int size, byte r[], byte g[],byte b[]);
/* Constructs an IndexColorModel from the given arrays of red, green, and blue components.
Pixels described by this color model all have alpha components of 255 (fully opaque).
Each of the three arrays must have at least size elements, and it must be the case that size < 2bits . These first size elements of the arrays are the red, green, and blue values for pixels in the range 0 <= i < size . Pixels in the range size <= i <= 2bits have red, green, and blue values of 0.
*/
public IndexColorModel(int bits, int size, byte r[], byte g[],byte b[], byte a[]);
// Constructs an IndexColorModel from the given arrays of red, green, blue and alpha components.
public IndexColorModel(int bits, int size, byte r[], byte g[],byte b[], int trans);
/* Constructs an IndexColorModel from the given arrays of red, green, and blue components. Pixels described by this color model all have alpha components of 255 (fully opaque), except for the transparent pixel.
*/
public IndexColorModel(int bits, int size, byte cmap[],int start,boolean hasalpha);
/* Constructs an index color model from a single array of packed red, green, blue and optional alpha components. If the hasalpha argument is false, then the cmap array must have length of at least start + 3 x size. The red, green, and blue components for a pixel i in the range 0 <= i < size are in the three elements of the cmap array starting at cmap[start + 3i] Its alpha component is 255 (fully opaque). If the hasalpha argument is true, then the cmap array must have length of at least start + 4 x size. The red, green, blue, and alpha components for a pixel i in the range 0 <= i < size are in the four elements of the cmap array starting at cmap[start + 4i]. Pixels in the range size <=i < 2bits have red, green, and blue values of 0, Their alpha component is 0 if hasalpha is true, and 255 otherwise.
*/
public IndexColorModel(int bits, int size, byte cmap[], int start,boolean hasalpha, int trans);
/* Constructs an index color model from a single array of packed red, green, blue, and optional alpha values.
The color model is constructed the same way as described in . In addition, the specified transparent index represents a pixel which 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.
*/
// Methods
public final int getAlpha(int pixel);
public final void getAlphas(byte a[]);
public final int getBlue(int pixel);
public final void getBlues(byte b[]);
public final int getGreen(int pixel);
public final void getGreens(byte g[]);
public final int getMapSize();
public final int getRed(int pixel);
public final void getReds(byte r[]);
public final int getRGB(int pixel);
public final int getTransparentPixel();
}
Methods are described in Table 5.6.
A memory image source is an implementation of the image producer interface. It uses an array to produce pixel values for the image. An application can use the method createImage in class Component to create an Image from a MemoryImageSource.
public class java.awt.image.MemoryImageSource extends java.lang.Object
implements java.awt.image.ImageProducer
{
// Constructors
public MemoryImageSource(int w, int h, ColorModel cm, byte pix[],int off, int scan);
/* Constructs an image producer object which uses an array of bytes to produce data for the image object. The pixel at coordinate (i, j) is stored in the pixel array at index (j x scan +i + offset).
*/
public MemoryImageSource(int w, int h, ColorModel cm, byte pix[],int off, int scan, Hashtable props);
/* Constructs an image producer object which uses an array of bytes to produce data for the image object. The pixel at coordinate (i, j) is stored in the pixel array at index (j x scan +i + offset).In addition, the image has the properties indicated in the hash table argument.
*/
public MemoryImageSource(int w, int h, ColorModel cm, int pix[], /* Constructs an image producer object which uses an array of integers to produce data for the image object. The pixel at coordinate (i, j) is stored in the pixel array at index (j x scan +i + offset).
*/
public MemoryImageSource(int w, int h, ColorModel cm, int pix[],int off, int scan, Hashtable props);
/* Constructs an image producer object which uses an array of integers to produce data for the image object. The pixel at coordinate (i, j) is stored in the pixel array at index (j x scan +i + offset).In addition, the image has the properties indicated in the hash table argument.
*/
public MemoryImageSource(int w, int h, int pix[], int off, int scan);
/* Constructs an image producer object which uses an array of integers to produce data for the image object. The pixel at coordinate ( i, j) is stored in the pixel array at index (j x scan +i + offset).The resulting image uses the default RGB color model.
*/
public MemoryImageSource(int w, int h, int pix[],int off,int scan, Hashtable props);
/* Constructs an image producer object which uses an array of integers to produce data for the image object. The pixel at coordinate (i, j) is stored in the pixel array at index (j x scan +i + offset). The resulting image uses the default RGB color model.In addition, the image has the properties indicated in the hash table argument.
*/
/* Note : The parameters in the above constructors :
w- the width of the image
h - the height of the image
cm - the color model used the pixels
pix - the array of pixel values
off - the offset of the first pixel in the array
scan - the number of pixels in the array per line
props - a hash table of properties
*/
// Methods
public void addConsumer(ImageConsumer ic);
public boolean isConsumer(ImageConsumer ic);
ublic void removeConsumer(ImageConsumer ic);
public void requestTopDownLeftRightResend(ImageConsumer ic);
public void ctstartProduion(ImageConsumer ic);
}
The methods are stated in Table 5.7.
The pixel grabber implements an image consumer which can be attached to an image or image producer object to retrieve a subset of the pixels in that image. Pixels are stored in the array in the default RGB color model. Most applications need to call only the grabPixel methods and the status method of this class. The remaining methods are part of the ImageConsumer interface and allow the pixel grabber to receive the image from the image producer.
public class java.awt.image.PixelGrabber extends java.lang.Object
implements java.awt.image.ImageConsumer
{
// Constructors
public PixelGrabber(Image img, int x, int y, int w, int h, int pix[],int off, int scansize);
/* Creates a new pixel grabber object to grab the rectangular section of pixels from the specified image into the specified array. The pixels are stored in the array in the default RGB color model. The pixel data for the coordinate (i, j), where (i, j) is inside the indicted rectangle, is stored in the array at index
(j - scan) + (i-x) + offset of the pixel array. The x and y coordinates indicate the upper left corner of the rectangle of pixels to retrieve from the image, relative to the default (unscaled) size of the image.
*/
public PixelGrabber(ImageProducer ip, int x, int y, int w, int h, int pix[], int off, int scansize);
/* Creates a new pixel grabber object to grab the rectangular section of pixels from the specified image producer into the specified array. The pixels are stored in the array in the default RGB color model. The pixel data for the coordinate (i,j), where (i, j) is inside the indicted rectangle, is stored in the array at the index
(j - scan) + (i-x) + offset of the pixel array. The x and y coordinates indicate the upper left corner of the rectangle of pixels to retrieve from the image, relative to the default (unscaled) size of the image.
/* Note : The various parameters used in these constructors are :
img - the image from which to retrieve pixels
x - the x coordinate of the upper left corner
y - the y coordinate of the upper left corner
w - the width of the rectangle to retrieve
h - the height of the rectangle to retrieve
pix - the array of integers into which to place the RGB pixels retrieved from the image
scansize - the distance from the start of one row of pixels to the start of the next row in the array.
*/
// Methods
public boolean grabPixels();
public boolean grabPixels(long ms);
public void imageComplete(int status);
public void setColorModel(ColorModel model);
public void setDimensions(int width, int height)
public void setHints(int hints);
public void setPixels(int srcX, int srcY, int srcW, int srcH,
ColorModel model, byte pixels[], int srcOff, int srcScan);
public void setPixels(int srcX, int srcY, int srcW, int srcH,ColorModel model, int pixels[], int srcOff, int srcScan);
public void setProperties(Hashtable props);
public int status();
}
Methods are described in Table 5.8.
This class provides an easy way to create an image filter which modifies the pixels of the original image by converting them one at a time in the default RGB color model. Objects of this class are meant to be used in conjunction with a filtered image source object to produce filtered versions of existing images.
This class is an abstract class. It provides the calls needed to channel all the pixel data through a single method which converts pixels, one at a time, into the default RGB color model, regardless of the color model being used by the image producer. The only method which needs to be defined to create a useable image filter is the filterRGB method.
public abstract class java.awt.image.RGBImageFilter extends java.awt.image.ImageFilter
{
// Member elements
protected boolean canFilterIndexColorModel;
/* Setting this value to true indicates that the the value returned by the filterRGB method is independent of the x and y arguments, and depends only on the rgb argument. Subclasses of RGBImageFilter should set this field to true in their constructor if their filterRGB method does not depend on the coordinate of the pixel being filtered. Filtering the colormap entries of an indexed color map can be much faster than filtering every pixel. The default value is false.
*/
protected ColorModel newmodel;
// This field is used to remember the newcm argument passed to the substituteColorModel method.
protected ColorModel origmodel;
// This field is used to remember the oldcm argument passed to the substituteColorModel method.
// Constructors
public RGBImageFilter();
// The default constructor.
// Methods
public IndexColorModel filterIndexColorModel(IndexColorModel icm);
public abstract int filterRGB(int x, int y, int rgb);
public void filterRGBPixels(int x, int y, int w, int h, int pixels[],int off, int scansize);
public void setColorModel(ColorModel model);
public void setPixels(int x, int y, int w, int h, ColorModel model,byte pixels[], ;int off, int scansize);
public void setPixels(int x, int y, int w, int h ColorModel model,int pixels[], int off, int scansize);
public void substituteColorModel(ColorModel oldcm, ColorModel newcm);
}
Methods in this class is described as in Table 5.9.
Table 5.9.
|
Methods |
Description |
|
filterIndexColorModel(IndexColorModel icm) |
Filters an index color model object by running each entry in its color table through the filterRGB method . The call to filterRGB has the x and y arguments set to -1 as a flag to indicate that a color table entry is being filtered rather than an actual pixel value. |
|
filterRGB(int x, int y,int rgb) |
Specifies a method to convert a single input pixel, whose value is specified in the default RGB color model, to a new pixel value also in the default RGB color model. Subclasses of RGBImageFilter must provide a definition for this method. If the value of the field canFilterIndexColorModel is true, then the value returned by this method must not depend on the x and y coordinates. If the x and y arguments are both -1, this method is being called by the filterIndexColorModel method. Returns : the new value of the pixel, in the default RGB color model. |
|
filterRGBPixels( ...) |
Filters a buffer of pixels in the default RGB color model by passing them one by one through the filterRGB method. The setPixels method of the filter's consumer is then called with the resulting buffer and the color model argument set to the default RGB color model. Only pixels that fall within the specified rectangle are modified. The value of the pixel at coordinate (i, j) stored in the pixel array at index ( j x scan + I + offset). |
|
setColorModel(ColorModel model) |
The
image producer calls the setColorModel
method to specify the color model for the majority of the
subsequent setPixels method calls.
The setColorModel method of
RGBImageFilter determines if the color model argument is an index
color model
and
if the canFilterIndexColorModel
field
is true.
If both
conditions are true, the method creates a new color model by
calling the filterIndexColorModel method
on the model argument. The original color model and the newly
created color model are then passed as arguments to the
substituteColorModel
method. In addition, the setColorModel
method
of the filter's consumer
is called with the newly created color model.
If either condition is false, the method calls the |
|
setPixels(..byte pixels[],..) |
The image producer calls the setPixels method of the image consumer one or more times to deliver the pixels of the image. The setPixels method of RGBImageFilter looks to see if the color model is the same one that has already been converted and remembered for substitution by a previous call to the substituteColorModel mrethod. If so, it calls the setPixels method of its consumer , changing the color model argument to be the alternative color model. Otherwise, the method converts the buffer of byte pixels to the default RGB color model and passes the converted buffer to the filterRGBPixels method to be converted one by one. |
|
setPixels(..int pixels[], ..) |
The image producer calls the setPixels method of the image consumer one or more times to deliver the pixels of the image. The setPixels method of RGBImageFilter looks to see if the color model is the same one that has already been converted and remembered for substitution by a previous call to the substituteColorModel method. If so, it calls the setPixels method of the filter's consumer , changing the color model argument to be the alternative color model. Otherwise, the method converts the buffer of byte pixels to the default RGB color model and passes the converted buffer to the filterRGBPixels method to be converted one by one. |
|
substituteColorModel(ColorModel oldcm, ColorModel newcm) |
Registers two color model objects for substitution: If the oldcm is the color model during any subsequent call to either of the setPixels methods, the newcm argument is substituted and the pixels passed through unmodifed. |
The image consumer interface specifies the methods that all image consumers must implement. An image consumer is an object interested in data produced by the image producers. When a consumer is added to an image producer, the producer delivers all the data about the image using the method calls defined in this interface.
public interface java.awt.image.ImageConsumer
{
// status value for the imageComplete method
public final static int IMAGEABORTED;
/* IMAGEABORTED = 4, Argument to the imageComplete method indicating that the image creation process was deliberately aborted.
*/
public final static int IMAGEERROR;
/* IMAGEERROR = 1, Argument to the imageComplete method indicating that an error was encountered while producing the image.
public final static int SINGLEFRAMEDONE;
/* SINGLEFRAMEDONE = 2, Argument to the imageComplete method indicating that one frame of the image is complete but there are more frames to be delivered.
*/
public final static int STATICIMAGEDONE;
/* STATICIMAGEDONE = 3, Argument to the imageComplete method indicating that the image is complete and there are no more pixels or frames to be delivered.
*/
// hints used by the setHints method
public final static int COMPLETESCANLINES;
/* COMPLETESCANLINES = 4, Flag in the setHints method indicating that the pixels will be delivered in (multiples of) complete scanlines at a time.
*/
public final static int RANDOMPIXELORDER;
/* RANDOMPIXELORDER = 1, Flag in the setHints method indicating that the pixels will be delivered in a random order.
*/
public final static int SINGLEFRAME;
/* SINGLEFRAME = 8, Flag in the setHints method indicating that the image contains a single static image. The pixels will be defined in calls to the setPixels methods; the image producer then calls the imageComplete method with the STATICIMAGEDONE flag after which no more image data is delivered.
*/
public final static int SINGLEPASS;
// SINGLEPASS = 8, Flag in the setHints method indicating that each pixel will be delivered only once.
public final static int TOPDOWNLEFTRIGHT;
/* TOPDOWNLEFTRIGHT = 2,Flag in the setHints method indicating that the pixels will be delivered in a top-down, left-to-right order.
*/
// Methods
public abstract void imageComplete(int status);
public abstract void setColorModel(ColorModel model);
public abstract void setDimensions(int width, int height);
public abstract void setHints(int hintflags);
public abstract void setPixels(int x, int y, int w, int h,
ColorModel model, byte pixels[], int off, int scansize);
public abstract void setPixels(int x, int y, int w, int h,
ColorModel model, int pixels[], int off, int scansize);
public abstract void setProperties(Hashtable props);
}
Methods are stated as in Table 5.10.
Table 5.10
|
Methods |
Description |
|
imageComplete(int status) |
The image producer calls the imageComplete method when one of the following conditions has occurred : it has delivered all the pixels that the source image contains, a single frame of a multi-frame animation has been completed, an error in loading or producing the image has occurred. the image production was explicitly aborted by the application. The image consumer should remove itself from the list of consumers registered with the image producer unless it is interested in subsequent frames. |
|
setColorModel(ColorModel model) |
The image producer calls the setColorModel method to specify the color model for the majority of the subsequent setPixels method calls. Each set of pixels delivered using the setPixels method includes its own color model, so the image consumer should not assume that the model argument is the color model argument in every subsequent setPixels method call. A notable case where multiple ColorModel objects may be seen is a filtered image where for each set of pixels that it filters, the filter determines whether the pixels can be sent on untouched, using the original ColorModel, or should be modified (filtered) and passed on using a ColorModel more convenient for the filtering process. |
|
setDimensions(int width, int height) |
The image producer calls the setDimensions of the image consumer to indicate the width and height of the image. |
|
setHints(int hintflags) |
The
image producer calls the setHints method of the image consumer to
indicate the order in which the bits will be delivered. The image
producer is allowed to deliver the pixels in any order, but the
image consumer may be able to scale or convert the pixels more
efficiently or with higher quality if it knows some information
about how the pixels will be presented.The image producer should
call the setHints method before any calls to the image consumer's
setPixels method. The hintflags agument is a bit mask of hints
about the manner in which the pixels are delivered. |
|
setPixels(..byte pixels[],..) |
The image producer calls the setPixels method of the image consumer one or more times to deliver the pixels of the image. Each call specifies the location and size of the rectangle of source pixels contained in the array of pixels.The specified color model object should be used to convert the pixels into their corresponding color and alpha components. The pixel at coordinate (i, j) is stored in the pixel array at index (j - y) x scan + (i-x) + offset. The pixels delivered using this method are all stored as bytes. |
|
setPixels(...int pixels[],..) |
The image producer calls the setPixels method of the image consumer one or more times to deliver the pixels of the image. Each call specifies the location and size of the rectangle of source pixels that are contained in the array of pixels. The specified color model object should be used to convert the pixels into their corresponding color and alpha components. The pixel at coordinate )(i, j) is stored in the pixel array at index (j - y) x scan + (i-x) + offset. The pixels delivered using this method are all stored as integers. |
|
setProperties(Hashtable props) |
The image producer calls the setProperties method of the image consumer to indicate additional properties of the image. All keys to the hash table are strings. The corresponding values depend on the string. |
The image observer interface specifies the methods that all image observers must implement. An image observer is interested in receiving asynchronous notifications about the image as the image is being constructed.
public interface java.awt.image.ImageObserver
{
// flags for the infoflags argument to imageUpdate
public final static int ABORT;
/* ABORT = 128 : This flag in the infoflags argument to imageUpdate indicates that the image was aborted before production was complete.
*/
public final static int ALLBITS;
/* ALLBITS = 32 : This flag in the infoflags argument to imageUpdate indicates that a static image is now complete and can be drawn in its final form. The x, y, width, and height arguments to the imageUpdate method should be ignored when this flag is set in the status
*/
public final static int ERROR;
/* ERROR = 64 : This flag in the infoflags argument to imageUpdate indicates that an image which was being tracked asynchronously has encountered an error. No further information will become available, and drawing the image will fail. Whenever this flag is set, the ABORT flag must also be set.
*/
public final static int FRAMEBITS;
/* FRAMEBITS = 16 : This flag in the infoflags argument to imageUpdate indicates that another complete frame of a multi-frame image can now be drawn. The x, y, width, and height arguments to the imageUpdate method should be ignored when this flag is set in the status.
/*
public final static int HEIGHT;
/* HEIGHT = 2 : This flag in the infoflags argument to imageUpdate indicates that the height of the base image is now available and can be taken from the height argument to the imageUpdate method.
*/
public final static int PROPERTIES;
/* PROPERTIES = 4 : This flag in the infoflags argument to imageUpdate indicates that the properties of the image are now available.
*/
public final static int SOMEBITS;
/* SOMEBITS = 8 : This flag in the infoflags argument to imageUpdate indicates that the pixels needed for drawing a scaled variation of the image are now available.
*/
public final static int WIDTH;
/* WIDTH = 2 : This flag in the infoflags argument to imageUpdate indicates that the width of the base image is now available and can be taken from the width argument to the imageUpdate method.
*/
// Methods
public abstract boolean imageUpdate(Image img, int infoflags, int x,int y, int width, int height);
/* This image observer method is called when previously requested information about an image becomes available.
Asynchronous interfaces are method calls such as getWidth, getHeight, and drawImage which take an image observer as an argument. These methods register the caller as being interested either in information about the image or about an output version of the image. This method should return true if further calls to imageUpdate are needed by this image observer; false if it needs no more information.
The infoflags argument should be the OR of the following flags :
WIDTH HEIGHT PROPERTIES SOMEBITS FRAMEBITS ALLBITS ERROR ABORT
The interpretation of the x, y, width, and height arguments depends on the infoflags argument.
*/
}
The image producer interface specifies the methods that all image producers must implement. Every image contains an image producer which can reconstruct the image whenever it is needed by an image consumer.
public interface java.awt.image.ImageProducer
{
// Methods
public abstract void addConsumer(ImageConsumer ic);
public abstract boolean isConsumer(ImageConsumer ic);
public abstract void removeConsumer(ImageConsumer ic);
public abstract void requestTopDownLeftRightResend(ImageConsumer ic);
public abstract void startProduction(ImageConsumer ic);
}
Methods are described in Table 5.11.
Table 5.11
|
Methods |
Description |
|
addConsumer(ImageConsumer ic) |
Registers the image consumer argument as wanting information about this image. The image producer may, at its discretion, start delivering the image data immediately, or it may wait until the next image reconstruction is forced by a call to the startProduction method. |
|
isConsumer(ImageConsumer ic) |
Returns : true, if the specified image consumer argument is currently registered with this image producer as one of its consumers; false otherwise. |
|
removeConsumer(ImageConsumer ic) |
Removes the specified image consumer object from the list of consumers registered to receive the image data. It is not an error to remove a consumer that is not registered. The image producer should stop sending data to this consumer as soon as it is feasible. |
|
requestTopDownLeftRightResend(ImageConsumer ic) |
An
image consumer inokes this method to request that the image
producer attempt to resend the image data one more time in
top-down, left-to-right order. If the data cannot be resent in
that order, the image producer ignores this call. If the data can
be resent in that order, the image producer should respond by
executing the following minimum set of image consumer method
calls
ic.setHints(TOPDOWNLEFTRIGHT
| otherhints
); An image consumer might call this method so that it can use a higher quality conversion algorithm which depends on receiving the pixels in order. |
|
startProduction (ImageConsumer ic) |
Registers the image consumer argument as wanting information about this image. In addition, this method forces the image producer to start an immediate reconstruction of the image data. Then data will be delivered both to this image consumer and to any other image consumers which may have already been registered with the producer using the addConsumer method. |
