Back to index...

	/*
	* Copyright (c) 1995, 2013, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/

	package java.awt.image;

	import java.util.Hashtable;
	import java.awt.image.ImageProducer;
	import java.awt.image.ImageConsumer;
	import java.awt.image.ColorModel;
	import java.awt.Image;

	/**
	* 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:
	* <pre>{@code
	*
	* 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 < h; j++) {
	* for (int i = 0; i < w; i++) {
	* handlesinglepixel(x+i, y+j, pixels[j * w + i]);
	* }
	* }
	* }
	*
	* }</pre>
	*
	* @see ColorModel#getRGBdefault
	*
	* @author Jim Graham
	*/
	public class PixelGrabber implements ImageConsumer {
	ImageProducer producer;

	int dstX;
	int dstY;
	int dstW;
	int dstH;

	ColorModel imageModel;
	byte[] bytePixels;
	int[] intPixels;
	int dstOff;
	int dstScan;

	private boolean grabbing;
	private int flags;

	private static final int GRABBEDBITS = (ImageObserver.FRAMEBITS
	\| ImageObserver.ALLBITS);
	private static final int DONEBITS = (GRABBEDBITS
	\| ImageObserver.ERROR);

	/**
	* Create a PixelGrabber object to grab the (x, y, w, h) rectangular
	* section of pixels from the specified image 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
	* <tt>pix[(j - y) * scansize + (i - x) + off]</tt>.
	* @see ColorModel#getRGBdefault
	* @param img the image 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
	*/
	public PixelGrabber(Image img, int x, int y, int w, int h,
	int[] pix, int off, int scansize) {
	this(img.getSource(), x, y, w, h, pix, off, scansize);
	}

	/**
	* 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
	* <tt>pix[(j - y) * scansize + (i - x) + off]</tt>.
	* @param ip the <code>ImageProducer</code> that produces the
	* image from which to retrieve pixels
	* @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
	*/
	public PixelGrabber(ImageProducer ip, int x, int y, int w, int h,
	int[] pix, int off, int scansize) {
	producer = ip;
	dstX = x;
	dstY = y;
	dstW = w;
	dstH = h;
	dstOff = off;
	dstScan = scansize;
	intPixels = pix;
	imageModel = ColorModel.getRGBdefault();
	}

	/**
	* Create a PixelGrabber object to grab the (x, y, w, h) rectangular
	* section of pixels from the specified image. The pixels are
	* accumulated in the original ColorModel if the same ColorModel
	* is used for every call to setPixels, otherwise the pixels are
	* accumulated in the default RGB ColorModel. If the forceRGB
	* parameter is true, then the pixels will be accumulated in the
	* default RGB ColorModel anyway. A buffer is allocated by the
	* PixelGrabber to hold the pixels in either case. If {@code (w < 0)} or
	* {@code (h < 0)}, then they will default to the remaining width and
	* height of the source data when that information is delivered.
	* @param img the image to retrieve the image data 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 forceRGB true if the pixels should always be converted to
	* the default RGB ColorModel
	*/
	public PixelGrabber(Image img, int x, int y, int w, int h,
	boolean forceRGB)
	{
	producer = img.getSource();
	dstX = x;
	dstY = y;
	dstW = w;
	dstH = h;
	if (forceRGB) {
	imageModel = ColorModel.getRGBdefault();
	}
	}

	/**
	* Request the PixelGrabber to start fetching the pixels.
	*/
	public synchronized void startGrabbing() {
	if ((flags & DONEBITS) != 0) {
	return;
	}
	if (!grabbing) {
	grabbing = true;
	flags &= ~(ImageObserver.ABORT);
	producer.startProduction(this);
	}
	}

	/**
	* Request the PixelGrabber to abort the image fetch.
	*/
	public synchronized void abortGrabbing() {
	imageComplete(IMAGEABORTED);
	}

	/**
	* Request the Image or ImageProducer to start delivering pixels and
	* wait for all of the pixels in the rectangle of interest to be
	* delivered.
	* @return true if the pixels were successfully grabbed, false on
	* abort, error or timeout
	* @exception InterruptedException
	* Another thread has interrupted this thread.
	*/
	public boolean grabPixels() throws InterruptedException {
	return grabPixels(0);
	}

	/**
	* Request the Image or ImageProducer to start delivering pixels and
	* wait for all of the pixels in the rectangle of interest to be
	* delivered or until the specified timeout has elapsed. This method
	* behaves in the following ways, depending on the value of
	* <code>ms</code>:
	* <ul>
	* <li> If {@code ms == 0}, waits until all pixels are delivered
	* <li> If {@code ms > 0}, waits until all pixels are delivered
	* as timeout expires.
	* <li> If {@code ms < 0}, returns <code>true</code> if all pixels
	* are grabbed, <code>false</code> otherwise and does not wait.
	* </ul>
	* @param ms the number of milliseconds to wait for the image pixels
	* to arrive before timing out
	* @return true if the pixels were successfully grabbed, false on
	* abort, error or timeout
	* @exception InterruptedException
	* Another thread has interrupted this thread.
	*/
	public synchronized boolean grabPixels(long ms)
	throws InterruptedException
	{
	if ((flags & DONEBITS) != 0) {
	return (flags & GRABBEDBITS) != 0;
	}
	long end = ms + System.currentTimeMillis();
	if (!grabbing) {
	grabbing = true;
	flags &= ~(ImageObserver.ABORT);
	producer.startProduction(this);
	}
	while (grabbing) {
	long timeout;
	if (ms == 0) {
	timeout = 0;
	} else {
	timeout = end - System.currentTimeMillis();
	if (timeout <= 0) {
	break;
	}
	}
	wait(timeout);
	}
	return (flags & GRABBEDBITS) != 0;
	}

	/**
	* Return the status of the pixels. The ImageObserver flags
	* representing the available pixel information are returned.
	* @return the bitwise OR of all relevant ImageObserver flags
	* @see ImageObserver
	*/
	public synchronized int getStatus() {
	return flags;
	}

	/**
	* Get the width of the pixel buffer (after adjusting for image width).
	* If no width was specified for the rectangle of pixels to grab then
	* then this information will only be available after the image has
	* delivered the dimensions.
	* @return the final width used for the pixel buffer or -1 if the width
	* is not yet known
	* @see #getStatus
	*/
	public synchronized int getWidth() {
	return (dstW < 0) ? -1 : dstW;
	}

	/**
	* Get the height of the pixel buffer (after adjusting for image height).
	* If no width was specified for the rectangle of pixels to grab then
	* then this information will only be available after the image has
	* delivered the dimensions.
	* @return the final height used for the pixel buffer or -1 if the height
	* is not yet known
	* @see #getStatus
	*/
	public synchronized int getHeight() {
	return (dstH < 0) ? -1 : dstH;
	}

	/**
	* 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)
	*/
	public synchronized Object getPixels() {
	return (bytePixels == null)
	? ((Object) intPixels)
	: ((Object) bytePixels);
	}

	/**
	* 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)
	*/
	public synchronized ColorModel getColorModel() {
	return imageModel;
	}

	/**
	* The setDimensions method is part of the ImageConsumer API which
	* this class must implement to retrieve the pixels.
	* <p>
	* 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
	*/
	public void setDimensions(int width, int height) {
	if (dstW < 0) {
	dstW = width - dstX;
	}
	if (dstH < 0) {
	dstH = height - dstY;
	}
	if (dstW <= 0 \|\| dstH <= 0) {
	imageComplete(STATICIMAGEDONE);
	} else if (intPixels == null &&
	imageModel == ColorModel.getRGBdefault()) {
	intPixels = new int[dstW * dstH];
	dstScan = dstW;
	dstOff = 0;
	}
	flags \|= (ImageObserver.WIDTH \| ImageObserver.HEIGHT);
	}

	/**
	* The setHints method is part of the ImageConsumer API which
	* this class must implement to retrieve the pixels.
	* <p>
	* 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
	*/
	public void setHints(int hints) {
	return;
	}

	/**
	* The setProperties method is part of the ImageConsumer API which
	* this class must implement to retrieve the pixels.
	* <p>
	* 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
	*/
	public void setProperties(Hashtable<?,?> props) {
	return;
	}

	/**
	* The setColorModel method is part of the ImageConsumer API which
	* this class must implement to retrieve the pixels.
	* <p>
	* 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 <code>ColorModel</code>
	* @see #getColorModel
	*/
	public void setColorModel(ColorModel model) {
	return;
	}

	private void convertToRGB() {
	int size = dstW * dstH;
	int newpixels[] = new int[size];
	if (bytePixels != null) {
	for (int i = 0; i < size; i++) {
	newpixels[i] = imageModel.getRGB(bytePixels[i] & 0xff);
	}
	} else if (intPixels != null) {
	for (int i = 0; i < size; i++) {
	newpixels[i] = imageModel.getRGB(intPixels[i]);
	}
	}
	bytePixels = null;
	intPixels = newpixels;
	dstScan = dstW;
	dstOff = 0;
	imageModel = ColorModel.getRGBdefault();
	}

	/**
	* The setPixels method is part of the ImageConsumer API which
	* this class must implement to retrieve the pixels.
	* <p>
	* 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 the X coordinate of the upper-left corner
	* of the area of pixels to be set
	* @param srcY the Y coordinate 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 <code>ColorModel</code>
	* @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
	*/
	public void setPixels(int srcX, int srcY, int srcW, int srcH,
	ColorModel model,
	byte pixels[], int srcOff, int srcScan) {
	if (srcY < dstY) {
	int diff = dstY - srcY;
	if (diff >= srcH) {
	return;
	}
	srcOff += srcScan * diff;
	srcY += diff;
	srcH -= diff;
	}
	if (srcY + srcH > dstY + dstH) {
	srcH = (dstY + dstH) - srcY;
	if (srcH <= 0) {
	return;
	}
	}
	if (srcX < dstX) {
	int diff = dstX - srcX;
	if (diff >= srcW) {
	return;
	}
	srcOff += diff;
	srcX += diff;
	srcW -= diff;
	}
	if (srcX + srcW > dstX + dstW) {
	srcW = (dstX + dstW) - srcX;
	if (srcW <= 0) {
	return;
	}
	}
	int dstPtr = dstOff + (srcY - dstY) * dstScan + (srcX - dstX);
	if (intPixels == null) {
	if (bytePixels == null) {
	bytePixels = new byte[dstW * dstH];
	dstScan = dstW;
	dstOff = 0;
	imageModel = model;
	} else if (imageModel != model) {
	convertToRGB();
	}
	if (bytePixels != null) {
	for (int h = srcH; h > 0; h--) {
	System.arraycopy(pixels, srcOff, bytePixels, dstPtr, srcW);
	srcOff += srcScan;
	dstPtr += dstScan;
	}
	}
	}
	if (intPixels != null) {
	int dstRem = dstScan - srcW;
	int srcRem = srcScan - srcW;
	for (int h = srcH; h > 0; h--) {
	for (int w = srcW; w > 0; w--) {
	intPixels[dstPtr++] = model.getRGB(pixels[srcOff++]&0xff);
	}
	srcOff += srcRem;
	dstPtr += dstRem;
	}
	}
	flags \|= ImageObserver.SOMEBITS;
	}

	/**
	* The setPixels method is part of the ImageConsumer API which
	* this class must implement to retrieve the pixels.
	* <p>
	* 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 the X coordinate of the upper-left corner
	* of the area of pixels to be set
	* @param srcY the Y coordinate 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 <code>ColorModel</code>
	* @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
	*/
	public void setPixels(int srcX, int srcY, int srcW, int srcH,
	ColorModel model,
	int pixels[], int srcOff, int srcScan) {
	if (srcY < dstY) {
	int diff = dstY - srcY;
	if (diff >= srcH) {
	return;
	}
	srcOff += srcScan * diff;
	srcY += diff;
	srcH -= diff;
	}
	if (srcY + srcH > dstY + dstH) {
	srcH = (dstY + dstH) - srcY;
	if (srcH <= 0) {
	return;
	}
	}
	if (srcX < dstX) {
	int diff = dstX - srcX;
	if (diff >= srcW) {
	return;
	}
	srcOff += diff;
	srcX += diff;
	srcW -= diff;
	}
	if (srcX + srcW > dstX + dstW) {
	srcW = (dstX + dstW) - srcX;
	if (srcW <= 0) {
	return;
	}
	}
	if (intPixels == null) {
	if (bytePixels == null) {
	intPixels = new int[dstW * dstH];
	dstScan = dstW;
	dstOff = 0;
	imageModel = model;
	} else {
	convertToRGB();
	}
	}
	int dstPtr = dstOff + (srcY - dstY) * dstScan + (srcX - dstX);
	if (imageModel == model) {
	for (int h = srcH; h > 0; h--) {
	System.arraycopy(pixels, srcOff, intPixels, dstPtr, srcW);
	srcOff += srcScan;
	dstPtr += dstScan;
	}
	} else {
	if (imageModel != ColorModel.getRGBdefault()) {
	convertToRGB();
	}
	int dstRem = dstScan - srcW;
	int srcRem = srcScan - srcW;
	for (int h = srcH; h > 0; h--) {
	for (int w = srcW; w > 0; w--) {
	intPixels[dstPtr++] = model.getRGB(pixels[srcOff++]);
	}
	srcOff += srcRem;
	dstPtr += dstRem;
	}
	}
	flags \|= ImageObserver.SOMEBITS;
	}

	/**
	* The imageComplete method is part of the ImageConsumer API which
	* this class must implement to retrieve the pixels.
	* <p>
	* 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
	*/
	public synchronized void imageComplete(int status) {
	grabbing = false;
	switch (status) {
	default:
	case IMAGEERROR:
	flags \|= ImageObserver.ERROR \| ImageObserver.ABORT;
	break;
	case IMAGEABORTED:
	flags \|= ImageObserver.ABORT;
	break;
	case STATICIMAGEDONE:
	flags \|= ImageObserver.ALLBITS;
	break;
	case SINGLEFRAMEDONE:
	flags \|= ImageObserver.FRAMEBITS;
	break;
	}
	producer.removeConsumer(this);
	notifyAll();
	}

	/**
	* Returns the status of the pixels. The ImageObserver flags
	* representing the available pixel information are returned.
	* This method and {@link #getStatus() getStatus} have the
	* same implementation, but <code>getStatus</code> is the
	* preferred method because it conforms to the convention of
	* naming information-retrieval methods with the form
	* "getXXX".
	* @return the bitwise OR of all relevant ImageObserver flags
	* @see ImageObserver
	* @see #getStatus()
	*/
	public synchronized int status() {
	return flags;
	}
	}

Back to index...