Source for java.awt.image.PixelGrabber

   1: /* PixelGrabber.java -- retrieve a subset of an image's data
   2:    Copyright (C) 1999, 2003, 2004  Free Software Foundation, Inc.
   3: 
   4: This file is part of GNU Classpath.
   5: 
   6: GNU Classpath is free software; you can redistribute it and/or modify
   7: it under the terms of the GNU General Public License as published by
   8: the Free Software Foundation; either version 2, or (at your option)
   9: any later version.
  10: 
  11: GNU Classpath is distributed in the hope that it will be useful, but
  12: WITHOUT ANY WARRANTY; without even the implied warranty of
  13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14: General Public License for more details.
  15: 
  16: You should have received a copy of the GNU General Public License
  17: along with GNU Classpath; see the file COPYING.  If not, write to the
  18: Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  19: 02110-1301 USA.
  20: 
  21: Linking this library statically or dynamically with other modules is
  22: making a combined work based on this library.  Thus, the terms and
  23: conditions of the GNU General Public License cover the whole
  24: combination.
  25: 
  26: As a special exception, the copyright holders of this library give you
  27: permission to link this library with independent modules to produce an
  28: executable, regardless of the license terms of these independent
  29: modules, and to copy and distribute the resulting executable under
  30: terms of your choice, provided that you also meet, for each linked
  31: independent module, the terms and conditions of the license of that
  32: module.  An independent module is a module which is not derived from
  33: or based on this library.  If you modify this library, you may extend
  34: this exception to your version of the library, but you are not
  35: obligated to do so.  If you do not wish to do so, delete this
  36: exception statement from your version. */
  37: 
  38: 
  39: package java.awt.image;
  40: 
  41: import java.awt.Image;
  42: import java.util.Hashtable;
  43: 
  44: /**
  45:  * PixelGrabber is an ImageConsumer that extracts a rectangular region
  46:  * of pixels from an Image.
  47:  */
  48: public class PixelGrabber implements ImageConsumer
  49: {
  50:   int x, y, offset;
  51:   int width = -1;
  52:   int height = -1;
  53:   int scansize = -1;
  54:   boolean forceRGB = true;
  55: 
  56:   ColorModel model = ColorModel.getRGBdefault();
  57:   int hints;
  58:   Hashtable<?,?> props;
  59: 
  60:   int int_pixel_buffer[];
  61:   boolean ints_delivered = false;
  62:   byte byte_pixel_buffer[];
  63:   boolean bytes_delivered = false;
  64: 
  65:   ImageProducer ip;
  66:   int observerStatus;
  67:   int consumerStatus;
  68: 
  69:   private Thread grabberThread;
  70:   boolean grabbing = false;
  71: 
  72:   /**
  73:    * Construct a PixelGrabber that will retrieve RGB data from a given
  74:    * Image.
  75:    *
  76:    * The RGB data will be retrieved from a rectangular region
  77:    * <code>(x, y, w, h)</code> within the image.  The data will be
  78:    * stored in the provided <code>pix</code> array, which must have
  79:    * been initialized to a size of at least <code>w * h</code>.  The
  80:    * data for a pixel (m, n) in the grab rectangle will be stored at
  81:    * <code>pix[(n - y) * scansize + (m - x) + off]</code>.
  82:    *
  83:    * @param img the Image from which to grab pixels
  84:    * @param x the x coordinate, relative to <code>img</code>'s
  85:    * top-left corner, of the grab rectangle's top-left pixel
  86:    * @param y the y coordinate, relative to <code>img</code>'s
  87:    * top-left corner, of the grab rectangle's top-left pixel
  88:    * @param w the width of the grab rectangle, in pixels
  89:    * @param h the height of the grab rectangle, in pixels
  90:    * @param pix the array in which to store grabbed RGB pixel data
  91:    * @param off the offset into the <code>pix</code> array at which to
  92:    * start storing RGB data
  93:    * @param scansize a set of <code>scansize</code> consecutive
  94:    * elements in the <code>pix</code> array represents one row of
  95:    * pixels in the grab rectangle
  96:    */
  97:   public PixelGrabber(Image img, int x, int y, int w, int h,
  98:                       int pix[], int off, int scansize)
  99:   {
 100:     this (img.getSource(), x, y, w, h, pix, off, scansize);
 101:   }
 102: 
 103:   /**
 104:    * Construct a PixelGrabber that will retrieve RGB data from a given
 105:    * ImageProducer.
 106:    *
 107:    * The RGB data will be retrieved from a rectangular region
 108:    * <code>(x, y, w, h)</code> within the image produced by
 109:    * <code>ip</code>.  The data will be stored in the provided
 110:    * <code>pix</code> array, which must have been initialized to a
 111:    * size of at least <code>w * h</code>.  The data for a pixel (m, n)
 112:    * in the grab rectangle will be stored at
 113:    * <code>pix[(n - y) * scansize + (m - x) + off]</code>.
 114:    *
 115:    * @param ip the ImageProducer from which to grab pixels. This can
 116:    * be null.
 117:    * @param x the x coordinate of the grab rectangle's top-left pixel,
 118:    * specified relative to the top-left corner of the image produced
 119:    * by <code>ip</code>
 120:    * @param y the y coordinate of the grab rectangle's top-left pixel,
 121:    * specified relative to the top-left corner of the image produced
 122:    * by <code>ip</code>
 123:    * @param w the width of the grab rectangle, in pixels
 124:    * @param h the height of the grab rectangle, in pixels
 125:    * @param pix the array in which to store grabbed RGB pixel data
 126:    * @param off the offset into the <code>pix</code> array at which to
 127:    * start storing RGB data
 128:    * @param scansize a set of <code>scansize</code> consecutive
 129:    * elements in the <code>pix</code> array represents one row of
 130:    * pixels in the grab rectangle
 131:    */
 132:   public PixelGrabber(ImageProducer ip, int x, int y, int w, int h,
 133:                       int pix[], int off, int scansize)
 134:   {
 135:     this.ip = ip;
 136:     this.x = x;
 137:     this.y = y;
 138:     this.width = w;
 139:     this.height = h;
 140:     this.offset = off;
 141:     this.scansize = scansize;
 142: 
 143:     int_pixel_buffer = pix;
 144:     // Initialize the byte array in case ip sends us byte-formatted
 145:     // pixel data.
 146:     byte_pixel_buffer = new byte[pix.length * 4];
 147:   }
 148: 
 149:   /**
 150:    * Construct a PixelGrabber that will retrieve data from a given
 151:    * Image.
 152:    *
 153:    * The RGB data will be retrieved from a rectangular region
 154:    * <code>(x, y, w, h)</code> within the image.  The data will be
 155:    * stored in an internal array which can be accessed by calling
 156:    * <code>getPixels</code>.  The data for a pixel (m, n) in the grab
 157:    * rectangle will be stored in the returned array at index
 158:    * <code>(n - y) * scansize + (m - x) + off</code>.
 159:    * If forceRGB is false, then the returned data will be not be
 160:    * converted to RGB from its format in <code>img</code>.
 161:    *
 162:    * If <code>w</code> is negative, the width of the grab region will
 163:    * be from x to the right edge of the image.  Likewise, if
 164:    * <code>h</code> is negative, the height of the grab region will be
 165:    * from y to the bottom edge of the image.
 166:    *
 167:    * @param img the Image from which to grab pixels
 168:    * @param x the x coordinate, relative to <code>img</code>'s
 169:    * top-left corner, of the grab rectangle's top-left pixel
 170:    * @param y the y coordinate, relative to <code>img</code>'s
 171:    * top-left corner, of the grab rectangle's top-left pixel
 172:    * @param w the width of the grab rectangle, in pixels
 173:    * @param h the height of the grab rectangle, in pixels
 174:    * @param forceRGB true to force conversion of the rectangular
 175:    * region's pixel data to RGB
 176:    */
 177:   public PixelGrabber(Image img,
 178:                       int x, int y,
 179:                       int w, int h,
 180:                       boolean forceRGB)
 181:   {
 182:     this.ip = img.getSource();
 183: 
 184:     if (this.ip == null)
 185:       throw new NullPointerException("The ImageProducer must not be null.");
 186: 
 187:     this.x = x;
 188:     this.y = y;
 189:     width = w;
 190:     height = h;
 191:     // If width or height is negative, postpone pixel buffer
 192:     // initialization until setDimensions is called back by ip.
 193:     if (width >= 0 && height >= 0)
 194:       {
 195:         int_pixel_buffer = new int[width * height];
 196:         byte_pixel_buffer = new byte[width * height];
 197:       }
 198:     this.forceRGB = forceRGB;
 199:   }
 200: 
 201:   /**
 202:    * Start grabbing pixels.
 203:    *
 204:    * Spawns an image production thread that calls back to this
 205:    * PixelGrabber's ImageConsumer methods.
 206:    */
 207:   public synchronized void startGrabbing()
 208:   {
 209:     // Make sure we're not already grabbing.
 210:     if (grabbing == false)
 211:       {
 212:         grabbing = true;
 213:         grabberThread = new Thread ()
 214:           {
 215:             public void run ()
 216:             {
 217:               try
 218:                 {
 219:                   ip.startProduction (PixelGrabber.this);
 220:                 }
 221:               catch (Exception ex)
 222:                 {
 223:                   imageComplete(ImageConsumer.IMAGEABORTED);
 224:                 }
 225:             }
 226:           };
 227:         grabberThread.start ();
 228:       }
 229:   }
 230: 
 231:   /**
 232:    * Abort pixel grabbing.
 233:    */
 234:   public synchronized void abortGrabbing()
 235:   {
 236:     if (grabbing)
 237:       {
 238:         // Interrupt the grabbing thread.
 239:         Thread moribund = grabberThread;
 240:         grabberThread = null;
 241:         moribund.interrupt();
 242: 
 243:         imageComplete (ImageConsumer.IMAGEABORTED);
 244:       }
 245:   }
 246: 
 247:   /**
 248:    * Have our Image or ImageProducer start sending us pixels via our
 249:    * ImageConsumer methods and wait for all pixels in the grab
 250:    * rectangle to be delivered.
 251:    *
 252:    * @return true if successful, false on abort or error
 253:    *
 254:    * @throws InterruptedException if interrupted by another thread.
 255:    */
 256:   public synchronized boolean grabPixels() throws InterruptedException
 257:   {
 258:     return grabPixels(0);
 259:   }
 260: 
 261:   /**
 262:    * grabPixels's behavior depends on the value of <code>ms</code>.
 263:    *
 264:    * If ms < 0, return true if all pixels from the source image have
 265:    * been delivered, false otherwise.  Do not wait.
 266:    *
 267:    * If ms >= 0 then we request that our Image or ImageProducer start
 268:    * delivering pixels to us via our ImageConsumer methods.
 269:    *
 270:    * If ms > 0, wait at most <code>ms</code> milliseconds for
 271:    * delivery of all pixels within the grab rectangle.
 272:    *
 273:    * If ms == 0, wait until all pixels have been delivered.
 274:    *
 275:    * @return true if all pixels from the source image have been
 276:    * delivered, false otherwise
 277:    *
 278:    * @throws InterruptedException if this thread is interrupted while
 279:    * we are waiting for pixels to be delivered
 280:    */
 281:   public synchronized boolean grabPixels(long ms) throws InterruptedException
 282:   {
 283:     if (ms < 0)
 284:       return ((observerStatus & (ImageObserver.FRAMEBITS
 285:                                  | ImageObserver.ALLBITS)) != 0);
 286: 
 287:     // Spawn a new ImageProducer thread to send us the image data via
 288:     // our ImageConsumer methods.
 289:     startGrabbing();
 290: 
 291:     if (ms > 0)
 292:       {
 293:         long stop_time = System.currentTimeMillis() + ms;
 294:         long time_remaining;
 295:         while (grabbing)
 296:           {
 297:             time_remaining = stop_time - System.currentTimeMillis();
 298:             if (time_remaining <= 0)
 299:               break;
 300:             wait (time_remaining);
 301:           }
 302:         abortGrabbing ();
 303:       }
 304:     else
 305:       wait ();
 306: 
 307:     // If consumerStatus is non-zero then the image is done loading or
 308:     // an error has occurred.
 309:     if (consumerStatus != 0)
 310:       return setObserverStatus ();
 311: 
 312:     return ((observerStatus & (ImageObserver.FRAMEBITS
 313:                                | ImageObserver.ALLBITS)) != 0);
 314:   }
 315: 
 316:   // Set observer status flags based on the current consumer status
 317:   // flags.  Return true if the consumer flags indicate that the
 318:   // image was loaded successfully, or false otherwise.
 319:   private synchronized boolean setObserverStatus ()
 320:   {
 321:     boolean retval = false;
 322: 
 323:     if ((consumerStatus & IMAGEERROR) != 0)
 324:       observerStatus |= ImageObserver.ERROR;
 325: 
 326:     if ((consumerStatus & IMAGEABORTED) != 0)
 327:       observerStatus |= ImageObserver.ABORT;
 328: 
 329:     if ((consumerStatus & STATICIMAGEDONE) != 0)
 330:       {
 331:         observerStatus |= ImageObserver.ALLBITS;
 332:         retval = true;
 333:       }
 334: 
 335:     if ((consumerStatus & SINGLEFRAMEDONE) != 0)
 336:       {
 337:         observerStatus |= ImageObserver.FRAMEBITS;
 338:         retval = true;
 339:       }
 340: 
 341:     return retval;
 342:   }
 343: 
 344:   /**
 345:    * @return the status of the pixel grabbing thread, represented by a
 346:    * bitwise OR of ImageObserver flags
 347:    */
 348:   public synchronized int getStatus()
 349:   {
 350:     return observerStatus;
 351:   }
 352: 
 353:   /**
 354:    * @return the width of the grab rectangle in pixels, or a negative
 355:    * number if the ImageProducer has not yet called our setDimensions
 356:    * method
 357:    */
 358:   public synchronized int getWidth()
 359:   {
 360:     return width;
 361:   }
 362: 
 363:   /**
 364:    * @return the height of the grab rectangle in pixels, or a negative
 365:    * number if the ImageProducer has not yet called our setDimensions
 366:    * method
 367:    */
 368:   public synchronized int getHeight()
 369:   {
 370:     return height;
 371:   }
 372: 
 373:   /**
 374:    * @return a byte array of pixel data if ImageProducer delivered
 375:    * pixel data using the byte[] variant of setPixels, or an int array
 376:    * otherwise
 377:    */
 378:   public synchronized Object getPixels()
 379:   {
 380:     if (ints_delivered)
 381:       return int_pixel_buffer;
 382:     else if (bytes_delivered)
 383:       return byte_pixel_buffer;
 384:     else
 385:       return null;
 386:   }
 387: 
 388:   /**
 389:    * @return the ColorModel currently being used for the majority of
 390:    * pixel data conversions
 391:    */
 392:   public synchronized ColorModel getColorModel()
 393:   {
 394:     return model;
 395:   }
 396: 
 397:   /**
 398:    * Our <code>ImageProducer</code> calls this method to indicate the
 399:    * size of the image being produced.
 400:    *
 401:    * setDimensions is an ImageConsumer method.  None of PixelGrabber's
 402:    * ImageConsumer methods should be called by code that instantiates
 403:    * a PixelGrabber.  They are only made public so they can be called
 404:    * by the PixelGrabber's ImageProducer.
 405:    *
 406:    * @param width the width of the image
 407:    * @param height the height of the image
 408:    */
 409:   public synchronized void setDimensions(int width, int height)
 410:   {
 411:     // Our width wasn't set when we were constructed.  Set our width
 412:     // so that the grab region includes all pixels from x to the right
 413:     // edge of the source image.
 414:     if (this.width < 0)
 415:       this.width = width - x;
 416: 
 417:     // Our height wasn't set when we were constructed.  Set our height
 418:     // so that the grab region includes all pixels from y to the
 419:     // bottom edge of the source image.
 420:     if (this.height < 0)
 421:       this.height = height - y;
 422: 
 423:     if (scansize < 0)
 424:       scansize = this.width;
 425: 
 426:     if (int_pixel_buffer == null)
 427:       int_pixel_buffer = new int[this.width * this.height];
 428: 
 429:     if (byte_pixel_buffer == null)
 430:       byte_pixel_buffer = new byte[this.width * this.height];
 431:   }
 432: 
 433:   /**
 434:    * Our <code>ImageProducer</code> may call this method to send us a
 435:    * list of its image's properties.
 436:    *
 437:    * setProperties is an ImageConsumer method.  None of PixelGrabber's
 438:    * ImageConsumer methods should be called by code that instantiates
 439:    * a PixelGrabber.  They are only made public so they can be called
 440:    * by the PixelGrabber's ImageProducer.
 441:    *
 442:    * @param props a list of properties associated with the image being
 443:    * produced
 444:    */
 445:   public synchronized void setProperties(Hashtable<?,?> props)
 446:   {
 447:     this.props = props;
 448:   }
 449: 
 450:   /**
 451:    * Our ImageProducer will call <code>setColorModel</code> to
 452:    * indicate the model used by the majority of calls to
 453:    * <code>setPixels</code>.  Each call to <code>setPixels</code>
 454:    * could however indicate a different <code>ColorModel</code>.
 455:    *
 456:    * setColorModel is an ImageConsumer method.  None of PixelGrabber's
 457:    * ImageConsumer methods should be called by code that instantiates
 458:    * a PixelGrabber.  They are only made public so they can be called
 459:    * by the PixelGrabber's ImageProducer.
 460:    *
 461:    * @param model the color model to be used most often by setPixels
 462:    *
 463:    * @see ColorModel
 464:    */
 465:   public synchronized void setColorModel(ColorModel model)
 466:   {
 467:     this.model = model;
 468:   }
 469: 
 470:   /**
 471:    * Our <code>ImageProducer</code> may call this method with a
 472:    * bit mask of hints from any of <code>RANDOMPIXELORDER</code>,
 473:    * <code>TOPDOWNLEFTRIGHT</code>, <code>COMPLETESCANLINES</code>,
 474:    * <code>SINGLEPASS</code>, <code>SINGLEFRAME</code>.
 475:    *
 476:    * setHints is an ImageConsumer method.  None of PixelGrabber's
 477:    * ImageConsumer methods should be called by code that instantiates
 478:    * a PixelGrabber.  They are only made public so they can be called
 479:    * by the PixelGrabber's ImageProducer.
 480:    *
 481:    * @param flags a bit mask of hints
 482:    */
 483:   public synchronized void setHints(int flags)
 484:   {
 485:     hints = flags;
 486:   }
 487: 
 488:   /**
 489:    * Our ImageProducer calls setPixels to deliver a subset of its
 490:    * pixels.
 491:    *
 492:    * Each element of the pixels array represents one pixel.  The
 493:    * pixel data is formatted according to the color model model.
 494:    * The x and y parameters are the coordinates of the rectangular
 495:    * region of pixels being delivered to this ImageConsumer,
 496:    * specified relative to the top left corner of the image being
 497:    * produced.  Likewise, w and h are the pixel region's dimensions.
 498:    *
 499:    * @param x x coordinate of pixel block
 500:    * @param y y coordinate of pixel block
 501:    * @param w width of pixel block
 502:    * @param h height of pixel block
 503:    * @param model color model used to interpret pixel data
 504:    * @param pixels pixel block data
 505:    * @param offset offset into pixels array
 506:    * @param scansize width of one row in the pixel block
 507:    */
 508:   public synchronized void setPixels(int x, int y, int w, int h,
 509:                                      ColorModel model, byte[] pixels,
 510:                                      int offset, int scansize)
 511:   {
 512:     ColorModel currentModel;
 513:     if (model != null)
 514:       currentModel = model;
 515:     else
 516:       currentModel = this.model;
 517: 
 518:     for(int yp = y; yp < (y + h); yp++)
 519:       {
 520:         for(int xp = x; xp < (x + w); xp++)
 521:           {
 522:             // Check if the coordinates (xp, yp) are within the
 523:             // pixel block that we are grabbing.
 524:             if(xp >= this.x
 525:                && yp >= this.y
 526:                && xp < (this.x + this.width)
 527:                && yp < (this.y + this.height))
 528:               {
 529:                 int i = (yp - this.y) * this.scansize + (xp - this.x) + this.offset;
 530:                 int p = (yp - y) * scansize + (xp - x) + offset;
 531:                 if (forceRGB)
 532:                   {
 533:                     ints_delivered = true;
 534: 
 535:                     int_pixel_buffer[i] = currentModel.getRGB (pixels[p] & 0xFF);
 536:                   }
 537:                 else
 538:                   {
 539:                     bytes_delivered = true;
 540: 
 541:                     byte_pixel_buffer[i] = pixels[p];
 542:                   }
 543:               }
 544:           }
 545:       }
 546:   }
 547: 
 548:   /**
 549:    * Our ImageProducer calls setPixels to deliver a subset of its
 550:    * pixels.
 551:    *
 552:    * Each element of the pixels array represents one pixel.  The
 553:    * pixel data is formatted according to the color model model.
 554:    * The x and y parameters are the coordinates of the rectangular
 555:    * region of pixels being delivered to this ImageConsumer,
 556:    * specified relative to the top left corner of the image being
 557:    * produced.  Likewise, w and h are the pixel region's dimensions.
 558:    *
 559:    * @param x x coordinate of pixel block
 560:    * @param y y coordinate of pixel block
 561:    * @param w width of pixel block
 562:    * @param h height of pixel block
 563:    * @param model color model used to interpret pixel data
 564:    * @param pixels pixel block data
 565:    * @param offset offset into pixels array
 566:    * @param scansize width of one row in the pixel block
 567:    */
 568:   public synchronized void setPixels(int x, int y, int w, int h,
 569:                                      ColorModel model, int[] pixels,
 570:                                      int offset, int scansize)
 571:   {
 572:     ColorModel currentModel;
 573:     if (model != null)
 574:       currentModel = model;
 575:     else
 576:       currentModel = this.model;
 577: 
 578:     ints_delivered = true;
 579: 
 580:     for(int yp = y; yp < (y + h); yp++)
 581:       {
 582:         for(int xp = x; xp < (x + w); xp++)
 583:           {
 584:             // Check if the coordinates (xp, yp) are within the
 585:             // pixel block that we are grabbing.
 586:             if(xp >= this.x
 587:                && yp >= this.y
 588:                && xp < (this.x + this.width)
 589:                && yp < (this.y + this.height))
 590:               {
 591:                 int i = (yp - this.y) * this.scansize + (xp - this.x) + this.offset;
 592:                 int p = (yp - y) * scansize + (xp - x) + offset;
 593:                 if (forceRGB)
 594:                   int_pixel_buffer[i] = currentModel.getRGB (pixels[p]);
 595:                 else
 596:                   int_pixel_buffer[i] = pixels[p];
 597:               }
 598:           }
 599:       }
 600:   }
 601: 
 602:   /**
 603:    * Our <code>ImageProducer</code> calls this method to inform us
 604:    * that a single frame or the entire image is complete.  The method
 605:    * is also used to inform us of an error in loading or producing the
 606:    * image.
 607:    *
 608:    * @param status the status of image production, represented by a
 609:    * bitwise OR of ImageConsumer flags
 610:    */
 611:   public synchronized void imageComplete(int status)
 612:   {
 613:     consumerStatus = status;
 614:     setObserverStatus ();
 615:     grabbing = false;
 616:     if (ip != null)
 617:       ip.removeConsumer (this);
 618: 
 619:     notifyAll ();
 620:   }
 621: 
 622:   /**
 623:    * @return the return value of getStatus
 624:    *
 625:    * @specnote The newer getStatus should be used in place of status.
 626:    */
 627:   public synchronized int status()
 628:   {
 629:     return getStatus();
 630:   }
 631: }