1 /*
   2  * Copyright (c) 1997, 2016, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 /* ****************************************************************
  27  ******************************************************************
  28  ******************************************************************
  29  *** COPYRIGHT (c) Eastman Kodak Company, 1997
  30  *** As  an unpublished  work pursuant to Title 17 of the United
  31  *** States Code.  All rights reserved.
  32  ******************************************************************
  33  ******************************************************************
  34  ******************************************************************/
  35 
  36 
  37 package java.awt.image;
  38 import java.awt.Rectangle;
  39 import java.awt.Point;
  40 
  41 import sun.awt.image.ByteInterleavedRaster;
  42 import sun.awt.image.ShortInterleavedRaster;
  43 import sun.awt.image.IntegerInterleavedRaster;
  44 import sun.awt.image.ByteBandedRaster;
  45 import sun.awt.image.ShortBandedRaster;
  46 import sun.awt.image.BytePackedRaster;
  47 import sun.awt.image.SunWritableRaster;
  48 
  49 /**
  50  * A class representing a rectangular array of pixels.  A Raster
  51  * encapsulates a DataBuffer that stores the sample values and a
  52  * SampleModel that describes how to locate a given sample value in a
  53  * DataBuffer.
  54  * <p>
  55  * A Raster defines values for pixels occupying a particular
  56  * rectangular area of the plane, not necessarily including (0, 0).
  57  * The rectangle, known as the Raster's bounding rectangle and
  58  * available by means of the getBounds method, is defined by minX,
  59  * minY, width, and height values.  The minX and minY values define
  60  * the coordinate of the upper left corner of the Raster.  References
  61  * to pixels outside of the bounding rectangle may result in an
  62  * exception being thrown, or may result in references to unintended
  63  * elements of the Raster's associated DataBuffer.  It is the user's
  64  * responsibility to avoid accessing such pixels.
  65  * <p>
  66  * A SampleModel describes how samples of a Raster
  67  * are stored in the primitive array elements of a DataBuffer.
  68  * Samples may be stored one per data element, as in a
  69  * PixelInterleavedSampleModel or BandedSampleModel, or packed several to
  70  * an element, as in a SinglePixelPackedSampleModel or
  71  * MultiPixelPackedSampleModel.  The SampleModel is also
  72  * controls whether samples are sign extended, allowing unsigned
  73  * data to be stored in signed Java data types such as byte, short, and
  74  * int.
  75  * <p>
  76  * Although a Raster may live anywhere in the plane, a SampleModel
  77  * makes use of a simple coordinate system that starts at (0, 0).  A
  78  * Raster therefore contains a translation factor that allows pixel
  79  * locations to be mapped between the Raster's coordinate system and
  80  * that of the SampleModel.  The translation from the SampleModel
  81  * coordinate system to that of the Raster may be obtained by the
  82  * getSampleModelTranslateX and getSampleModelTranslateY methods.
  83  * <p>
  84  * A Raster may share a DataBuffer with another Raster either by
  85  * explicit construction or by the use of the createChild and
  86  * createTranslatedChild methods.  Rasters created by these methods
  87  * can return a reference to the Raster they were created from by
  88  * means of the getParent method.  For a Raster that was not
  89  * constructed by means of a call to createTranslatedChild or
  90  * createChild, getParent will return null.
  91  * <p>
  92  * The createTranslatedChild method returns a new Raster that
  93  * shares all of the data of the current Raster, but occupies a
  94  * bounding rectangle of the same width and height but with a
  95  * different starting point.  For example, if the parent Raster
  96  * occupied the region (10, 10) to (100, 100), and the translated
  97  * Raster was defined to start at (50, 50), then pixel (20, 20) of the
  98  * parent and pixel (60, 60) of the child occupy the same location in
  99  * the DataBuffer shared by the two Rasters.  In the first case, (-10,
 100  * -10) should be added to a pixel coordinate to obtain the
 101  * corresponding SampleModel coordinate, and in the second case (-50,
 102  * -50) should be added.
 103  * <p>
 104  * The translation between a parent and child Raster may be
 105  * determined by subtracting the child's sampleModelTranslateX and
 106  * sampleModelTranslateY values from those of the parent.
 107  * <p>
 108  * The createChild method may be used to create a new Raster
 109  * occupying only a subset of its parent's bounding rectangle
 110  * (with the same or a translated coordinate system) or
 111  * with a subset of the bands of its parent.
 112  * <p>
 113  * All constructors are protected.  The correct way to create a
 114  * Raster is to use one of the static create methods defined in this
 115  * class.  These methods create instances of Raster that use the
 116  * standard Interleaved, Banded, and Packed SampleModels and that may
 117  * be processed more efficiently than a Raster created by combining
 118  * an externally generated SampleModel and DataBuffer.
 119  * @see java.awt.image.DataBuffer
 120  * @see java.awt.image.SampleModel
 121  * @see java.awt.image.PixelInterleavedSampleModel
 122  * @see java.awt.image.BandedSampleModel
 123  * @see java.awt.image.SinglePixelPackedSampleModel
 124  * @see java.awt.image.MultiPixelPackedSampleModel
 125  */
 126 public class Raster {
 127 
 128     /**
 129      * The SampleModel that describes how pixels from this Raster
 130      * are stored in the DataBuffer.
 131      */
 132     protected SampleModel sampleModel;
 133 
 134     /** The DataBuffer that stores the image data. */
 135     protected DataBuffer dataBuffer;
 136 
 137     /** The X coordinate of the upper-left pixel of this Raster. */
 138     protected int minX;
 139 
 140     /** The Y coordinate of the upper-left pixel of this Raster. */
 141     protected int minY;
 142 
 143     /** The width of this Raster. */
 144     protected int width;
 145 
 146     /** The height of this Raster. */
 147     protected int height;
 148 
 149     /**
 150      * The X translation from the coordinate space of the
 151      * Raster's SampleModel to that of the Raster.
 152      */
 153     protected int sampleModelTranslateX;
 154 
 155     /**
 156      * The Y translation from the coordinate space of the
 157      * Raster's SampleModel to that of the Raster.
 158      */
 159     protected int sampleModelTranslateY;
 160 
 161     /** The number of bands in the Raster. */
 162     protected int numBands;
 163 
 164     /** The number of DataBuffer data elements per pixel. */
 165     protected int numDataElements;
 166 
 167     /** The parent of this Raster, or null. */
 168     protected Raster parent;
 169 
 170     private static native void initIDs();
 171     static {
 172         ColorModel.loadLibraries();
 173         initIDs();
 174     }
 175 
 176     /**
 177      * Creates a Raster based on a PixelInterleavedSampleModel with the
 178      * specified data type, width, height, and number of bands.
 179      *
 180      * <p> The upper left corner of the Raster is given by the
 181      * location argument.  If location is null, (0, 0) will be used.
 182      * The dataType parameter should be one of the enumerated values
 183      * defined in the DataBuffer class.
 184      *
 185      * <p> Note that interleaved {@code DataBuffer.TYPE_INT}
 186      * Rasters are not supported.  To create a 1-band Raster of type
 187      * {@code DataBuffer.TYPE_INT}, use
 188      * Raster.createPackedRaster().
 189      * <p> The only dataTypes supported currently are TYPE_BYTE
 190      * and TYPE_USHORT.
 191      * @param dataType  the data type for storing samples
 192      * @param w         the width in pixels of the image data
 193      * @param h         the height in pixels of the image data
 194      * @param bands     the number of bands
 195      * @param location  the upper-left corner of the {@code Raster}
 196      * @return a WritableRaster object with the specified data type,
 197      *         width, height and number of bands.
 198      * @throws RasterFormatException if {@code w} or {@code h}
 199      *         is less than or equal to zero, or computing either
 200      *         {@code location.x + w} or
 201      *         {@code location.y + h} results in integer
 202      *         overflow
 203      */
 204     public static WritableRaster createInterleavedRaster(int dataType,
 205                                                          int w, int h,
 206                                                          int bands,
 207                                                          Point location) {
 208         int[] bandOffsets = new int[bands];
 209         for (int i = 0; i < bands; i++) {
 210             bandOffsets[i] = i;
 211         }
 212         return createInterleavedRaster(dataType, w, h, w*bands, bands,
 213                                        bandOffsets, location);
 214     }
 215 
 216     /**
 217      * Creates a Raster based on a PixelInterleavedSampleModel with the
 218      * specified data type, width, height, scanline stride, pixel
 219      * stride, and band offsets.  The number of bands is inferred from
 220      * bandOffsets.length.
 221      *
 222      * <p> The upper left corner of the Raster is given by the
 223      * location argument.  If location is null, (0, 0) will be used.
 224      * The dataType parameter should be one of the enumerated values
 225      * defined in the DataBuffer class.
 226      *
 227      * <p> Note that interleaved {@code DataBuffer.TYPE_INT}
 228      * Rasters are not supported.  To create a 1-band Raster of type
 229      * {@code DataBuffer.TYPE_INT}, use
 230      * Raster.createPackedRaster().
 231      * <p> The only dataTypes supported currently are TYPE_BYTE
 232      * and TYPE_USHORT.
 233      * @param dataType  the data type for storing samples
 234      * @param w         the width in pixels of the image data
 235      * @param h         the height in pixels of the image data
 236      * @param scanlineStride the line stride of the image data
 237      * @param pixelStride the pixel stride of the image data
 238      * @param bandOffsets the offsets of all bands
 239      * @param location  the upper-left corner of the {@code Raster}
 240      * @return a WritableRaster object with the specified data type,
 241      *         width, height, scanline stride, pixel stride and band
 242      *         offsets.
 243      * @throws RasterFormatException if {@code w} or {@code h}
 244      *         is less than or equal to zero, or computing either
 245      *         {@code location.x + w} or
 246      *         {@code location.y + h} results in integer
 247      *         overflow
 248      * @throws IllegalArgumentException if {@code dataType} is not
 249      *         one of the supported data types, which are
 250      *         {@code DataBuffer.TYPE_BYTE}, or
 251      *         {@code DataBuffer.TYPE_USHORT}.
 252      */
 253     public static WritableRaster createInterleavedRaster(int dataType,
 254                                                          int w, int h,
 255                                                          int scanlineStride,
 256                                                          int pixelStride,
 257                                                          int bandOffsets[],
 258                                                          Point location) {
 259         DataBuffer d;
 260 
 261         int size = scanlineStride * (h - 1) + // fisrt (h - 1) scans
 262             pixelStride * w; // last scan
 263 
 264         switch(dataType) {
 265         case DataBuffer.TYPE_BYTE:
 266             d = new DataBufferByte(size);
 267             break;
 268 
 269         case DataBuffer.TYPE_USHORT:
 270             d = new DataBufferUShort(size);
 271             break;
 272 
 273         default:
 274             throw new IllegalArgumentException("Unsupported data type " +
 275                                                 dataType);
 276         }
 277 
 278         return createInterleavedRaster(d, w, h, scanlineStride,
 279                                        pixelStride, bandOffsets, location);
 280     }
 281 
 282     /**
 283      * Creates a Raster based on a BandedSampleModel with the
 284      * specified data type, width, height, and number of bands.
 285      *
 286      * <p> The upper left corner of the Raster is given by the
 287      * location argument.  If location is null, (0, 0) will be used.
 288      * The dataType parameter should be one of the enumerated values
 289      * defined in the DataBuffer class.
 290      *
 291      * <p> The only dataTypes supported currently are TYPE_BYTE, TYPE_USHORT,
 292      * and TYPE_INT.
 293      * @param dataType  the data type for storing samples
 294      * @param w         the width in pixels of the image data
 295      * @param h         the height in pixels of the image data
 296      * @param bands     the number of bands
 297      * @param location  the upper-left corner of the {@code Raster}
 298      * @return a WritableRaster object with the specified data type,
 299      *         width, height and number of bands.
 300      * @throws RasterFormatException if {@code w} or {@code h}
 301      *         is less than or equal to zero, or computing either
 302      *         {@code location.x + w} or
 303      *         {@code location.y + h} results in integer
 304      *         overflow
 305      * @throws ArrayIndexOutOfBoundsException if {@code bands}
 306      *         is less than 1
 307      */
 308     public static WritableRaster createBandedRaster(int dataType,
 309                                                     int w, int h,
 310                                                     int bands,
 311                                                     Point location) {
 312         if (bands < 1) {
 313             throw new ArrayIndexOutOfBoundsException("Number of bands ("+
 314                                                      bands+") must"+
 315                                                      " be greater than 0");
 316         }
 317         int[] bankIndices = new int[bands];
 318         int[] bandOffsets = new int[bands];
 319         for (int i = 0; i < bands; i++) {
 320             bankIndices[i] = i;
 321             bandOffsets[i] = 0;
 322         }
 323 
 324         return createBandedRaster(dataType, w, h, w,
 325                                   bankIndices, bandOffsets,
 326                                   location);
 327     }
 328 
 329     /**
 330      * Creates a Raster based on a BandedSampleModel with the
 331      * specified data type, width, height, scanline stride, bank
 332      * indices and band offsets.  The number of bands is inferred from
 333      * bankIndices.length and bandOffsets.length, which must be the
 334      * same.
 335      *
 336      * <p> The upper left corner of the Raster is given by the
 337      * location argument.  The dataType parameter should be one of the
 338      * enumerated values defined in the DataBuffer class.
 339      *
 340      * <p> The only dataTypes supported currently are TYPE_BYTE, TYPE_USHORT,
 341      * and TYPE_INT.
 342      * @param dataType  the data type for storing samples
 343      * @param w         the width in pixels of the image data
 344      * @param h         the height in pixels of the image data
 345      * @param scanlineStride the line stride of the image data
 346      * @param bankIndices the bank indices for each band
 347      * @param bandOffsets the offsets of all bands
 348      * @param location  the upper-left corner of the {@code Raster}
 349      * @return a WritableRaster object with the specified data type,
 350      *         width, height, scanline stride, bank indices and band
 351      *         offsets.
 352      * @throws RasterFormatException if {@code w} or {@code h}
 353      *         is less than or equal to zero, or computing either
 354      *         {@code location.x + w} or
 355      *         {@code location.y + h} results in integer
 356      *         overflow
 357      * @throws IllegalArgumentException if {@code dataType} is not
 358      *         one of the supported data types, which are
 359      *         {@code DataBuffer.TYPE_BYTE},
 360      *         {@code DataBuffer.TYPE_USHORT}
 361      *         or {@code DataBuffer.TYPE_INT}
 362      * @throws ArrayIndexOutOfBoundsException if {@code bankIndices}
 363      *         or {@code bandOffsets} is {@code null}
 364      */
 365     public static WritableRaster createBandedRaster(int dataType,
 366                                                     int w, int h,
 367                                                     int scanlineStride,
 368                                                     int bankIndices[],
 369                                                     int bandOffsets[],
 370                                                     Point location) {
 371         DataBuffer d;
 372         int bands = bandOffsets.length;
 373 
 374         if (bankIndices == null) {
 375             throw new
 376                 ArrayIndexOutOfBoundsException("Bank indices array is null");
 377         }
 378         if (bandOffsets == null) {
 379             throw new
 380                 ArrayIndexOutOfBoundsException("Band offsets array is null");
 381         }
 382 
 383         // Figure out the #banks and the largest band offset
 384         int maxBank = bankIndices[0];
 385         int maxBandOff = bandOffsets[0];
 386         for (int i = 1; i < bands; i++) {
 387             if (bankIndices[i] > maxBank) {
 388                 maxBank = bankIndices[i];
 389             }
 390             if (bandOffsets[i] > maxBandOff) {
 391                 maxBandOff = bandOffsets[i];
 392             }
 393         }
 394         int banks = maxBank + 1;
 395         int size = maxBandOff +
 396             scanlineStride * (h - 1) + // first (h - 1) scans
 397             w; // last scan
 398 
 399         switch(dataType) {
 400         case DataBuffer.TYPE_BYTE:
 401             d = new DataBufferByte(size, banks);
 402             break;
 403 
 404         case DataBuffer.TYPE_USHORT:
 405             d = new DataBufferUShort(size, banks);
 406             break;
 407 
 408         case DataBuffer.TYPE_INT:
 409             d = new DataBufferInt(size, banks);
 410             break;
 411 
 412         default:
 413             throw new IllegalArgumentException("Unsupported data type " +
 414                                                 dataType);
 415         }
 416 
 417         return createBandedRaster(d, w, h, scanlineStride,
 418                                   bankIndices, bandOffsets, location);
 419     }
 420 
 421     /**
 422      * Creates a Raster based on a SinglePixelPackedSampleModel with
 423      * the specified data type, width, height, and band masks.
 424      * The number of bands is inferred from bandMasks.length.
 425      *
 426      * <p> The upper left corner of the Raster is given by the
 427      * location argument.  If location is null, (0, 0) will be used.
 428      * The dataType parameter should be one of the enumerated values
 429      * defined in the DataBuffer class.
 430      *
 431      * <p> The only dataTypes supported currently are TYPE_BYTE, TYPE_USHORT,
 432      * and TYPE_INT.
 433      * @param dataType  the data type for storing samples
 434      * @param w         the width in pixels of the image data
 435      * @param h         the height in pixels of the image data
 436      * @param bandMasks an array containing an entry for each band
 437      * @param location  the upper-left corner of the {@code Raster}
 438      * @return a WritableRaster object with the specified data type,
 439      *         width, height, and band masks.
 440      * @throws RasterFormatException if {@code w} or {@code h}
 441      *         is less than or equal to zero, or computing either
 442      *         {@code location.x + w} or
 443      *         {@code location.y + h} results in integer
 444      *         overflow
 445      * @throws IllegalArgumentException if {@code dataType} is not
 446      *         one of the supported data types, which are
 447      *         {@code DataBuffer.TYPE_BYTE},
 448      *         {@code DataBuffer.TYPE_USHORT}
 449      *         or {@code DataBuffer.TYPE_INT}
 450      */
 451     public static WritableRaster createPackedRaster(int dataType,
 452                                                     int w, int h,
 453                                                     int bandMasks[],
 454                                                     Point location) {
 455         DataBuffer d;
 456 
 457         switch(dataType) {
 458         case DataBuffer.TYPE_BYTE:
 459             d = new DataBufferByte(w*h);
 460             break;
 461 
 462         case DataBuffer.TYPE_USHORT:
 463             d = new DataBufferUShort(w*h);
 464             break;
 465 
 466         case DataBuffer.TYPE_INT:
 467             d = new DataBufferInt(w*h);
 468             break;
 469 
 470         default:
 471             throw new IllegalArgumentException("Unsupported data type " +
 472                                                 dataType);
 473         }
 474 
 475         return createPackedRaster(d, w, h, w, bandMasks, location);
 476     }
 477 
 478     /**
 479      * Creates a Raster based on a packed SampleModel with the
 480      * specified data type, width, height, number of bands, and bits
 481      * per band.  If the number of bands is one, the SampleModel will
 482      * be a MultiPixelPackedSampleModel.
 483      *
 484      * <p> If the number of bands is more than one, the SampleModel
 485      * will be a SinglePixelPackedSampleModel, with each band having
 486      * bitsPerBand bits.  In either case, the requirements on dataType
 487      * and bitsPerBand imposed by the corresponding SampleModel must
 488      * be met.
 489      *
 490      * <p> The upper left corner of the Raster is given by the
 491      * location argument.  If location is null, (0, 0) will be used.
 492      * The dataType parameter should be one of the enumerated values
 493      * defined in the DataBuffer class.
 494      *
 495      * <p> The only dataTypes supported currently are TYPE_BYTE, TYPE_USHORT,
 496      * and TYPE_INT.
 497      * @param dataType  the data type for storing samples
 498      * @param w         the width in pixels of the image data
 499      * @param h         the height in pixels of the image data
 500      * @param bands     the number of bands
 501      * @param bitsPerBand the number of bits per band
 502      * @param location  the upper-left corner of the {@code Raster}
 503      * @return a WritableRaster object with the specified data type,
 504      *         width, height, number of bands, and bits per band.
 505      * @throws RasterFormatException if {@code w} or {@code h}
 506      *         is less than or equal to zero, or computing either
 507      *         {@code location.x + w} or
 508      *         {@code location.y + h} results in integer
 509      *         overflow
 510      * @throws IllegalArgumentException if the product of
 511      *         {@code bitsPerBand} and {@code bands} is
 512      *         greater than the number of bits held by
 513      *         {@code dataType}
 514      * @throws IllegalArgumentException if {@code bitsPerBand} or
 515      *         {@code bands} is not greater than zero
 516      * @throws IllegalArgumentException if {@code dataType} is not
 517      *         one of the supported data types, which are
 518      *         {@code DataBuffer.TYPE_BYTE},
 519      *         {@code DataBuffer.TYPE_USHORT}
 520      *         or {@code DataBuffer.TYPE_INT}
 521      */
 522     public static WritableRaster createPackedRaster(int dataType,
 523                                                     int w, int h,
 524                                                     int bands,
 525                                                     int bitsPerBand,
 526                                                     Point location) {
 527         DataBuffer d;
 528 
 529         if (bands <= 0) {
 530             throw new IllegalArgumentException("Number of bands ("+bands+
 531                                                ") must be greater than 0");
 532         }
 533 
 534         if (bitsPerBand <= 0) {
 535             throw new IllegalArgumentException("Bits per band ("+bitsPerBand+
 536                                                ") must be greater than 0");
 537         }
 538 
 539         if (bands != 1) {
 540             int[] masks = new int[bands];
 541             int mask = (1 << bitsPerBand) - 1;
 542             int shift = (bands-1)*bitsPerBand;
 543 
 544             /* Make sure the total mask size will fit in the data type */
 545             if (shift+bitsPerBand > DataBuffer.getDataTypeSize(dataType)) {
 546                 throw new IllegalArgumentException("bitsPerBand("+
 547                                                    bitsPerBand+") * bands is "+
 548                                                    " greater than data type "+
 549                                                    "size.");
 550             }
 551             switch(dataType) {
 552             case DataBuffer.TYPE_BYTE:
 553             case DataBuffer.TYPE_USHORT:
 554             case DataBuffer.TYPE_INT:
 555                 break;
 556             default:
 557                 throw new IllegalArgumentException("Unsupported data type " +
 558                                                     dataType);
 559             }
 560 
 561             for (int i = 0; i < bands; i++) {
 562                 masks[i] = mask << shift;
 563                 shift = shift - bitsPerBand;
 564             }
 565 
 566             return createPackedRaster(dataType, w, h, masks, location);
 567         }
 568         else {
 569             double fw = w;
 570             switch(dataType) {
 571             case DataBuffer.TYPE_BYTE:
 572                 d = new DataBufferByte((int)(Math.ceil(fw/(8/bitsPerBand)))*h);
 573                 break;
 574 
 575             case DataBuffer.TYPE_USHORT:
 576                 d = new DataBufferUShort((int)(Math.ceil(fw/(16/bitsPerBand)))*h);
 577                 break;
 578 
 579             case DataBuffer.TYPE_INT:
 580                 d = new DataBufferInt((int)(Math.ceil(fw/(32/bitsPerBand)))*h);
 581                 break;
 582 
 583             default:
 584                 throw new IllegalArgumentException("Unsupported data type " +
 585                                                    dataType);
 586             }
 587 
 588             return createPackedRaster(d, w, h, bitsPerBand, location);
 589         }
 590     }
 591 
 592     /**
 593      * Creates a Raster based on a PixelInterleavedSampleModel with the
 594      * specified DataBuffer, width, height, scanline stride, pixel
 595      * stride, and band offsets.  The number of bands is inferred from
 596      * bandOffsets.length.  The upper left corner of the Raster
 597      * is given by the location argument.  If location is null, (0, 0)
 598      * will be used.
 599      * <p> Note that interleaved {@code DataBuffer.TYPE_INT}
 600      * Rasters are not supported.  To create a 1-band Raster of type
 601      * {@code DataBuffer.TYPE_INT}, use
 602      * Raster.createPackedRaster().
 603      * @param dataBuffer the {@code DataBuffer} that contains the
 604      *        image data
 605      * @param w         the width in pixels of the image data
 606      * @param h         the height in pixels of the image data
 607      * @param scanlineStride the line stride of the image data
 608      * @param pixelStride the pixel stride of the image data
 609      * @param bandOffsets the offsets of all bands
 610      * @param location  the upper-left corner of the {@code Raster}
 611      * @return a WritableRaster object with the specified
 612      *         {@code DataBuffer}, width, height, scanline stride,
 613      *         pixel stride and band offsets.
 614      * @throws RasterFormatException if {@code w} or {@code h}
 615      *         is less than or equal to zero, or computing either
 616      *         {@code location.x + w} or
 617      *         {@code location.y + h} results in integer
 618      *         overflow
 619      * @throws IllegalArgumentException if {@code dataType} is not
 620      *         one of the supported data types, which are
 621      *         {@code DataBuffer.TYPE_BYTE},
 622      *         {@code DataBuffer.TYPE_USHORT}
 623      * @throws RasterFormatException if {@code dataBuffer} has more
 624      *         than one bank.
 625      * @throws NullPointerException if {@code dataBuffer} is null
 626      */
 627     public static WritableRaster createInterleavedRaster(DataBuffer dataBuffer,
 628                                                          int w, int h,
 629                                                          int scanlineStride,
 630                                                          int pixelStride,
 631                                                          int bandOffsets[],
 632                                                          Point location) {
 633         if (dataBuffer == null) {
 634             throw new NullPointerException("DataBuffer cannot be null");
 635         }
 636         if (location == null) {
 637             location = new Point(0, 0);
 638         }
 639         int dataType = dataBuffer.getDataType();
 640 
 641         PixelInterleavedSampleModel csm =
 642             new PixelInterleavedSampleModel(dataType, w, h,
 643                                             pixelStride,
 644                                             scanlineStride,
 645                                             bandOffsets);
 646         switch(dataType) {
 647         case DataBuffer.TYPE_BYTE:
 648             if (dataBuffer instanceof DataBufferByte) {
 649                 return new ByteInterleavedRaster(csm, 
 650                         (DataBufferByte)dataBuffer, location);
 651             }
 652             break;
 653 
 654         case DataBuffer.TYPE_USHORT:
 655             if (dataBuffer instanceof DataBufferUShort) {
 656                 return new ShortInterleavedRaster(csm,
 657                         (DataBufferUShort)dataBuffer, location);
 658             }
 659             break;
 660 
 661         default:
 662             throw new IllegalArgumentException("Unsupported data type " +
 663                                                 dataType);
 664         }
 665         
 666         // Create the generic raster
 667         return new SunWritableRaster(csm, dataBuffer, location);
 668     }
 669 
 670     /**
 671      * Creates a Raster based on a BandedSampleModel with the
 672      * specified DataBuffer, width, height, scanline stride, bank
 673      * indices, and band offsets.  The number of bands is inferred
 674      * from bankIndices.length and bandOffsets.length, which must be
 675      * the same.  The upper left corner of the Raster is given by the
 676      * location argument.  If location is null, (0, 0) will be used.
 677      * @param dataBuffer the {@code DataBuffer} that contains the
 678      *        image data
 679      * @param w         the width in pixels of the image data
 680      * @param h         the height in pixels of the image data
 681      * @param scanlineStride the line stride of the image data
 682      * @param bankIndices the bank indices for each band
 683      * @param bandOffsets the offsets of all bands
 684      * @param location  the upper-left corner of the {@code Raster}
 685      * @return a WritableRaster object with the specified
 686      *         {@code DataBuffer}, width, height, scanline stride,
 687      *         bank indices and band offsets.
 688      * @throws RasterFormatException if {@code w} or {@code h}
 689      *         is less than or equal to zero, or computing either
 690      *         {@code location.x + w} or
 691      *         {@code location.y + h} results in integer
 692      *         overflow
 693      * @throws IllegalArgumentException if {@code dataType} is not
 694      *         one of the supported data types, which are
 695      *         {@code DataBuffer.TYPE_BYTE},
 696      *         {@code DataBuffer.TYPE_USHORT}
 697      *         or {@code DataBuffer.TYPE_INT}
 698      * @throws NullPointerException if {@code dataBuffer} is null
 699      */
 700     public static WritableRaster createBandedRaster(DataBuffer dataBuffer,
 701                                                     int w, int h,
 702                                                     int scanlineStride,
 703                                                     int bankIndices[],
 704                                                     int bandOffsets[],
 705                                                     Point location) {
 706         if (dataBuffer == null) {
 707             throw new NullPointerException("DataBuffer cannot be null");
 708         }
 709         if (location == null) {
 710            location = new Point(0,0);
 711         }
 712         int dataType = dataBuffer.getDataType();
 713 
 714         int bands = bankIndices.length;
 715         if (bandOffsets.length != bands) {
 716             throw new IllegalArgumentException(
 717                                    "bankIndices.length != bandOffsets.length");
 718         }
 719 
 720         BandedSampleModel bsm =
 721             new BandedSampleModel(dataType, w, h,
 722                                   scanlineStride,
 723                                   bankIndices, bandOffsets);
 724 
 725         switch(dataType) {
 726         case DataBuffer.TYPE_BYTE:
 727             if (dataBuffer instanceof DataBufferByte) {
 728                 return new ByteBandedRaster(bsm, 
 729                         (DataBufferByte)dataBuffer, location);
 730             }
 731             break;
 732 
 733         case DataBuffer.TYPE_USHORT:
 734             if (dataBuffer instanceof DataBufferUShort) {
 735                 return new ShortBandedRaster(bsm,
 736                         (DataBufferUShort)dataBuffer, location);
 737             }
 738             break;
 739 
 740         case DataBuffer.TYPE_INT:
 741             if (dataBuffer instanceof DataBufferInt) {
 742                 return new SunWritableRaster(bsm, 
 743                         (DataBufferInt)dataBuffer, location);
 744             }
 745             break;
 746 
 747         default:
 748             throw new IllegalArgumentException("Unsupported data type " +
 749                                                 dataType);
 750         }
 751         
 752         // Create the generic raster
 753         return new SunWritableRaster(bsm, dataBuffer, location);
 754     }
 755 
 756     /**
 757      * Creates a Raster based on a SinglePixelPackedSampleModel with
 758      * the specified DataBuffer, width, height, scanline stride, and
 759      * band masks.  The number of bands is inferred from bandMasks.length.
 760      * The upper left corner of the Raster is given by
 761      * the location argument.  If location is null, (0, 0) will be used.
 762      * @param dataBuffer the {@code DataBuffer} that contains the
 763      *        image data
 764      * @param w         the width in pixels of the image data
 765      * @param h         the height in pixels of the image data
 766      * @param scanlineStride the line stride of the image data
 767      * @param bandMasks an array containing an entry for each band
 768      * @param location  the upper-left corner of the {@code Raster}
 769      * @return a WritableRaster object with the specified
 770      *         {@code DataBuffer}, width, height, scanline stride,
 771      *         and band masks.
 772      * @throws RasterFormatException if {@code w} or {@code h}
 773      *         is less than or equal to zero, or computing either
 774      *         {@code location.x + w} or
 775      *         {@code location.y + h} results in integer
 776      *         overflow
 777      * @throws IllegalArgumentException if {@code dataType} is not
 778      *         one of the supported data types, which are
 779      *         {@code DataBuffer.TYPE_BYTE},
 780      *         {@code DataBuffer.TYPE_USHORT}
 781      *         or {@code DataBuffer.TYPE_INT}
 782      * @throws RasterFormatException if {@code dataBuffer} has more
 783      *         than one bank.
 784      * @throws NullPointerException if {@code dataBuffer} is null
 785      */
 786     public static WritableRaster createPackedRaster(DataBuffer dataBuffer,
 787                                                     int w, int h,
 788                                                     int scanlineStride,
 789                                                     int bandMasks[],
 790                                                     Point location) {
 791         if (dataBuffer == null) {
 792             throw new NullPointerException("DataBuffer cannot be null");
 793         }
 794         if (location == null) {
 795            location = new Point(0,0);
 796         }
 797         int dataType = dataBuffer.getDataType();
 798 
 799         SinglePixelPackedSampleModel sppsm =
 800             new SinglePixelPackedSampleModel(dataType, w, h, scanlineStride,
 801                                              bandMasks);
 802 
 803         switch(dataType) {
 804         case DataBuffer.TYPE_BYTE:
 805             if (dataBuffer instanceof DataBufferByte) {
 806                 return new ByteInterleavedRaster(sppsm,
 807                         (DataBufferByte)dataBuffer, location);
 808             }
 809             break;
 810 
 811         case DataBuffer.TYPE_USHORT:
 812             if (dataBuffer instanceof DataBufferUShort) {
 813                 return new ShortInterleavedRaster(sppsm,
 814                         (DataBufferUShort)dataBuffer, location);
 815             }
 816             break;
 817 
 818         case DataBuffer.TYPE_INT:
 819             if (dataBuffer instanceof DataBufferInt) {
 820                 return new IntegerInterleavedRaster(sppsm,
 821                         (DataBufferInt)dataBuffer, location);
 822             }
 823             break;
 824 
 825         default:
 826             throw new IllegalArgumentException("Unsupported data type " +
 827                                                 dataType);
 828         }
 829         
 830         // Create the generic raster
 831         return new SunWritableRaster(sppsm, dataBuffer, location);
 832     }
 833 
 834     /**
 835      * Creates a Raster based on a MultiPixelPackedSampleModel with the
 836      * specified DataBuffer, width, height, and bits per pixel.  The upper
 837      * left corner of the Raster is given by the location argument.  If
 838      * location is null, (0, 0) will be used.
 839      * @param dataBuffer the {@code DataBuffer} that contains the
 840      *        image data
 841      * @param w         the width in pixels of the image data
 842      * @param h         the height in pixels of the image data
 843      * @param bitsPerPixel the number of bits for each pixel
 844      * @param location  the upper-left corner of the {@code Raster}
 845      * @return a WritableRaster object with the specified
 846      *         {@code DataBuffer}, width, height, and
 847      *         bits per pixel.
 848      * @throws RasterFormatException if {@code w} or {@code h}
 849      *         is less than or equal to zero, or computing either
 850      *         {@code location.x + w} or
 851      *         {@code location.y + h} results in integer
 852      *         overflow
 853      * @throws IllegalArgumentException if {@code dataType} is not
 854      *         one of the supported data types, which are
 855      *         {@code DataBuffer.TYPE_BYTE},
 856      *         {@code DataBuffer.TYPE_USHORT}
 857      *         or {@code DataBuffer.TYPE_INT}
 858      * @throws RasterFormatException if {@code dataBuffer} has more
 859      *         than one bank.
 860      * @throws NullPointerException if {@code dataBuffer} is null
 861      */
 862     public static WritableRaster createPackedRaster(DataBuffer dataBuffer,
 863                                                     int w, int h,
 864                                                     int bitsPerPixel,
 865                                                     Point location) {
 866         if (dataBuffer == null) {
 867             throw new NullPointerException("DataBuffer cannot be null");
 868         }
 869         if (location == null) {
 870            location = new Point(0,0);
 871         }
 872         int dataType = dataBuffer.getDataType();
 873 
 874         if (dataType != DataBuffer.TYPE_BYTE &&
 875             dataType != DataBuffer.TYPE_USHORT &&
 876             dataType != DataBuffer.TYPE_INT) {
 877             throw new IllegalArgumentException("Unsupported data type " +
 878                                                dataType);
 879         }
 880 
 881         if (dataBuffer.getNumBanks() != 1) {
 882             throw new
 883                 RasterFormatException("DataBuffer for packed Rasters"+
 884                                       " must only have 1 bank.");
 885         }
 886 
 887         MultiPixelPackedSampleModel mppsm =
 888                 new MultiPixelPackedSampleModel(dataType, w, h, bitsPerPixel);
 889 
 890         if (dataBuffer instanceof DataBufferByte &&
 891             (bitsPerPixel == 1 || bitsPerPixel == 2 || bitsPerPixel == 4)) {
 892             return new BytePackedRaster(mppsm, (DataBufferByte)dataBuffer, location);
 893         } else {
 894             return new SunWritableRaster(mppsm, dataBuffer, location);
 895         }
 896     }
 897 
 898 
 899     /**
 900      *  Creates a Raster with the specified SampleModel and DataBuffer.
 901      *  The upper left corner of the Raster is given by the location argument.
 902      *  If location is null, (0, 0) will be used.
 903      *  @param sm the specified {@code SampleModel}
 904      *  @param db the specified {@code DataBuffer}
 905      *  @param location the upper-left corner of the {@code Raster}
 906      *  @return a {@code Raster} with the specified
 907      *          {@code SampleModel}, {@code DataBuffer}, and
 908      *          location.
 909      * @throws RasterFormatException if computing either
 910      *         {@code location.x + sm.getWidth()} or
 911      *         {@code location.y + sm.getHeight()} results in integer
 912      *         overflow
 913      * @throws RasterFormatException if {@code db} has more
 914      *         than one bank and {@code sm} is a
 915      *         PixelInterleavedSampleModel, SinglePixelPackedSampleModel,
 916      *         or MultiPixelPackedSampleModel.
 917      *  @throws NullPointerException if either SampleModel or DataBuffer is
 918      *          null
 919      */
 920     public static Raster createRaster(SampleModel sm,
 921                                       DataBuffer db,
 922                                       Point location) {
 923         if ((sm == null) || (db == null)) {
 924             throw new NullPointerException("SampleModel and DataBuffer cannot be null");
 925         }
 926 
 927         if (location == null) {
 928            location = new Point(0,0);
 929         }
 930         int dataType = sm.getDataType();
 931 
 932         if (sm instanceof PixelInterleavedSampleModel) {
 933             switch(dataType) {
 934             case DataBuffer.TYPE_BYTE:
 935                 if (db instanceof DataBufferByte) {
 936                     return new ByteInterleavedRaster(sm, 
 937                             (DataBufferByte)db, location);
 938                 }
 939                 break;
 940 
 941             case DataBuffer.TYPE_USHORT:
 942                 if (db instanceof DataBufferUShort) {
 943                     return new ShortInterleavedRaster(sm, 
 944                             (DataBufferUShort)db, location);
 945                 }
 946                 break;
 947             }
 948         } else if (sm instanceof SinglePixelPackedSampleModel) {
 949             switch(dataType) {
 950             case DataBuffer.TYPE_BYTE:
 951                 if (db instanceof DataBufferByte) {
 952                     return new ByteInterleavedRaster(sm, 
 953                             (DataBufferByte)db, location);
 954                 }
 955                 break;
 956 
 957             case DataBuffer.TYPE_USHORT:
 958                 if (db instanceof DataBufferUShort) {
 959                     return new ShortInterleavedRaster(sm, 
 960                             (DataBufferUShort)db, location);
 961                 }
 962                 break;
 963 
 964             case DataBuffer.TYPE_INT:
 965                 if (db instanceof DataBufferInt) {
 966                     return new IntegerInterleavedRaster(sm, 
 967                             (DataBufferInt)db, location);
 968                 }
 969                 break;
 970             }
 971         } else if (sm instanceof MultiPixelPackedSampleModel &&
 972                    dataType == DataBuffer.TYPE_BYTE &&
 973                    db instanceof DataBufferByte &&
 974                    sm.getSampleSize(0) < 8) {
 975             return new BytePackedRaster(sm, (DataBufferByte)db, location);
 976         }
 977 
 978         // we couldn't do anything special - do the generic thing
 979         return new Raster(sm, db, location);

 980     }
 981 
 982     /**
 983      *  Creates a WritableRaster with the specified SampleModel.
 984      *  The upper left corner of the Raster is given by the location argument.
 985      *  If location is null, (0, 0) will be used.
 986      *  @param sm the specified {@code SampleModel}
 987      *  @param location the upper-left corner of the
 988      *         {@code WritableRaster}
 989      *  @return a {@code WritableRaster} with the specified
 990      *          {@code SampleModel} and location.
 991      *  @throws RasterFormatException if computing either
 992      *          {@code location.x + sm.getWidth()} or
 993      *          {@code location.y + sm.getHeight()} results in integer
 994      *          overflow
 995      */
 996     public static WritableRaster createWritableRaster(SampleModel sm,
 997                                                       Point location) {
 998         if (location == null) {
 999            location = new Point(0,0);
1000         }
1001 
1002         return createWritableRaster(sm, sm.createDataBuffer(), location);
1003     }
1004 
1005     /**
1006      *  Creates a WritableRaster with the specified SampleModel and DataBuffer.
1007      *  The upper left corner of the Raster is given by the location argument.
1008      *  If location is null, (0, 0) will be used.
1009      *  @param sm the specified {@code SampleModel}
1010      *  @param db the specified {@code DataBuffer}
1011      *  @param location the upper-left corner of the
1012      *         {@code WritableRaster}
1013      *  @return a {@code WritableRaster} with the specified
1014      *          {@code SampleModel}, {@code DataBuffer}, and
1015      *          location.
1016      * @throws RasterFormatException if computing either
1017      *         {@code location.x + sm.getWidth()} or
1018      *         {@code location.y + sm.getHeight()} results in integer
1019      *         overflow
1020      * @throws RasterFormatException if {@code db} has more
1021      *         than one bank and {@code sm} is a
1022      *         PixelInterleavedSampleModel, SinglePixelPackedSampleModel,
1023      *         or MultiPixelPackedSampleModel.
1024      * @throws NullPointerException if either SampleModel or DataBuffer is null
1025      */
1026     public static WritableRaster createWritableRaster(SampleModel sm,
1027                                                       DataBuffer db,
1028                                                       Point location) {
1029         if ((sm == null) || (db == null)) {
1030             throw new NullPointerException("SampleModel and DataBuffer cannot be null");
1031         }
1032         if (location == null) {
1033            location = new Point(0,0);
1034         }
1035 
1036         int dataType = sm.getDataType();
1037 
1038         if (sm instanceof PixelInterleavedSampleModel) {
1039             switch(dataType) {
1040             case DataBuffer.TYPE_BYTE:
1041                 if (db instanceof DataBufferByte) {
1042                     return new ByteInterleavedRaster(sm,
1043                             (DataBufferByte)db, location);
1044                 }
1045                 break;
1046 
1047             case DataBuffer.TYPE_USHORT:
1048                 if (db instanceof DataBufferUShort) {
1049                     return new ShortInterleavedRaster(sm,
1050                             (DataBufferUShort)db, location);
1051                 }
1052                 break;
1053             }
1054         } else if (sm instanceof SinglePixelPackedSampleModel) {
1055             switch(dataType) {
1056             case DataBuffer.TYPE_BYTE:
1057                 if (db instanceof DataBufferByte) {
1058                     return new ByteInterleavedRaster(sm,
1059                             (DataBufferByte)db, location);
1060                 }
1061                 break;
1062 
1063             case DataBuffer.TYPE_USHORT:
1064                 if (db instanceof DataBufferUShort) {
1065                     return new ShortInterleavedRaster(sm, 
1066                             (DataBufferUShort)db, location);
1067                 }
1068                 break;
1069 
1070             case DataBuffer.TYPE_INT:
1071                 if (db instanceof DataBufferInt) {
1072                     return new IntegerInterleavedRaster(sm,
1073                             (DataBufferInt)db, location);
1074                 }
1075                 break;
1076             }
1077         } else if (sm instanceof MultiPixelPackedSampleModel &&
1078                    dataType == DataBuffer.TYPE_BYTE &&
1079                    db instanceof DataBufferByte &&
1080                    sm.getSampleSize(0) < 8) {
1081             return new BytePackedRaster(sm, (DataBufferByte)db, location);
1082         }
1083 
1084         // we couldn't do anything special - do the generic thing

1085         return new SunWritableRaster(sm,db,location);
1086     }
1087 
1088     /**
1089      *  Constructs a Raster with the given SampleModel.  The Raster's
1090      *  upper left corner is origin and it is the same size as the
1091      *  SampleModel.  A DataBuffer large enough to describe the
1092      *  Raster is automatically created.
1093      *  @param sampleModel     The SampleModel that specifies the layout
1094      *  @param origin          The Point that specified the origin
1095      *  @throws RasterFormatException if computing either
1096      *          {@code origin.x + sampleModel.getWidth()} or
1097      *          {@code origin.y + sampleModel.getHeight()} results in
1098      *          integer overflow
1099      *  @throws NullPointerException either {@code sampleModel} or
1100      *          {@code origin} is null
1101      */
1102     protected Raster(SampleModel sampleModel,
1103                      Point origin) {
1104         this(sampleModel,
1105              sampleModel.createDataBuffer(),
1106              new Rectangle(origin.x,
1107                            origin.y,
1108                            sampleModel.getWidth(),
1109                            sampleModel.getHeight()),
1110              origin,
1111              null);
1112     }
1113 
1114     /**
1115      *  Constructs a Raster with the given SampleModel and DataBuffer.
1116      *  The Raster's upper left corner is origin and it is the same size
1117      *  as the SampleModel.  The DataBuffer is not initialized and must
1118      *  be compatible with SampleModel.
1119      *  @param sampleModel     The SampleModel that specifies the layout
1120      *  @param dataBuffer      The DataBuffer that contains the image data
1121      *  @param origin          The Point that specifies the origin
1122      *  @throws RasterFormatException if computing either
1123      *          {@code origin.x + sampleModel.getWidth()} or
1124      *          {@code origin.y + sampleModel.getHeight()} results in
1125      *          integer overflow
1126      *  @throws NullPointerException either {@code sampleModel} or
1127      *          {@code origin} is null
1128      */
1129     protected Raster(SampleModel sampleModel,
1130                      DataBuffer dataBuffer,
1131                      Point origin) {
1132         this(sampleModel,
1133              dataBuffer,
1134              new Rectangle(origin.x,
1135                            origin.y,
1136                            sampleModel.getWidth(),
1137                            sampleModel.getHeight()),
1138              origin,
1139              null);
1140     }
1141 
1142     /**
1143      * Constructs a Raster with the given SampleModel, DataBuffer, and
1144      * parent.  aRegion specifies the bounding rectangle of the new
1145      * Raster.  When translated into the base Raster's coordinate
1146      * system, aRegion must be contained by the base Raster.
1147      * (The base Raster is the Raster's ancestor which has no parent.)
1148      * sampleModelTranslate specifies the sampleModelTranslateX and
1149      * sampleModelTranslateY values of the new Raster.
1150      *
1151      * Note that this constructor should generally be called by other
1152      * constructors or create methods, it should not be used directly.
1153      * @param sampleModel     The SampleModel that specifies the layout
1154      * @param dataBuffer      The DataBuffer that contains the image data
1155      * @param aRegion         The Rectangle that specifies the image area
1156      * @param sampleModelTranslate  The Point that specifies the translation
1157      *                        from SampleModel to Raster coordinates
1158      * @param parent          The parent (if any) of this raster
1159      * @throws NullPointerException if any of {@code sampleModel},
1160      *         {@code dataBuffer}, {@code aRegion} or
1161      *         {@code sampleModelTranslate} is null
1162      * @throws RasterFormatException if {@code aRegion} has width
1163      *         or height less than or equal to zero, or computing either
1164      *         {@code aRegion.x + aRegion.width} or
1165      *         {@code aRegion.y + aRegion.height} results in integer
1166      *         overflow
1167      */
1168     protected Raster(SampleModel sampleModel,
1169                      DataBuffer dataBuffer,
1170                      Rectangle aRegion,
1171                      Point sampleModelTranslate,
1172                      Raster parent) {
1173 
1174         if ((sampleModel == null) || (dataBuffer == null) ||
1175             (aRegion == null) || (sampleModelTranslate == null)) {
1176             throw new NullPointerException("SampleModel, dataBuffer, aRegion and " +
1177                                            "sampleModelTranslate cannot be null");
1178         }
1179        this.sampleModel = sampleModel;
1180        this.dataBuffer = dataBuffer;
1181        minX = aRegion.x;
1182        minY = aRegion.y;
1183        width = aRegion.width;
1184        height = aRegion.height;
1185        if (width <= 0 || height <= 0) {
1186            throw new RasterFormatException("negative or zero " +
1187                ((width <= 0) ? "width" : "height"));
1188        }
1189        if ((minX + width) < minX) {
1190            throw new RasterFormatException(
1191                "overflow condition for X coordinates of Raster");
1192        }
1193        if ((minY + height) < minY) {
1194            throw new RasterFormatException(
1195                "overflow condition for Y coordinates of Raster");
1196        }
1197 
1198        sampleModelTranslateX = sampleModelTranslate.x;
1199        sampleModelTranslateY = sampleModelTranslate.y;
1200 
1201        numBands = sampleModel.getNumBands();
1202        numDataElements = sampleModel.getNumDataElements();
1203        this.parent = parent;
1204     }
1205 
1206 
1207     /**
1208      * Returns the parent Raster (if any) of this Raster or null.
1209      * @return the parent Raster or {@code null}.
1210      */
1211     public Raster getParent() {
1212         return parent;
1213     }
1214 
1215     /**
1216      * Returns the X translation from the coordinate system of the
1217      * SampleModel to that of the Raster.  To convert a pixel's X
1218      * coordinate from the Raster coordinate system to the SampleModel
1219      * coordinate system, this value must be subtracted.
1220      * @return the X translation from the coordinate space of the
1221      *         Raster's SampleModel to that of the Raster.
1222      */
1223     public final int getSampleModelTranslateX() {
1224         return sampleModelTranslateX;
1225     }
1226 
1227     /**
1228      * Returns the Y translation from the coordinate system of the
1229      * SampleModel to that of the Raster.  To convert a pixel's Y
1230      * coordinate from the Raster coordinate system to the SampleModel
1231      * coordinate system, this value must be subtracted.
1232      * @return the Y translation from the coordinate space of the
1233      *         Raster's SampleModel to that of the Raster.
1234      */
1235     public final int getSampleModelTranslateY() {
1236         return sampleModelTranslateY;
1237     }
1238 
1239     /**
1240      * Create a compatible WritableRaster the same size as this Raster with
1241      * the same SampleModel and a new initialized DataBuffer.
1242      * @return a compatible {@code WritableRaster} with the same sample
1243      *         model and a new data buffer.
1244      */
1245     public WritableRaster createCompatibleWritableRaster() {
1246         return new SunWritableRaster(sampleModel, new Point(0,0));
1247     }
1248 
1249     /**
1250      * Create a compatible WritableRaster with the specified size, a new
1251      * SampleModel, and a new initialized DataBuffer.
1252      * @param w the specified width of the new {@code WritableRaster}
1253      * @param h the specified height of the new {@code WritableRaster}
1254      * @return a compatible {@code WritableRaster} with the specified
1255      *         size and a new sample model and data buffer.
1256      * @exception RasterFormatException if the width or height is less than
1257      *                               or equal to zero.
1258      */
1259     public WritableRaster createCompatibleWritableRaster(int w, int h) {
1260         if (w <= 0 || h <=0) {
1261             throw new RasterFormatException("negative " +
1262                                           ((w <= 0) ? "width" : "height"));
1263         }
1264 
1265         SampleModel sm = sampleModel.createCompatibleSampleModel(w,h);
1266 
1267         return new SunWritableRaster(sm, new Point(0,0));
1268     }
1269 
1270     /**
1271      * Create a compatible WritableRaster with location (minX, minY)
1272      * and size (width, height) specified by rect, a
1273      * new SampleModel, and a new initialized DataBuffer.
1274      * @param rect a {@code Rectangle} that specifies the size and
1275      *        location of the {@code WritableRaster}
1276      * @return a compatible {@code WritableRaster} with the specified
1277      *         size and location and a new sample model and data buffer.
1278      * @throws RasterFormatException if {@code rect} has width
1279      *         or height less than or equal to zero, or computing either
1280      *         {@code rect.x + rect.width} or
1281      *         {@code rect.y + rect.height} results in integer
1282      *         overflow
1283      * @throws NullPointerException if {@code rect} is null
1284      */
1285     public WritableRaster createCompatibleWritableRaster(Rectangle rect) {
1286         if (rect == null) {
1287             throw new NullPointerException("Rect cannot be null");
1288         }
1289         return createCompatibleWritableRaster(rect.x, rect.y,
1290                                               rect.width, rect.height);
1291     }
1292 
1293     /**
1294      * Create a compatible WritableRaster with the specified
1295      * location (minX, minY) and size (width, height), a
1296      * new SampleModel, and a new initialized DataBuffer.
1297      * @param x the X coordinate of the upper-left corner of
1298      *        the {@code WritableRaster}
1299      * @param y the Y coordinate of the upper-left corner of
1300      *        the {@code WritableRaster}
1301      * @param w the specified width of the {@code WritableRaster}
1302      * @param h the specified height of the {@code WritableRaster}
1303      * @return a compatible {@code WritableRaster} with the specified
1304      *         size and location and a new sample model and data buffer.
1305      * @throws RasterFormatException if {@code w} or {@code h}
1306      *         is less than or equal to zero, or computing either
1307      *         {@code x + w} or
1308      *         {@code y + h} results in integer
1309      *         overflow
1310      */
1311     public WritableRaster createCompatibleWritableRaster(int x, int y,
1312                                                          int w, int h) {
1313         WritableRaster ret = createCompatibleWritableRaster(w, h);
1314         return ret.createWritableChild(0,0,w,h,x,y,null);
1315     }
1316 
1317     /**
1318      * Create a Raster with the same size, SampleModel and DataBuffer
1319      * as this one, but with a different location.  The new Raster
1320      * will possess a reference to the current Raster, accessible
1321      * through its getParent() method.
1322      *
1323      * @param childMinX the X coordinate of the upper-left
1324      *        corner of the new {@code Raster}
1325      * @param childMinY the Y coordinate of the upper-left
1326      *        corner of the new {@code Raster}
1327      * @return a new {@code Raster} with the same size, SampleModel,
1328      *         and DataBuffer as this {@code Raster}, but with the
1329      *         specified location.
1330      * @throws RasterFormatException if  computing either
1331      *         {@code childMinX + this.getWidth()} or
1332      *         {@code childMinY + this.getHeight()} results in integer
1333      *         overflow
1334      */
1335     public Raster createTranslatedChild(int childMinX, int childMinY) {
1336         return createChild(minX,minY,width,height,
1337                            childMinX,childMinY,null);
1338     }
1339 
1340     /**
1341      * Returns a new Raster which shares all or part of this Raster's
1342      * DataBuffer.  The new Raster will possess a reference to the
1343      * current Raster, accessible through its getParent() method.
1344      *
1345      * <p> The parentX, parentY, width and height parameters
1346      * form a Rectangle in this Raster's coordinate space,
1347      * indicating the area of pixels to be shared.  An error will
1348      * be thrown if this Rectangle is not contained with the bounds
1349      * of the current Raster.
1350      *
1351      * <p> The new Raster may additionally be translated to a
1352      * different coordinate system for the plane than that used by the current
1353      * Raster.  The childMinX and childMinY parameters give the new
1354      * (x, y) coordinate of the upper-left pixel of the returned
1355      * Raster; the coordinate (childMinX, childMinY) in the new Raster
1356      * will map to the same pixel as the coordinate (parentX, parentY)
1357      * in the current Raster.
1358      *
1359      * <p> The new Raster may be defined to contain only a subset of
1360      * the bands of the current Raster, possibly reordered, by means
1361      * of the bandList parameter.  If bandList is null, it is taken to
1362      * include all of the bands of the current Raster in their current
1363      * order.
1364      *
1365      * <p> To create a new Raster that contains a subregion of the current
1366      * Raster, but shares its coordinate system and bands,
1367      * this method should be called with childMinX equal to parentX,
1368      * childMinY equal to parentY, and bandList equal to null.
1369      *
1370      * @param parentX The X coordinate of the upper-left corner
1371      *        in this Raster's coordinates
1372      * @param parentY The Y coordinate of the upper-left corner
1373      *        in this Raster's coordinates
1374      * @param width      Width of the region starting at (parentX, parentY)
1375      * @param height     Height of the region starting at (parentX, parentY).
1376      * @param childMinX The X coordinate of the upper-left corner
1377      *                   of the returned Raster
1378      * @param childMinY The Y coordinate of the upper-left corner
1379      *                   of the returned Raster
1380      * @param bandList   Array of band indices, or null to use all bands
1381      * @return a new {@code Raster}.
1382      * @exception RasterFormatException if the specified subregion is outside
1383      *                               of the raster bounds.
1384      * @throws RasterFormatException if {@code width} or
1385      *         {@code height}
1386      *         is less than or equal to zero, or computing any of
1387      *         {@code parentX + width}, {@code parentY + height},
1388      *         {@code childMinX + width}, or
1389      *         {@code childMinY + height} results in integer
1390      *         overflow
1391      */
1392     public Raster createChild(int parentX, int parentY,
1393                               int width, int height,
1394                               int childMinX, int childMinY,
1395                               int bandList[]) {
1396         if (parentX < this.minX) {
1397             throw new RasterFormatException("parentX lies outside raster");
1398         }
1399         if (parentY < this.minY) {
1400             throw new RasterFormatException("parentY lies outside raster");
1401         }
1402         if ((parentX + width < parentX) ||
1403             (parentX + width > this.width + this.minX)) {
1404             throw new RasterFormatException("(parentX + width) is outside raster");
1405         }
1406         if ((parentY + height < parentY) ||
1407             (parentY + height > this.height + this.minY)) {
1408             throw new RasterFormatException("(parentY + height) is outside raster");
1409         }
1410 
1411         SampleModel subSampleModel;
1412         // Note: the SampleModel for the child Raster should have the same
1413         // width and height as that for the parent, since it represents
1414         // the physical layout of the pixel data.  The child Raster's width
1415         // and height represent a "virtual" view of the pixel data, so
1416         // they may be different than those of the SampleModel.
1417         if (bandList == null) {
1418             subSampleModel = sampleModel;
1419         } else {
1420             subSampleModel = sampleModel.createSubsetSampleModel(bandList);
1421         }
1422 
1423         int deltaX = childMinX - parentX;
1424         int deltaY = childMinY - parentY;
1425 
1426         return new Raster(subSampleModel, getDataBuffer(),
1427                           new Rectangle(childMinX, childMinY, width, height),
1428                           new Point(sampleModelTranslateX + deltaX,
1429                                     sampleModelTranslateY + deltaY), this);
1430     }
1431 
1432     /**
1433      * Returns the bounding Rectangle of this Raster. This function returns
1434      * the same information as getMinX/MinY/Width/Height.
1435      * @return the bounding box of this {@code Raster}.
1436      */
1437     public Rectangle getBounds() {
1438         return new Rectangle(minX, minY, width, height);
1439     }
1440 
1441     /** Returns the minimum valid X coordinate of the Raster.
1442      *  @return the minimum x coordinate of this {@code Raster}.
1443      */
1444     public final int getMinX() {
1445         return minX;
1446     }
1447 
1448     /** Returns the minimum valid Y coordinate of the Raster.
1449      *  @return the minimum y coordinate of this {@code Raster}.
1450      */
1451     public final int getMinY() {
1452         return minY;
1453     }
1454 
1455     /** Returns the width in pixels of the Raster.
1456      *  @return the width of this {@code Raster}.
1457      */
1458     public final int getWidth() {
1459         return width;
1460     }
1461 
1462     /** Returns the height in pixels of the Raster.
1463      *  @return the height of this {@code Raster}.
1464      */
1465     public final int getHeight() {
1466         return height;
1467     }
1468 
1469     /** Returns the number of bands (samples per pixel) in this Raster.
1470      *  @return the number of bands of this {@code Raster}.
1471      */
1472     public final int getNumBands() {
1473         return numBands;
1474     }
1475 
1476     /**
1477      *  Returns the number of data elements needed to transfer one pixel
1478      *  via the getDataElements and setDataElements methods.  When pixels
1479      *  are transferred via these methods, they may be transferred in a
1480      *  packed or unpacked format, depending on the implementation of the
1481      *  underlying SampleModel.  Using these methods, pixels are transferred
1482      *  as an array of getNumDataElements() elements of a primitive type given
1483      *  by getTransferType().  The TransferType may or may not be the same
1484      *  as the storage data type of the DataBuffer.
1485      *  @return the number of data elements.
1486      */
1487     public final int getNumDataElements() {
1488         return sampleModel.getNumDataElements();
1489     }
1490 
1491     /**
1492      *  Returns the TransferType used to transfer pixels via the
1493      *  getDataElements and setDataElements methods.  When pixels
1494      *  are transferred via these methods, they may be transferred in a
1495      *  packed or unpacked format, depending on the implementation of the
1496      *  underlying SampleModel.  Using these methods, pixels are transferred
1497      *  as an array of getNumDataElements() elements of a primitive type given
1498      *  by getTransferType().  The TransferType may or may not be the same
1499      *  as the storage data type of the DataBuffer.  The TransferType will
1500      *  be one of the types defined in DataBuffer.
1501      *  @return this transfer type.
1502      */
1503     public final int getTransferType() {
1504         return sampleModel.getTransferType();
1505     }
1506 
1507     /** Returns the DataBuffer associated with this Raster.
1508      *  @return the {@code DataBuffer} of this {@code Raster}.
1509      */
1510     public DataBuffer getDataBuffer() {
1511         return dataBuffer;
1512     }
1513 
1514     /** Returns the SampleModel that describes the layout of the image data.
1515      *  @return the {@code SampleModel} of this {@code Raster}.
1516      */
1517     public SampleModel getSampleModel() {
1518         return sampleModel;
1519     }
1520 
1521     /**
1522      * Returns data for a single pixel in a primitive array of type
1523      * TransferType.  For image data supported by the Java 2D(tm) API,
1524      * this will be one of DataBuffer.TYPE_BYTE, DataBuffer.TYPE_USHORT,
1525      * DataBuffer.TYPE_INT, DataBuffer.TYPE_SHORT, DataBuffer.TYPE_FLOAT,
1526      * or DataBuffer.TYPE_DOUBLE.  Data may be returned in a packed format,
1527      * thus increasing efficiency for data transfers.
1528      * An ArrayIndexOutOfBoundsException may be thrown
1529      * if the coordinates are not in bounds.  However, explicit bounds
1530      * checking is not guaranteed.
1531      * A ClassCastException will be thrown if the input object is non null
1532      * and references anything other than an array of TransferType.
1533      * @see java.awt.image.SampleModel#getDataElements(int, int, Object, DataBuffer)
1534      * @param x        The X coordinate of the pixel location
1535      * @param y        The Y coordinate of the pixel location
1536      * @param outData  An object reference to an array of type defined by
1537      *                 getTransferType() and length getNumDataElements().
1538      *                 If null, an array of appropriate type and size will be
1539      *                 allocated
1540      * @return         An object reference to an array of type defined by
1541      *                 getTransferType() with the requested pixel data.
1542      *
1543      * @throws ArrayIndexOutOfBoundsException if the coordinates are not
1544      * in bounds, or if outData is too small to hold the output.
1545      */
1546     public Object getDataElements(int x, int y, Object outData) {
1547         return sampleModel.getDataElements(x - sampleModelTranslateX,
1548                                            y - sampleModelTranslateY,
1549                                            outData, dataBuffer);
1550     }
1551 
1552     /**
1553      * Returns the pixel data for the specified rectangle of pixels in a
1554      * primitive array of type TransferType.
1555      * For image data supported by the Java 2D API, this
1556      * will be one of DataBuffer.TYPE_BYTE, DataBuffer.TYPE_USHORT,
1557      * DataBuffer.TYPE_INT, DataBuffer.TYPE_SHORT, DataBuffer.TYPE_FLOAT,
1558      * or DataBuffer.TYPE_DOUBLE.  Data may be returned in a packed format,
1559      * thus increasing efficiency for data transfers.
1560      * An ArrayIndexOutOfBoundsException may be thrown
1561      * if the coordinates are not in bounds.  However, explicit bounds
1562      * checking is not guaranteed.
1563      * A ClassCastException will be thrown if the input object is non null
1564      * and references anything other than an array of TransferType.
1565      * @see java.awt.image.SampleModel#getDataElements(int, int, int, int, Object, DataBuffer)
1566      * @param x    The X coordinate of the upper-left pixel location
1567      * @param y    The Y coordinate of the upper-left pixel location
1568      * @param w    Width of the pixel rectangle
1569      * @param h   Height of the pixel rectangle
1570      * @param outData  An object reference to an array of type defined by
1571      *                 getTransferType() and length w*h*getNumDataElements().
1572      *                 If null, an array of appropriate type and size will be
1573      *                 allocated.
1574      * @return         An object reference to an array of type defined by
1575      *                 getTransferType() with the requested pixel data.
1576      *
1577      * @throws ArrayIndexOutOfBoundsException if the coordinates are not
1578      * in bounds, or if outData is too small to hold the output.
1579      */
1580     public Object getDataElements(int x, int y, int w, int h, Object outData) {
1581         return sampleModel.getDataElements(x - sampleModelTranslateX,
1582                                            y - sampleModelTranslateY,
1583                                            w, h, outData, dataBuffer);
1584     }
1585 
1586     /**
1587      * Returns the samples in an array of int for the specified pixel.
1588      * An ArrayIndexOutOfBoundsException may be thrown
1589      * if the coordinates are not in bounds.  However, explicit bounds
1590      * checking is not guaranteed.
1591      * @param x The X coordinate of the pixel location
1592      * @param y The Y coordinate of the pixel location
1593      * @param iArray An optionally preallocated int array
1594      * @return the samples for the specified pixel.
1595      *
1596      * @throws ArrayIndexOutOfBoundsException if the coordinates are not
1597      * in bounds, or if iArray is too small to hold the output.
1598      */
1599     public int[] getPixel(int x, int y, int iArray[]) {
1600         return sampleModel.getPixel(x - sampleModelTranslateX,
1601                                     y - sampleModelTranslateY,
1602                                     iArray, dataBuffer);
1603     }
1604 
1605     /**
1606      * Returns the samples in an array of float for the
1607      * specified pixel.
1608      * An ArrayIndexOutOfBoundsException may be thrown
1609      * if the coordinates are not in bounds.  However, explicit bounds
1610      * checking is not guaranteed.
1611      * @param x The X coordinate of the pixel location
1612      * @param y The Y coordinate of the pixel location
1613      * @param fArray An optionally preallocated float array
1614      * @return the samples for the specified pixel.
1615      *
1616      * @throws ArrayIndexOutOfBoundsException if the coordinates are not
1617      * in bounds, or if fArray is too small to hold the output.
1618      */
1619     public float[] getPixel(int x, int y, float fArray[]) {
1620         return sampleModel.getPixel(x - sampleModelTranslateX,
1621                                     y - sampleModelTranslateY,
1622                                     fArray, dataBuffer);
1623     }
1624 
1625     /**
1626      * Returns the samples in an array of double for the specified pixel.
1627      * An ArrayIndexOutOfBoundsException may be thrown
1628      * if the coordinates are not in bounds.  However, explicit bounds
1629      * checking is not guaranteed.
1630      * @param x The X coordinate of the pixel location
1631      * @param y The Y coordinate of the pixel location
1632      * @param dArray An optionally preallocated double array
1633      * @return the samples for the specified pixel.
1634      *
1635      * @throws ArrayIndexOutOfBoundsException if the coordinates are not
1636      * in bounds, or if dArray is too small to hold the output.
1637      */
1638     public double[] getPixel(int x, int y, double dArray[]) {
1639         return sampleModel.getPixel(x - sampleModelTranslateX,
1640                                     y - sampleModelTranslateY,
1641                                     dArray, dataBuffer);
1642     }
1643 
1644     /**
1645      * Returns an int array containing all samples for a rectangle of pixels,
1646      * one sample per array element.
1647      * An ArrayIndexOutOfBoundsException may be thrown
1648      * if the coordinates are not in bounds.  However, explicit bounds
1649      * checking is not guaranteed.
1650      * @param x      The X coordinate of the upper-left pixel location
1651      * @param y      The Y coordinate of the upper-left pixel location
1652      * @param w      Width of the pixel rectangle
1653      * @param h      Height of the pixel rectangle
1654      * @param iArray An optionally pre-allocated int array
1655      * @return the samples for the specified rectangle of pixels.
1656      *
1657      * @throws ArrayIndexOutOfBoundsException if the coordinates are not
1658      * in bounds, or if iArray is too small to hold the output.
1659      */
1660     public int[] getPixels(int x, int y, int w, int h, int iArray[]) {
1661         return sampleModel.getPixels(x - sampleModelTranslateX,
1662                                      y - sampleModelTranslateY, w, h,
1663                                      iArray, dataBuffer);
1664     }
1665 
1666     /**
1667      * Returns a float array containing all samples for a rectangle of pixels,
1668      * one sample per array element.
1669      * An ArrayIndexOutOfBoundsException may be thrown
1670      * if the coordinates are not in bounds.  However, explicit bounds
1671      * checking is not guaranteed.
1672      * @param x        The X coordinate of the pixel location
1673      * @param y        The Y coordinate of the pixel location
1674      * @param w        Width of the pixel rectangle
1675      * @param h        Height of the pixel rectangle
1676      * @param fArray   An optionally pre-allocated float array
1677      * @return the samples for the specified rectangle of pixels.
1678      *
1679      * @throws ArrayIndexOutOfBoundsException if the coordinates are not
1680      * in bounds, or if fArray is too small to hold the output.
1681      */
1682     public float[] getPixels(int x, int y, int w, int h,
1683                              float fArray[]) {
1684         return sampleModel.getPixels(x - sampleModelTranslateX,
1685                                      y - sampleModelTranslateY, w, h,
1686                                      fArray, dataBuffer);
1687     }
1688 
1689     /**
1690      * Returns a double array containing all samples for a rectangle of pixels,
1691      * one sample per array element.
1692      * An ArrayIndexOutOfBoundsException may be thrown
1693      * if the coordinates are not in bounds.  However, explicit bounds
1694      * checking is not guaranteed.
1695      * @param x        The X coordinate of the upper-left pixel location
1696      * @param y        The Y coordinate of the upper-left pixel location
1697      * @param w        Width of the pixel rectangle
1698      * @param h        Height of the pixel rectangle
1699      * @param dArray   An optionally pre-allocated double array
1700      * @return the samples for the specified rectangle of pixels.
1701      *
1702      * @throws ArrayIndexOutOfBoundsException if the coordinates are not
1703      * in bounds, or if dArray is too small to hold the output.
1704      */
1705     public double[] getPixels(int x, int y, int w, int h,
1706                               double dArray[]) {
1707         return sampleModel.getPixels(x - sampleModelTranslateX,
1708                                      y - sampleModelTranslateY,
1709                                      w, h, dArray, dataBuffer);
1710     }
1711 
1712 
1713     /**
1714      * Returns the sample in a specified band for the pixel located
1715      * at (x,y) as an int.
1716      * An ArrayIndexOutOfBoundsException may be thrown
1717      * if the coordinates are not in bounds.  However, explicit bounds
1718      * checking is not guaranteed.
1719      * @param x        The X coordinate of the pixel location
1720      * @param y        The Y coordinate of the pixel location
1721      * @param b        The band to return
1722      * @return the sample in the specified band for the pixel at the
1723      *         specified coordinate.
1724      *
1725      * @throws ArrayIndexOutOfBoundsException if the coordinates or
1726      * the band index are not in bounds.
1727      */
1728     public int getSample(int x, int y, int b) {
1729         return sampleModel.getSample(x - sampleModelTranslateX,
1730                                      y - sampleModelTranslateY, b,
1731                                      dataBuffer);
1732     }
1733 
1734     /**
1735      * Returns the sample in a specified band
1736      * for the pixel located at (x,y) as a float.
1737      * An ArrayIndexOutOfBoundsException may be thrown
1738      * if the coordinates are not in bounds.  However, explicit bounds
1739      * checking is not guaranteed.
1740      * @param x        The X coordinate of the pixel location
1741      * @param y        The Y coordinate of the pixel location
1742      * @param b        The band to return
1743      * @return the sample in the specified band for the pixel at the
1744      *         specified coordinate.
1745      *
1746      * @throws ArrayIndexOutOfBoundsException if the coordinates or
1747      * the band index are not in bounds.
1748      */
1749     public float getSampleFloat(int x, int y, int b) {
1750         return sampleModel.getSampleFloat(x - sampleModelTranslateX,
1751                                           y - sampleModelTranslateY, b,
1752                                           dataBuffer);
1753     }
1754 
1755     /**
1756      * Returns the sample in a specified band
1757      * for a pixel located at (x,y) as a double.
1758      * An ArrayIndexOutOfBoundsException may be thrown
1759      * if the coordinates are not in bounds.  However, explicit bounds
1760      * checking is not guaranteed.
1761      * @param x        The X coordinate of the pixel location
1762      * @param y        The Y coordinate of the pixel location
1763      * @param b        The band to return
1764      * @return the sample in the specified band for the pixel at the
1765      *         specified coordinate.
1766      *
1767      * @throws ArrayIndexOutOfBoundsException if the coordinates or
1768      * the band index are not in bounds.
1769      */
1770     public double getSampleDouble(int x, int y, int b) {
1771         return sampleModel.getSampleDouble(x - sampleModelTranslateX,
1772                                            y - sampleModelTranslateY,
1773                                            b, dataBuffer);
1774     }
1775 
1776     /**
1777      * Returns the samples for a specified band for the specified rectangle
1778      * of pixels in an int array, one sample per array element.
1779      * An ArrayIndexOutOfBoundsException may be thrown
1780      * if the coordinates are not in bounds.  However, explicit bounds
1781      * checking is not guaranteed.
1782      * @param x        The X coordinate of the upper-left pixel location
1783      * @param y        The Y coordinate of the upper-left pixel location
1784      * @param w        Width of the pixel rectangle
1785      * @param h        Height of the pixel rectangle
1786      * @param b        The band to return
1787      * @param iArray   An optionally pre-allocated int array
1788      * @return the samples for the specified band for the specified
1789      *         rectangle of pixels.
1790      *
1791      * @throws ArrayIndexOutOfBoundsException if the coordinates or
1792      * the band index are not in bounds, or if iArray is too small to
1793      * hold the output.
1794      */
1795     public int[] getSamples(int x, int y, int w, int h, int b,
1796                             int iArray[]) {
1797         return sampleModel.getSamples(x - sampleModelTranslateX,
1798                                       y - sampleModelTranslateY,
1799                                       w, h, b, iArray,
1800                                       dataBuffer);
1801     }
1802 
1803     /**
1804      * Returns the samples for a specified band for the specified rectangle
1805      * of pixels in a float array, one sample per array element.
1806      * An ArrayIndexOutOfBoundsException may be thrown
1807      * if the coordinates are not in bounds.  However, explicit bounds
1808      * checking is not guaranteed.
1809      * @param x        The X coordinate of the upper-left pixel location
1810      * @param y        The Y coordinate of the upper-left pixel location
1811      * @param w        Width of the pixel rectangle
1812      * @param h        Height of the pixel rectangle
1813      * @param b        The band to return
1814      * @param fArray   An optionally pre-allocated float array
1815      * @return the samples for the specified band for the specified
1816      *         rectangle of pixels.
1817      *
1818      * @throws ArrayIndexOutOfBoundsException if the coordinates or
1819      * the band index are not in bounds, or if fArray is too small to
1820      * hold the output.
1821      */
1822     public float[] getSamples(int x, int y, int w, int h, int b,
1823                               float fArray[]) {
1824         return sampleModel.getSamples(x - sampleModelTranslateX,
1825                                       y - sampleModelTranslateY,
1826                                       w, h, b, fArray, dataBuffer);
1827     }
1828 
1829     /**
1830      * Returns the samples for a specified band for a specified rectangle
1831      * of pixels in a double array, one sample per array element.
1832      * An ArrayIndexOutOfBoundsException may be thrown
1833      * if the coordinates are not in bounds.  However, explicit bounds
1834      * checking is not guaranteed.
1835      * @param x        The X coordinate of the upper-left pixel location
1836      * @param y        The Y coordinate of the upper-left pixel location
1837      * @param w        Width of the pixel rectangle
1838      * @param h        Height of the pixel rectangle
1839      * @param b        The band to return
1840      * @param dArray   An optionally pre-allocated double array
1841      * @return the samples for the specified band for the specified
1842      *         rectangle of pixels.
1843      *
1844      * @throws ArrayIndexOutOfBoundsException if the coordinates or
1845      * the band index are not in bounds, or if dArray is too small to
1846      * hold the output.
1847      */
1848     public double[] getSamples(int x, int y, int w, int h, int b,
1849                                double dArray[]) {
1850          return sampleModel.getSamples(x - sampleModelTranslateX,
1851                                        y - sampleModelTranslateY,
1852                                        w, h, b, dArray, dataBuffer);
1853     }
1854 
1855 }
--- EOF ---