1 /*

     2  * Portions Copyright 1997-2007 Sun Microsystems, Inc.  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.  Sun designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

    22  * CA 95054 USA or visit www.sun.com if you need additional information or

    23  * have any 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     static private 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</code>

   186      * Rasters are not supported.  To create a 1-band Raster of type

   187      * <code>DataBuffer.TYPE_INT</code>, 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</code>

   196      * @return a WritableRaster object with the specified data type,

   197      *         width, height and number of bands.

   198      * @throws RasterFormatException if <code>w</code> or <code>h</code>

   199      *         is less than or equal to zero, or computing either

   200      *         <code>location.x + w</code> or

   201      *         <code>location.y + h</code> 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</code>

   228      * Rasters are not supported.  To create a 1-band Raster of type

   229      * <code>DataBuffer.TYPE_INT</code>, 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</code>

   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</code> or <code>h</code>

   244      *         is less than or equal to zero, or computing either

   245      *         <code>location.x + w</code> or

   246      *         <code>location.y + h</code> results in integer

   247      *         overflow

   248      * @throws IllegalArgumentException if <code>dataType</code> is not

   249      *         one of the supported data types, which are

   250      *         <code>DataBuffer.TYPE_BYTE</code>, or

   251      *         <code>DataBuffer.TYPE_USHORT</code>.

   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         int bands = bandOffsets.length;

   261 

   262         int maxBandOff = bandOffsets[0];

   263         for (int i=1; i < bands; i++) {

   264             if (bandOffsets[i] > maxBandOff) {

   265                 maxBandOff = bandOffsets[i];

   266             }

   267         }

   268         int size = maxBandOff + scanlineStride*(h-1) + pixelStride*(w-1) + 1;

   269         switch(dataType) {

   270         case DataBuffer.TYPE_BYTE:

   271             d = new DataBufferByte(size);

   272             break;

   273 

   274         case DataBuffer.TYPE_USHORT:

   275             d = new DataBufferUShort(size);

   276             break;

   277 

   278         default:

   279             throw new IllegalArgumentException("Unsupported data type " +

   280                                                 dataType);

   281         }

   282 

   283         return createInterleavedRaster(d, w, h, scanlineStride,

   284                                        pixelStride, bandOffsets, location);

   285     }

   286 

   287     /**

   288      * Creates a Raster based on a BandedSampleModel with the

   289      * specified data type, width, height, and number of bands.

   290      *

   291      * <p> The upper left corner of the Raster is given by the

   292      * location argument.  If location is null, (0, 0) will be used.

   293      * The dataType parameter should be one of the enumerated values

   294      * defined in the DataBuffer class.

   295      *

   296      * <p> The only dataTypes supported currently are TYPE_BYTE, TYPE_USHORT,

   297      * and TYPE_INT.

   298      * @param dataType  the data type for storing samples

   299      * @param w         the width in pixels of the image data

   300      * @param h         the height in pixels of the image data

   301      * @param bands     the number of bands

   302      * @param location  the upper-left corner of the <code>Raster</code>

   303      * @return a WritableRaster object with the specified data type,

   304      *         width, height and number of bands.

   305      * @throws RasterFormatException if <code>w</code> or <code>h</code>

   306      *         is less than or equal to zero, or computing either

   307      *         <code>location.x + w</code> or

   308      *         <code>location.y + h</code> results in integer

   309      *         overflow

   310      * @throws ArrayIndexOutOfBoundsException if <code>bands</code>

   311      *         is less than 1

   312      */

   313     public static WritableRaster createBandedRaster(int dataType,

   314                                                     int w, int h,

   315                                                     int bands,

   316                                                     Point location) {

   317         if (bands < 1) {

   318             throw new ArrayIndexOutOfBoundsException("Number of bands ("+

   319                                                      bands+") must"+

   320                                                      " be greater than 0");

   321         }

   322         int[] bankIndices = new int[bands];

   323         int[] bandOffsets = new int[bands];

   324         for (int i = 0; i < bands; i++) {

   325             bankIndices[i] = i;

   326             bandOffsets[i] = 0;

   327         }

   328 

   329         return createBandedRaster(dataType, w, h, w,

   330                                   bankIndices, bandOffsets,

   331                                   location);

   332     }

   333 

   334     /**

   335      * Creates a Raster based on a BandedSampleModel with the

   336      * specified data type, width, height, scanline stride, bank

   337      * indices and band offsets.  The number of bands is inferred from

   338      * bankIndices.length and bandOffsets.length, which must be the

   339      * same.

   340      *

   341      * <p> The upper left corner of the Raster is given by the

   342      * location argument.  The dataType parameter should be one of the

   343      * enumerated values defined in the DataBuffer class.

   344      *

   345      * <p> The only dataTypes supported currently are TYPE_BYTE, TYPE_USHORT,

   346      * and TYPE_INT.

   347      * @param dataType  the data type for storing samples

   348      * @param w         the width in pixels of the image data

   349      * @param h         the height in pixels of the image data

   350      * @param scanlineStride the line stride of the image data

   351      * @param bankIndices the bank indices for each band

   352      * @param bandOffsets the offsets of all bands

   353      * @param location  the upper-left corner of the <code>Raster</code>

   354      * @return a WritableRaster object with the specified data type,

   355      *         width, height, scanline stride, bank indices and band

   356      *         offsets.

   357      * @throws RasterFormatException if <code>w</code> or <code>h</code>

   358      *         is less than or equal to zero, or computing either

   359      *         <code>location.x + w</code> or

   360      *         <code>location.y + h</code> results in integer

   361      *         overflow

   362      * @throws IllegalArgumentException if <code>dataType</code> is not

   363      *         one of the supported data types, which are

   364      *         <code>DataBuffer.TYPE_BYTE</code>,

   365      *         <code>DataBuffer.TYPE_USHORT</code>

   366      *         or <code>DataBuffer.TYPE_INT</code>

   367      * @throws ArrayIndexOutOfBoundsException if <code>bankIndices</code>

   368      *         or <code>bandOffsets</code> is <code>null</code>

   369      */

   370     public static WritableRaster createBandedRaster(int dataType,

   371                                                     int w, int h,

   372                                                     int scanlineStride,

   373                                                     int bankIndices[],

   374                                                     int bandOffsets[],

   375                                                     Point location) {

   376         DataBuffer d;

   377         int bands = bandOffsets.length;

   378 

   379         if (bankIndices == null) {

   380             throw new

   381                 ArrayIndexOutOfBoundsException("Bank indices array is null");

   382         }

   383         if (bandOffsets == null) {

   384             throw new

   385                 ArrayIndexOutOfBoundsException("Band offsets array is null");

   386         }

   387 

   388         // Figure out the #banks and the largest band offset

   389         int maxBank = bankIndices[0];

   390         int maxBandOff = bandOffsets[0];

   391         for (int i = 1; i < bands; i++) {

   392             if (bankIndices[i] > maxBank) {

   393                 maxBank = bankIndices[i];

   394             }

   395             if (bandOffsets[i] > maxBandOff) {

   396                 maxBandOff = bandOffsets[i];

   397             }

   398         }

   399         int banks = maxBank + 1;

   400         int size = maxBandOff + scanlineStride*(h-1) + (w-1) + 1;

   401 

   402         switch(dataType) {

   403         case DataBuffer.TYPE_BYTE:

   404             d = new DataBufferByte(size, banks);

   405             break;

   406 

   407         case DataBuffer.TYPE_USHORT:

   408             d = new DataBufferUShort(size, banks);

   409             break;

   410 

   411         case DataBuffer.TYPE_INT:

   412             d = new DataBufferInt(size, banks);

   413             break;

   414 

   415         default:

   416             throw new IllegalArgumentException("Unsupported data type " +

   417                                                 dataType);

   418         }

   419 

   420         return createBandedRaster(d, w, h, scanlineStride,

   421                                   bankIndices, bandOffsets, location);

   422     }

   423 

   424     /**

   425      * Creates a Raster based on a SinglePixelPackedSampleModel with

   426      * the specified data type, width, height, and band masks.

   427      * The number of bands is inferred from bandMasks.length.

   428      *

   429      * <p> The upper left corner of the Raster is given by the

   430      * location argument.  If location is null, (0, 0) will be used.

   431      * The dataType parameter should be one of the enumerated values

   432      * defined in the DataBuffer class.

   433      *

   434      * <p> The only dataTypes supported currently are TYPE_BYTE, TYPE_USHORT,

   435      * and TYPE_INT.

   436      * @param dataType  the data type for storing samples

   437      * @param w         the width in pixels of the image data

   438      * @param h         the height in pixels of the image data

   439      * @param bandMasks an array containing an entry for each band

   440      * @param location  the upper-left corner of the <code>Raster</code>

   441      * @return a WritableRaster object with the specified data type,

   442      *         width, height, and band masks.

   443      * @throws RasterFormatException if <code>w</code> or <code>h</code>

   444      *         is less than or equal to zero, or computing either

   445      *         <code>location.x + w</code> or

   446      *         <code>location.y + h</code> results in integer

   447      *         overflow

   448      * @throws IllegalArgumentException if <code>dataType</code> is not

   449      *         one of the supported data types, which are

   450      *         <code>DataBuffer.TYPE_BYTE</code>,

   451      *         <code>DataBuffer.TYPE_USHORT</code>

   452      *         or <code>DataBuffer.TYPE_INT</code>

   453      */

   454     public static WritableRaster createPackedRaster(int dataType,

   455                                                     int w, int h,

   456                                                     int bandMasks[],

   457                                                     Point location) {

   458         DataBuffer d;

   459 

   460         switch(dataType) {

   461         case DataBuffer.TYPE_BYTE:

   462             d = new DataBufferByte(w*h);

   463             break;

   464 

   465         case DataBuffer.TYPE_USHORT:

   466             d = new DataBufferUShort(w*h);

   467             break;

   468 

   469         case DataBuffer.TYPE_INT:

   470             d = new DataBufferInt(w*h);

   471             break;

   472 

   473         default:

   474             throw new IllegalArgumentException("Unsupported data type " +

   475                                                 dataType);

   476         }

   477 

   478         return createPackedRaster(d, w, h, w, bandMasks, location);

   479     }

   480 

   481     /**

   482      * Creates a Raster based on a packed SampleModel with the

   483      * specified data type, width, height, number of bands, and bits

   484      * per band.  If the number of bands is one, the SampleModel will

   485      * be a MultiPixelPackedSampleModel.

   486      *

   487      * <p> If the number of bands is more than one, the SampleModel

   488      * will be a SinglePixelPackedSampleModel, with each band having

   489      * bitsPerBand bits.  In either case, the requirements on dataType

   490      * and bitsPerBand imposed by the corresponding SampleModel must

   491      * be met.

   492      *

   493      * <p> The upper left corner of the Raster is given by the

   494      * location argument.  If location is null, (0, 0) will be used.

   495      * The dataType parameter should be one of the enumerated values

   496      * defined in the DataBuffer class.

   497      *

   498      * <p> The only dataTypes supported currently are TYPE_BYTE, TYPE_USHORT,

   499      * and TYPE_INT.

   500      * @param dataType  the data type for storing samples

   501      * @param w         the width in pixels of the image data

   502      * @param h         the height in pixels of the image data

   503      * @param bands     the number of bands

   504      * @param bitsPerBand the number of bits per band

   505      * @param location  the upper-left corner of the <code>Raster</code>

   506      * @return a WritableRaster object with the specified data type,

   507      *         width, height, number of bands, and bits per band.

   508      * @throws RasterFormatException if <code>w</code> or <code>h</code>

   509      *         is less than or equal to zero, or computing either

   510      *         <code>location.x + w</code> or

   511      *         <code>location.y + h</code> results in integer

   512      *         overflow

   513      * @throws IllegalArgumentException if the product of

   514      *         <code>bitsPerBand</code> and <code>bands</code> is

   515      *         greater than the number of bits held by

   516      *         <code>dataType</code>

   517      * @throws IllegalArgumentException if <code>bitsPerBand</code> or

   518      *         <code>bands</code> is not greater than zero

   519      * @throws IllegalArgumentException if <code>dataType</code> is not

   520      *         one of the supported data types, which are

   521      *         <code>DataBuffer.TYPE_BYTE</code>,

   522      *         <code>DataBuffer.TYPE_USHORT</code>

   523      *         or <code>DataBuffer.TYPE_INT</code>

   524      */

   525     public static WritableRaster createPackedRaster(int dataType,

   526                                                     int w, int h,

   527                                                     int bands,

   528                                                     int bitsPerBand,

   529                                                     Point location) {

   530         DataBuffer d;

   531 

   532         if (bands <= 0) {

   533             throw new IllegalArgumentException("Number of bands ("+bands+

   534                                                ") must be greater than 0");

   535         }

   536 

   537         if (bitsPerBand <= 0) {

   538             throw new IllegalArgumentException("Bits per band ("+bitsPerBand+

   539                                                ") must be greater than 0");

   540         }

   541 

   542         if (bands != 1) {

   543             int[] masks = new int[bands];

   544             int mask = (1 << bitsPerBand) - 1;

   545             int shift = (bands-1)*bitsPerBand;

   546 

   547             /* Make sure the total mask size will fit in the data type */

   548             if (shift+bitsPerBand > DataBuffer.getDataTypeSize(dataType)) {

   549                 throw new IllegalArgumentException("bitsPerBand("+

   550                                                    bitsPerBand+") * bands is "+

   551                                                    " greater than data type "+

   552                                                    "size.");

   553             }

   554             switch(dataType) {

   555             case DataBuffer.TYPE_BYTE:

   556             case DataBuffer.TYPE_USHORT:

   557             case DataBuffer.TYPE_INT:

   558                 break;

   559             default:

   560                 throw new IllegalArgumentException("Unsupported data type " +

   561                                                     dataType);

   562             }

   563 

   564             for (int i = 0; i < bands; i++) {

   565                 masks[i] = mask << shift;

   566                 shift = shift - bitsPerBand;

   567             }

   568 

   569             return createPackedRaster(dataType, w, h, masks, location);

   570         }

   571         else {

   572             double fw = w;

   573             switch(dataType) {

   574             case DataBuffer.TYPE_BYTE:

   575                 d = new DataBufferByte((int)(Math.ceil(fw/(8/bitsPerBand)))*h);

   576                 break;

   577 

   578             case DataBuffer.TYPE_USHORT:

   579                 d = new DataBufferUShort((int)(Math.ceil(fw/(16/bitsPerBand)))*h);

   580                 break;

   581 

   582             case DataBuffer.TYPE_INT:

   583                 d = new DataBufferInt((int)(Math.ceil(fw/(32/bitsPerBand)))*h);

   584                 break;

   585 

   586             default:

   587                 throw new IllegalArgumentException("Unsupported data type " +

   588                                                    dataType);

   589             }

   590 

   591             return createPackedRaster(d, w, h, bitsPerBand, location);

   592         }

   593     }

   594 

   595     /**

   596      * Creates a Raster based on a PixelInterleavedSampleModel with the

   597      * specified DataBuffer, width, height, scanline stride, pixel

   598      * stride, and band offsets.  The number of bands is inferred from

   599      * bandOffsets.length.  The upper left corner of the Raster

   600      * is given by the location argument.  If location is null, (0, 0)

   601      * will be used.

   602      * <p> Note that interleaved <code>DataBuffer.TYPE_INT</code>

   603      * Rasters are not supported.  To create a 1-band Raster of type

   604      * <code>DataBuffer.TYPE_INT</code>, use

   605      * Raster.createPackedRaster().

   606      * @param dataBuffer the <code>DataBuffer</code> that contains the

   607      *        image data

   608      * @param w         the width in pixels of the image data

   609      * @param h         the height in pixels of the image data

   610      * @param scanlineStride the line stride of the image data

   611      * @param pixelStride the pixel stride of the image data

   612      * @param bandOffsets the offsets of all bands

   613      * @param location  the upper-left corner of the <code>Raster</code>

   614      * @return a WritableRaster object with the specified

   615      *         <code>DataBuffer</code>, width, height, scanline stride,

   616      *         pixel stride and band offsets.

   617      * @throws RasterFormatException if <code>w</code> or <code>h</code>

   618      *         is less than or equal to zero, or computing either

   619      *         <code>location.x + w</code> or

   620      *         <code>location.y + h</code> results in integer

   621      *         overflow

   622      * @throws IllegalArgumentException if <code>dataType</code> is not

   623      *         one of the supported data types, which are

   624      *         <code>DataBuffer.TYPE_BYTE</code>,

   625      *         <code>DataBuffer.TYPE_USHORT</code>

   626      * @throws RasterFormatException if <code>dataBuffer</code> has more

   627      *         than one bank.

   628      * @throws NullPointerException if <code>dataBuffer</code> is null

   629      */

   630     public static WritableRaster createInterleavedRaster(DataBuffer dataBuffer,

   631                                                          int w, int h,

   632                                                          int scanlineStride,

   633                                                          int pixelStride,

   634                                                          int bandOffsets[],

   635                                                          Point location) {

   636         if (dataBuffer == null) {

   637             throw new NullPointerException("DataBuffer cannot be null");

   638         }

   639         if (location == null) {

   640             location = new Point(0, 0);

   641         }

   642         int dataType = dataBuffer.getDataType();

   643 

   644         PixelInterleavedSampleModel csm =

   645             new PixelInterleavedSampleModel(dataType, w, h,

   646                                             pixelStride,

   647                                             scanlineStride,

   648                                             bandOffsets);

   649         switch(dataType) {

   650         case DataBuffer.TYPE_BYTE:

   651             return new ByteInterleavedRaster(csm, dataBuffer, location);

   652 

   653         case DataBuffer.TYPE_USHORT:

   654             return new ShortInterleavedRaster(csm, dataBuffer, location);

   655 

   656         default:

   657             throw new IllegalArgumentException("Unsupported data type " +

   658                                                 dataType);

   659         }

   660     }

   661 

   662     /**

   663      * Creates a Raster based on a BandedSampleModel with the

   664      * specified DataBuffer, width, height, scanline stride, bank

   665      * indices, and band offsets.  The number of bands is inferred

   666      * from bankIndices.length and bandOffsets.length, which must be

   667      * the same.  The upper left corner of the Raster is given by the

   668      * location argument.  If location is null, (0, 0) will be used.

   669      * @param dataBuffer the <code>DataBuffer</code> that contains the

   670      *        image data

   671      * @param w         the width in pixels of the image data

   672      * @param h         the height in pixels of the image data

   673      * @param scanlineStride the line stride of the image data

   674      * @param bankIndices the bank indices for each band

   675      * @param bandOffsets the offsets of all bands

   676      * @param location  the upper-left corner of the <code>Raster</code>

   677      * @return a WritableRaster object with the specified

   678      *         <code>DataBuffer</code>, width, height, scanline stride,

   679      *         bank indices and band offsets.

   680      * @throws RasterFormatException if <code>w</code> or <code>h</code>

   681      *         is less than or equal to zero, or computing either

   682      *         <code>location.x + w</code> or

   683      *         <code>location.y + h</code> results in integer

   684      *         overflow

   685      * @throws IllegalArgumentException if <code>dataType</code> is not

   686      *         one of the supported data types, which are

   687      *         <code>DataBuffer.TYPE_BYTE</code>,

   688      *         <code>DataBuffer.TYPE_USHORT</code>

   689      *         or <code>DataBuffer.TYPE_INT</code>

   690      * @throws NullPointerException if <code>dataBuffer</code> is null

   691      */

   692     public static WritableRaster createBandedRaster(DataBuffer dataBuffer,

   693                                                     int w, int h,

   694                                                     int scanlineStride,

   695                                                     int bankIndices[],

   696                                                     int bandOffsets[],

   697                                                     Point location) {

   698         if (dataBuffer == null) {

   699             throw new NullPointerException("DataBuffer cannot be null");

   700         }

   701         if (location == null) {

   702            location = new Point(0,0);

   703         }

   704         int dataType = dataBuffer.getDataType();

   705 

   706         int bands = bankIndices.length;

   707         if (bandOffsets.length != bands) {

   708             throw new IllegalArgumentException(

   709                                    "bankIndices.length != bandOffsets.length");

   710         }

   711 

   712         BandedSampleModel bsm =

   713             new BandedSampleModel(dataType, w, h,

   714                                   scanlineStride,

   715                                   bankIndices, bandOffsets);

   716 

   717         switch(dataType) {

   718         case DataBuffer.TYPE_BYTE:

   719             return new ByteBandedRaster(bsm, dataBuffer, location);

   720 

   721         case DataBuffer.TYPE_USHORT:

   722             return new ShortBandedRaster(bsm, dataBuffer, location);

   723 

   724         case DataBuffer.TYPE_INT:

   725             return new SunWritableRaster(bsm, dataBuffer, location);

   726 

   727         default:

   728             throw new IllegalArgumentException("Unsupported data type " +

   729                                                 dataType);

   730         }

   731     }

   732 

   733     /**

   734      * Creates a Raster based on a SinglePixelPackedSampleModel with

   735      * the specified DataBuffer, width, height, scanline stride, and

   736      * band masks.  The number of bands is inferred from bandMasks.length.

   737      * The upper left corner of the Raster is given by

   738      * the location argument.  If location is null, (0, 0) will be used.

   739      * @param dataBuffer the <code>DataBuffer</code> that contains the

   740      *        image data

   741      * @param w         the width in pixels of the image data

   742      * @param h         the height in pixels of the image data

   743      * @param scanlineStride the line stride of the image data

   744      * @param bandMasks an array containing an entry for each band

   745      * @param location  the upper-left corner of the <code>Raster</code>

   746      * @return a WritableRaster object with the specified

   747      *         <code>DataBuffer</code>, width, height, scanline stride,

   748      *         and band masks.

   749      * @throws RasterFormatException if <code>w</code> or <code>h</code>

   750      *         is less than or equal to zero, or computing either

   751      *         <code>location.x + w</code> or

   752      *         <code>location.y + h</code> results in integer

   753      *         overflow

   754      * @throws IllegalArgumentException if <code>dataType</code> is not

   755      *         one of the supported data types, which are

   756      *         <code>DataBuffer.TYPE_BYTE</code>,

   757      *         <code>DataBuffer.TYPE_USHORT</code>

   758      *         or <code>DataBuffer.TYPE_INT</code>

   759      * @throws RasterFormatException if <code>dataBuffer</code> has more

   760      *         than one bank.

   761      * @throws NullPointerException if <code>dataBuffer</code> is null

   762      */

   763     public static WritableRaster createPackedRaster(DataBuffer dataBuffer,

   764                                                     int w, int h,

   765                                                     int scanlineStride,

   766                                                     int bandMasks[],

   767                                                     Point location) {

   768         if (dataBuffer == null) {

   769             throw new NullPointerException("DataBuffer cannot be null");

   770         }

   771         if (location == null) {

   772            location = new Point(0,0);

   773         }

   774         int dataType = dataBuffer.getDataType();

   775 

   776         SinglePixelPackedSampleModel sppsm =

   777             new SinglePixelPackedSampleModel(dataType, w, h, scanlineStride,

   778                                              bandMasks);

   779 

   780         switch(dataType) {

   781         case DataBuffer.TYPE_BYTE:

   782             return new ByteInterleavedRaster(sppsm, dataBuffer, location);

   783 

   784         case DataBuffer.TYPE_USHORT:

   785             return new ShortInterleavedRaster(sppsm, dataBuffer, location);

   786 

   787         case DataBuffer.TYPE_INT:

   788             return new IntegerInterleavedRaster(sppsm, dataBuffer, location);

   789 

   790         default:

   791             throw new IllegalArgumentException("Unsupported data type " +

   792                                                 dataType);

   793         }

   794     }

   795 

   796     /**

   797      * Creates a Raster based on a MultiPixelPackedSampleModel with the

   798      * specified DataBuffer, width, height, and bits per pixel.  The upper

   799      * left corner of the Raster is given by the location argument.  If

   800      * location is null, (0, 0) will be used.

   801      * @param dataBuffer the <code>DataBuffer</code> that contains the

   802      *        image data

   803      * @param w         the width in pixels of the image data

   804      * @param h         the height in pixels of the image data

   805      * @param bitsPerPixel the number of bits for each pixel

   806      * @param location  the upper-left corner of the <code>Raster</code>

   807      * @return a WritableRaster object with the specified

   808      *         <code>DataBuffer</code>, width, height, and

   809      *         bits per pixel.

   810      * @throws RasterFormatException if <code>w</code> or <code>h</code>

   811      *         is less than or equal to zero, or computing either

   812      *         <code>location.x + w</code> or

   813      *         <code>location.y + h</code> results in integer

   814      *         overflow

   815      * @throws IllegalArgumentException if <code>dataType</code> is not

   816      *         one of the supported data types, which are

   817      *         <code>DataBuffer.TYPE_BYTE</code>,

   818      *         <code>DataBuffer.TYPE_USHORT</code>

   819      *         or <code>DataBuffer.TYPE_INT</code>

   820      * @throws RasterFormatException if <code>dataBuffer</code> has more

   821      *         than one bank.

   822      * @throws NullPointerException if <code>dataBuffer</code> is null

   823      */

   824     public static WritableRaster createPackedRaster(DataBuffer dataBuffer,

   825                                                     int w, int h,

   826                                                     int bitsPerPixel,

   827                                                     Point location) {

   828         if (dataBuffer == null) {

   829             throw new NullPointerException("DataBuffer cannot be null");

   830         }

   831         if (location == null) {

   832            location = new Point(0,0);

   833         }

   834         int dataType = dataBuffer.getDataType();

   835 

   836         if (dataType != DataBuffer.TYPE_BYTE &&

   837             dataType != DataBuffer.TYPE_USHORT &&

   838             dataType != DataBuffer.TYPE_INT) {

   839             throw new IllegalArgumentException("Unsupported data type " +

   840                                                dataType);

   841         }

   842 

   843         if (dataBuffer.getNumBanks() != 1) {

   844             throw new

   845                 RasterFormatException("DataBuffer for packed Rasters"+

   846                                       " must only have 1 bank.");

   847         }

   848 

   849         MultiPixelPackedSampleModel mppsm =

   850                 new MultiPixelPackedSampleModel(dataType, w, h, bitsPerPixel);

   851 

   852         if (dataType == DataBuffer.TYPE_BYTE &&

   853             (bitsPerPixel == 1 || bitsPerPixel == 2 || bitsPerPixel == 4)) {

   854             return new BytePackedRaster(mppsm, dataBuffer, location);

   855         } else {

   856             return new SunWritableRaster(mppsm, dataBuffer, location);

   857         }

   858     }

   859 

   860 

   861     /**

   862      *  Creates a Raster with the specified SampleModel and DataBuffer.

   863      *  The upper left corner of the Raster is given by the location argument.

   864      *  If location is null, (0, 0) will be used.

   865      *  @param sm the specified <code>SampleModel</code>

   866      *  @param db the specified <code>DataBuffer</code>

   867      *  @param location the upper-left corner of the <code>Raster</code>

   868      *  @return a <code>Raster</code> with the specified

   869      *          <code>SampleModel</code>, <code>DataBuffer</code>, and

   870      *          location.

   871      * @throws RasterFormatException if computing either

   872      *         <code>location.x + sm.getWidth()</code> or

   873      *         <code>location.y + sm.getHeight()</code> results in integer

   874      *         overflow

   875      * @throws RasterFormatException if <code>db</code> has more

   876      *         than one bank and <code>sm</code> is a

   877      *         PixelInterleavedSampleModel, SinglePixelPackedSampleModel,

   878      *         or MultiPixelPackedSampleModel.

   879      *  @throws NullPointerException if either SampleModel or DataBuffer is

   880      *          null

   881      */

   882     public static Raster createRaster(SampleModel sm,

   883                                       DataBuffer db,

   884                                       Point location) {

   885         if ((sm == null) || (db == null)) {

   886             throw new NullPointerException("SampleModel and DataBuffer cannot be null");

   887         }

   888 

   889         if (location == null) {

   890            location = new Point(0,0);

   891         }

   892         int dataType = sm.getDataType();

   893 

   894         if (sm instanceof PixelInterleavedSampleModel) {

   895             switch(dataType) {

   896                 case DataBuffer.TYPE_BYTE:

   897                     return new ByteInterleavedRaster(sm, db, location);

   898 

   899                 case DataBuffer.TYPE_USHORT:

   900                     return new ShortInterleavedRaster(sm, db, location);

   901             }

   902         } else if (sm instanceof SinglePixelPackedSampleModel) {

   903             switch(dataType) {

   904                 case DataBuffer.TYPE_BYTE:

   905                     return new ByteInterleavedRaster(sm, db, location);

   906 

   907                 case DataBuffer.TYPE_USHORT:

   908                     return new ShortInterleavedRaster(sm, db, location);

   909 

   910                 case DataBuffer.TYPE_INT:

   911                     return new IntegerInterleavedRaster(sm, db, location);

   912             }

   913         } else if (sm instanceof MultiPixelPackedSampleModel &&

   914                    dataType == DataBuffer.TYPE_BYTE &&

   915                    sm.getSampleSize(0) < 8) {

   916             return new BytePackedRaster(sm, db, location);

   917         }

   918 

   919         // we couldn't do anything special - do the generic thing

   920 

   921         return new Raster(sm,db,location);

   922     }

   923 

   924     /**

   925      *  Creates a WritableRaster with the specified SampleModel.

   926      *  The upper left corner of the Raster is given by the location argument.

   927      *  If location is null, (0, 0) will be used.

   928      *  @param sm the specified <code>SampleModel</code>

   929      *  @param location the upper-left corner of the

   930      *         <code>WritableRaster</code>

   931      *  @return a <code>WritableRaster</code> with the specified

   932      *          <code>SampleModel</code> and location.

   933      *  @throws RasterFormatException if computing either

   934      *          <code>location.x + sm.getWidth()</code> or

   935      *          <code>location.y + sm.getHeight()</code> results in integer

   936      *          overflow

   937      */

   938     public static WritableRaster createWritableRaster(SampleModel sm,

   939                                                       Point location) {

   940         if (location == null) {

   941            location = new Point(0,0);

   942         }

   943 

   944         return createWritableRaster(sm, sm.createDataBuffer(), location);

   945     }

   946 

   947     /**

   948      *  Creates a WritableRaster with the specified SampleModel and DataBuffer.

   949      *  The upper left corner of the Raster is given by the location argument.

   950      *  If location is null, (0, 0) will be used.

   951      *  @param sm the specified <code>SampleModel</code>

   952      *  @param db the specified <code>DataBuffer</code>

   953      *  @param location the upper-left corner of the

   954      *         <code>WritableRaster</code>

   955      *  @return a <code>WritableRaster</code> with the specified

   956      *          <code>SampleModel</code>, <code>DataBuffer</code>, and

   957      *          location.

   958      * @throws RasterFormatException if computing either

   959      *         <code>location.x + sm.getWidth()</code> or

   960      *         <code>location.y + sm.getHeight()</code> results in integer

   961      *         overflow

   962      * @throws RasterFormatException if <code>db</code> has more

   963      *         than one bank and <code>sm</code> is a

   964      *         PixelInterleavedSampleModel, SinglePixelPackedSampleModel,

   965      *         or MultiPixelPackedSampleModel.

   966      * @throws NullPointerException if either SampleModel or DataBuffer is null

   967      */

   968     public static WritableRaster createWritableRaster(SampleModel sm,

   969                                                       DataBuffer db,

   970                                                       Point location) {

   971         if ((sm == null) || (db == null)) {

   972             throw new NullPointerException("SampleModel and DataBuffer cannot be null");

   973         }

   974         if (location == null) {

   975            location = new Point(0,0);

   976         }

   977 

   978         int dataType = sm.getDataType();

   979 

   980         if (sm instanceof PixelInterleavedSampleModel) {

   981             switch(dataType) {

   982                 case DataBuffer.TYPE_BYTE:

   983                     return new ByteInterleavedRaster(sm, db, location);

   984 

   985                 case DataBuffer.TYPE_USHORT:

   986                     return new ShortInterleavedRaster(sm, db, location);

   987             }

   988         } else if (sm instanceof SinglePixelPackedSampleModel) {

   989             switch(dataType) {

   990                 case DataBuffer.TYPE_BYTE:

   991                     return new ByteInterleavedRaster(sm, db, location);

   992 

   993                 case DataBuffer.TYPE_USHORT:

   994                     return new ShortInterleavedRaster(sm, db, location);

   995 

   996                 case DataBuffer.TYPE_INT:

   997                     return new IntegerInterleavedRaster(sm, db, location);

   998             }

   999         } else if (sm instanceof MultiPixelPackedSampleModel &&

  1000                    dataType == DataBuffer.TYPE_BYTE &&

  1001                    sm.getSampleSize(0) < 8) {

  1002             return new BytePackedRaster(sm, db, location);

  1003         }

  1004 

  1005         // we couldn't do anything special - do the generic thing

  1006 

  1007         return new SunWritableRaster(sm,db,location);

  1008     }

  1009 

  1010     /**

  1011      *  Constructs a Raster with the given SampleModel.  The Raster's

  1012      *  upper left corner is origin and it is the same size as the

  1013      *  SampleModel.  A DataBuffer large enough to describe the

  1014      *  Raster is automatically created.

  1015      *  @param sampleModel     The SampleModel that specifies the layout

  1016      *  @param origin          The Point that specified the origin

  1017      *  @throws RasterFormatException if computing either

  1018      *          <code>origin.x + sampleModel.getWidth()</code> or

  1019      *          <code>origin.y + sampleModel.getHeight()</code> results in

  1020      *          integer overflow

  1021      *  @throws NullPointerException either <code>sampleModel</code> or

  1022      *          <code>origin</code> is null

  1023      */

  1024     protected Raster(SampleModel sampleModel,

  1025                      Point origin) {

  1026         this(sampleModel,

  1027              sampleModel.createDataBuffer(),

  1028              new Rectangle(origin.x,

  1029                            origin.y,

  1030                            sampleModel.getWidth(),

  1031                            sampleModel.getHeight()),

  1032              origin,

  1033              null);

  1034     }

  1035 

  1036     /**

  1037      *  Constructs a Raster with the given SampleModel and DataBuffer.

  1038      *  The Raster's upper left corner is origin and it is the same size

  1039      *  as the SampleModel.  The DataBuffer is not initialized and must

  1040      *  be compatible with SampleModel.

  1041      *  @param sampleModel     The SampleModel that specifies the layout

  1042      *  @param dataBuffer      The DataBuffer that contains the image data

  1043      *  @param origin          The Point that specifies the origin

  1044      *  @throws RasterFormatException if computing either

  1045      *          <code>origin.x + sampleModel.getWidth()</code> or

  1046      *          <code>origin.y + sampleModel.getHeight()</code> results in

  1047      *          integer overflow

  1048      *  @throws NullPointerException either <code>sampleModel</code> or

  1049      *          <code>origin</code> is null

  1050      */

  1051     protected Raster(SampleModel sampleModel,

  1052                      DataBuffer dataBuffer,

  1053                      Point origin) {

  1054         this(sampleModel,

  1055              dataBuffer,

  1056              new Rectangle(origin.x,

  1057                            origin.y,

  1058                            sampleModel.getWidth(),

  1059                            sampleModel.getHeight()),

  1060              origin,

  1061              null);

  1062     }

  1063 

  1064     /**

  1065      * Constructs a Raster with the given SampleModel, DataBuffer, and

  1066      * parent.  aRegion specifies the bounding rectangle of the new

  1067      * Raster.  When translated into the base Raster's coordinate

  1068      * system, aRegion must be contained by the base Raster.

  1069      * (The base Raster is the Raster's ancestor which has no parent.)

  1070      * sampleModelTranslate specifies the sampleModelTranslateX and

  1071      * sampleModelTranslateY values of the new Raster.

  1072      *

  1073      * Note that this constructor should generally be called by other

  1074      * constructors or create methods, it should not be used directly.

  1075      * @param sampleModel     The SampleModel that specifies the layout

  1076      * @param dataBuffer      The DataBuffer that contains the image data

  1077      * @param aRegion         The Rectangle that specifies the image area

  1078      * @param sampleModelTranslate  The Point that specifies the translation

  1079      *                        from SampleModel to Raster coordinates

  1080      * @param parent          The parent (if any) of this raster

  1081      * @throws NullPointerException if any of <code>sampleModel</code>,

  1082      *         <code>dataBuffer</code>, <code>aRegion</code> or

  1083      *         <code>sampleModelTranslate</code> is null

  1084      * @throws RasterFormatException if <code>aRegion</code> has width

  1085      *         or height less than or equal to zero, or computing either

  1086      *         <code>aRegion.x + aRegion.width</code> or

  1087      *         <code>aRegion.y + aRegion.height</code> results in integer

  1088      *         overflow

  1089      */

  1090     protected Raster(SampleModel sampleModel,

  1091                      DataBuffer dataBuffer,

  1092                      Rectangle aRegion,

  1093                      Point sampleModelTranslate,

  1094                      Raster parent) {

  1095 

  1096         if ((sampleModel == null) || (dataBuffer == null) ||

  1097             (aRegion == null) || (sampleModelTranslate == null)) {

  1098             throw new NullPointerException("SampleModel, dataBuffer, aRegion and " +

  1099                                            "sampleModelTranslate cannot be null");

  1100         }

  1101        this.sampleModel = sampleModel;

  1102        this.dataBuffer = dataBuffer;

  1103        minX = aRegion.x;

  1104        minY = aRegion.y;

  1105        width = aRegion.width;

  1106        height = aRegion.height;

  1107        if (width <= 0 || height <= 0) {

  1108            throw new RasterFormatException("negative or zero " +

  1109                ((width <= 0) ? "width" : "height"));

  1110        }

  1111        if ((minX + width) < minX) {

  1112            throw new RasterFormatException(

  1113                "overflow condition for X coordinates of Raster");

  1114        }

  1115        if ((minY + height) < minY) {

  1116            throw new RasterFormatException(

  1117                "overflow condition for Y coordinates of Raster");

  1118        }

  1119 

  1120        sampleModelTranslateX = sampleModelTranslate.x;

  1121        sampleModelTranslateY = sampleModelTranslate.y;

  1122 

  1123        numBands = sampleModel.getNumBands();

  1124        numDataElements = sampleModel.getNumDataElements();

  1125        this.parent = parent;

  1126     }

  1127 

  1128 

  1129     /**

  1130      * Returns the parent Raster (if any) of this Raster or null.

  1131      * @return the parent Raster or <code>null</code>.

  1132      */

  1133     public Raster getParent() {

  1134         return parent;

  1135     }