View Javadoc
1   /*
2    * Copyright (c) 1997, 2013, 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  package java.awt.image;
37  import java.awt.Rectangle;
38  import java.awt.Point;
39  
40  /**
41   * This class extends Raster to provide pixel writing capabilities.
42   * Refer to the class comment for Raster for descriptions of how
43   * a Raster stores pixels.
44   *
45   * <p> The constructors of this class are protected.  To instantiate
46   * a WritableRaster, use one of the createWritableRaster factory methods
47   * in the Raster class.
48   */
49  public class WritableRaster extends Raster {
50  
51      /**
52       *  Constructs a WritableRaster with the given SampleModel.  The
53       *  WritableRaster's upper left corner is origin and it is the
54       *  same size as the  SampleModel.  A DataBuffer large enough to
55       *  describe the WritableRaster is automatically created.
56       *  @param sampleModel     The SampleModel that specifies the layout.
57       *  @param origin          The Point that specifies the origin.
58       *  @throws RasterFormatException if computing either
59       *          <code>origin.x + sampleModel.getWidth()</code> or
60       *          <code>origin.y + sampleModel.getHeight()</code> results
61       *          in integer overflow
62       */
63      protected WritableRaster(SampleModel sampleModel,
64                               Point origin) {
65          this(sampleModel,
66               sampleModel.createDataBuffer(),
67               new Rectangle(origin.x,
68                             origin.y,
69                             sampleModel.getWidth(),
70                             sampleModel.getHeight()),
71               origin,
72               null);
73      }
74  
75      /**
76       *  Constructs a WritableRaster with the given SampleModel and DataBuffer.
77       *  The WritableRaster's upper left corner is origin and it is the same
78       *  size as the SampleModel.  The DataBuffer is not initialized and must
79       *  be compatible with SampleModel.
80       *  @param sampleModel     The SampleModel that specifies the layout.
81       *  @param dataBuffer      The DataBuffer that contains the image data.
82       *  @param origin          The Point that specifies the origin.
83       *  @throws RasterFormatException if computing either
84       *          <code>origin.x + sampleModel.getWidth()</code> or
85       *          <code>origin.y + sampleModel.getHeight()</code> results
86       *          in integer overflow
87       */
88      protected WritableRaster(SampleModel sampleModel,
89                               DataBuffer dataBuffer,
90                               Point origin) {
91          this(sampleModel,
92               dataBuffer,
93               new Rectangle(origin.x,
94                             origin.y,
95                             sampleModel.getWidth(),
96                             sampleModel.getHeight()),
97               origin,
98               null);
99      }
100 
101     /**
102      * Constructs a WritableRaster with the given SampleModel, DataBuffer,
103      * and parent.  aRegion specifies the bounding rectangle of the new
104      * Raster.  When translated into the base Raster's coordinate
105      * system, aRegion must be contained by the base Raster.
106      * (The base Raster is the Raster's ancestor which has no parent.)
107      * sampleModelTranslate specifies the sampleModelTranslateX and
108      * sampleModelTranslateY values of the new Raster.
109      *
110      * Note that this constructor should generally be called by other
111      * constructors or create methods, it should not be used directly.
112      * @param sampleModel     The SampleModel that specifies the layout.
113      * @param dataBuffer      The DataBuffer that contains the image data.
114      * @param aRegion         The Rectangle that specifies the image area.
115      * @param sampleModelTranslate  The Point that specifies the translation
116      *                        from SampleModel to Raster coordinates.
117      * @param parent          The parent (if any) of this raster.
118      * @throws RasterFormatException if <code>aRegion</code> has width
119      *         or height less than or equal to zero, or computing either
120      *         <code>aRegion.x + aRegion.width</code> or
121      *         <code>aRegion.y + aRegion.height</code> results in integer
122      *         overflow
123      */
124     protected WritableRaster(SampleModel sampleModel,
125                              DataBuffer dataBuffer,
126                              Rectangle aRegion,
127                              Point sampleModelTranslate,
128                              WritableRaster parent){
129         super(sampleModel,dataBuffer,aRegion,sampleModelTranslate,parent);
130     }
131 
132     /** Returns the parent WritableRaster (if any) of this WritableRaster,
133      *  or else null.
134      *  @return the parent of this <code>WritableRaster</code>, or
135      *          <code>null</code>.
136      */
137     public WritableRaster getWritableParent() {
138         return (WritableRaster)parent;
139     }
140 
141     /**
142      * Create a WritableRaster with the same size, SampleModel and DataBuffer
143      * as this one, but with a different location.  The new WritableRaster
144      * will possess a reference to the current WritableRaster, accessible
145      * through its getParent() and getWritableParent() methods.
146      *
147      * @param childMinX X coord of the upper left corner of the new Raster.
148      * @param childMinY Y coord of the upper left corner of the new Raster.
149      * @return a <code>WritableRaster</code> the same as this one except
150      *         for the specified location.
151      * @throws RasterFormatException if  computing either
152      *         <code>childMinX + this.getWidth()</code> or
153      *         <code>childMinY + this.getHeight()</code> results in integer
154      *         overflow
155      */
156     public WritableRaster createWritableTranslatedChild(int childMinX,
157                                                         int childMinY) {
158         return createWritableChild(minX,minY,width,height,
159                                    childMinX,childMinY,null);
160     }
161 
162     /**
163      * Returns a new WritableRaster which shares all or part of this
164      * WritableRaster's DataBuffer.  The new WritableRaster will
165      * possess a reference to the current WritableRaster, accessible
166      * through its getParent() and getWritableParent() methods.
167      *
168      * <p> The parentX, parentY, width and height parameters form a
169      * Rectangle in this WritableRaster's coordinate space, indicating
170      * the area of pixels to be shared.  An error will be thrown if
171      * this Rectangle is not contained with the bounds of the current
172      * WritableRaster.
173      *
174      * <p> The new WritableRaster may additionally be translated to a
175      * different coordinate system for the plane than that used by the current
176      * WritableRaster.  The childMinX and childMinY parameters give
177      * the new (x, y) coordinate of the upper-left pixel of the
178      * returned WritableRaster; the coordinate (childMinX, childMinY)
179      * in the new WritableRaster will map to the same pixel as the
180      * coordinate (parentX, parentY) in the current WritableRaster.
181      *
182      * <p> The new WritableRaster may be defined to contain only a
183      * subset of the bands of the current WritableRaster, possibly
184      * reordered, by means of the bandList parameter.  If bandList is
185      * null, it is taken to include all of the bands of the current
186      * WritableRaster in their current order.
187      *
188      * <p> To create a new WritableRaster that contains a subregion of
189      * the current WritableRaster, but shares its coordinate system
190      * and bands, this method should be called with childMinX equal to
191      * parentX, childMinY equal to parentY, and bandList equal to
192      * null.
193      *
194      * @param parentX    X coordinate of the upper left corner in this
195      *                   WritableRaster's coordinates.
196      * @param parentY    Y coordinate of the upper left corner in this
197      *                   WritableRaster's coordinates.
198      * @param w          Width of the region starting at (parentX, parentY).
199      * @param h          Height of the region starting at (parentX, parentY).
200      * @param childMinX  X coordinate of the upper left corner of
201      *                   the returned WritableRaster.
202      * @param childMinY  Y coordinate of the upper left corner of
203      *                   the returned WritableRaster.
204      * @param bandList   Array of band indices, or null to use all bands.
205      * @return a <code>WritableRaster</code> sharing all or part of the
206      *         <code>DataBuffer</code> of this <code>WritableRaster</code>.
207      * @exception RasterFormatException if the subregion is outside of the
208      *                               raster bounds.
209      * @throws RasterFormatException if <code>w</code> or
210      *         <code>h</code>
211      *         is less than or equal to zero, or computing any of
212      *         <code>parentX + w</code>, <code>parentY + h</code>,
213      *         <code>childMinX + w</code>, or
214      *         <code>childMinY + h</code> results in integer
215      *         overflow
216      */
217     public WritableRaster createWritableChild(int parentX, int parentY,
218                                               int w, int h,
219                                               int childMinX, int childMinY,
220                                               int bandList[]) {
221         if (parentX < this.minX) {
222             throw new RasterFormatException("parentX lies outside raster");
223         }
224         if (parentY < this.minY) {
225             throw new RasterFormatException("parentY lies outside raster");
226         }
227         if ((parentX+w < parentX) || (parentX+w > this.width + this.minX)) {
228             throw new RasterFormatException("(parentX + width) is outside raster");
229         }
230         if ((parentY+h < parentY) || (parentY+h > this.height + this.minY)) {
231             throw new RasterFormatException("(parentY + height) is outside raster");
232         }
233 
234         SampleModel sm;
235         // Note: the SampleModel for the child Raster should have the same
236         // width and height as that for the parent, since it represents
237         // the physical layout of the pixel data.  The child Raster's width
238         // and height represent a "virtual" view of the pixel data, so
239         // they may be different than those of the SampleModel.
240         if (bandList != null) {
241             sm = sampleModel.createSubsetSampleModel(bandList);
242         }
243         else {
244             sm = sampleModel;
245         }
246 
247         int deltaX = childMinX - parentX;
248         int deltaY = childMinY - parentY;
249 
250         return new WritableRaster(sm,
251                                   getDataBuffer(),
252                                   new Rectangle(childMinX,childMinY,
253                                                 w, h),
254                                   new Point(sampleModelTranslateX+deltaX,
255                                             sampleModelTranslateY+deltaY),
256                                   this);
257     }
258 
259     /**
260      * Sets the data for a single pixel from a
261      * primitive array of type TransferType.  For image data supported by
262      * the Java 2D(tm) API, this will be one of DataBuffer.TYPE_BYTE,
263      * DataBuffer.TYPE_USHORT, DataBuffer.TYPE_INT, DataBuffer.TYPE_SHORT,
264      * DataBuffer.TYPE_FLOAT, or DataBuffer.TYPE_DOUBLE.  Data in the array
265      * may be in a packed format, thus increasing efficiency for data
266      * transfers.
267      * An ArrayIndexOutOfBoundsException may be thrown if the coordinates are
268      * not in bounds, or if inData is not large enough to hold the pixel data.
269      * However, explicit bounds checking is not guaranteed.
270      * A ClassCastException will be thrown if the input object is not null
271      * and references anything other than an array of TransferType.
272      * @see java.awt.image.SampleModel#setDataElements(int, int, Object, DataBuffer)
273      * @param x        The X coordinate of the pixel location.
274      * @param y        The Y coordinate of the pixel location.
275      * @param inData   An object reference to an array of type defined by
276      *                 getTransferType() and length getNumDataElements()
277      *                 containing the pixel data to place at x,y.
278      *
279      * @throws ArrayIndexOutOfBoundsException if the coordinates are not
280      * in bounds, or if inData is too small to hold the input.
281      */
282     public void setDataElements(int x, int y, Object inData) {
283         sampleModel.setDataElements(x-sampleModelTranslateX,
284                                     y-sampleModelTranslateY,
285                                     inData, dataBuffer);
286     }
287 
288     /**
289      * Sets the data for a rectangle of pixels from an input Raster.
290      * The input Raster must be compatible with this WritableRaster
291      * in that they must have the same number of bands, corresponding bands
292      * must have the same number of bits per sample, the TransferTypes
293      * and NumDataElements must be the same, and the packing used by
294      * the getDataElements/setDataElements must be identical.
295      * An ArrayIndexOutOfBoundsException may be thrown if the coordinates are
296      * not in bounds.
297      * However, explicit bounds checking is not guaranteed.
298      * @param x        The X coordinate of the pixel location.
299      * @param y        The Y coordinate of the pixel location.
300      * @param inRaster Raster containing data to place at x,y.
301      *
302      * @throws NullPointerException if inRaster is null.
303      * @throws ArrayIndexOutOfBoundsException if the coordinates are not
304      * in bounds.
305      */
306     public void setDataElements(int x, int y, Raster inRaster) {
307         int dstOffX = x+inRaster.getMinX();
308         int dstOffY = y+inRaster.getMinY();
309         int width  = inRaster.getWidth();
310         int height = inRaster.getHeight();
311         if ((dstOffX < this.minX) || (dstOffY < this.minY) ||
312             (dstOffX + width > this.minX + this.width) ||
313             (dstOffY + height > this.minY + this.height)) {
314             throw new ArrayIndexOutOfBoundsException
315                 ("Coordinate out of bounds!");
316         }
317 
318         int srcOffX = inRaster.getMinX();
319         int srcOffY = inRaster.getMinY();
320         Object tdata = null;
321 
322         for (int startY=0; startY < height; startY++) {
323             tdata = inRaster.getDataElements(srcOffX, srcOffY+startY,
324                                              width, 1, tdata);
325             setDataElements(dstOffX, dstOffY+startY,
326                             width, 1, tdata);
327         }
328     }
329 
330     /**
331      * Sets the data for a rectangle of pixels from a
332      * primitive array of type TransferType.  For image data supported by
333      * the Java 2D API, this will be one of DataBuffer.TYPE_BYTE,
334      * DataBuffer.TYPE_USHORT, DataBuffer.TYPE_INT, DataBuffer.TYPE_SHORT,
335      * DataBuffer.TYPE_FLOAT, or DataBuffer.TYPE_DOUBLE.  Data in the array
336      * may be in a packed format, thus increasing efficiency for data
337      * transfers.
338      * An ArrayIndexOutOfBoundsException may be thrown if the coordinates are
339      * not in bounds, or if inData is not large enough to hold the pixel data.
340      * However, explicit bounds checking is not guaranteed.
341      * A ClassCastException will be thrown if the input object is not null
342      * and references anything other than an array of TransferType.
343      * @see java.awt.image.SampleModel#setDataElements(int, int, int, int, Object, DataBuffer)
344      * @param x        The X coordinate of the upper left pixel location.
345      * @param y        The Y coordinate of the upper left pixel location.
346      * @param w        Width of the pixel rectangle.
347      * @param h        Height of the pixel rectangle.
348      * @param inData   An object reference to an array of type defined by
349      *                 getTransferType() and length w*h*getNumDataElements()
350      *                 containing the pixel data to place between x,y and
351      *                 x+w-1, y+h-1.
352      *
353      * @throws NullPointerException if inData is null.
354      * @throws ArrayIndexOutOfBoundsException if the coordinates are not
355      * in bounds, or if inData is too small to hold the input.
356      */
357     public void setDataElements(int x, int y, int w, int h, Object inData) {
358         sampleModel.setDataElements(x-sampleModelTranslateX,
359                                     y-sampleModelTranslateY,
360                                     w,h,inData,dataBuffer);
361     }
362 
363     /**
364      * Copies pixels from Raster srcRaster to this WritableRaster.  Each pixel
365      * in srcRaster is copied to the same x,y address in this raster, unless
366      * the address falls outside the bounds of this raster.  srcRaster
367      * must have the same number of bands as this WritableRaster.  The
368      * copy is a simple copy of source samples to the corresponding destination
369      * samples.
370      * <p>
371      * If all samples of both source and destination Rasters are of
372      * integral type and less than or equal to 32 bits in size, then calling
373      * this method is equivalent to executing the following code for all
374      * <code>x,y</code> addresses valid in both Rasters.
375      * <pre>{@code
376      *       Raster srcRaster;
377      *       WritableRaster dstRaster;
378      *       for (int b = 0; b < srcRaster.getNumBands(); b++) {
379      *           dstRaster.setSample(x, y, b, srcRaster.getSample(x, y, b));
380      *       }
381      * }</pre>
382      * Thus, when copying an integral type source to an integral type
383      * destination, if the source sample size is greater than the destination
384      * sample size for a particular band, the high order bits of the source
385      * sample are truncated.  If the source sample size is less than the
386      * destination size for a particular band, the high order bits of the
387      * destination are zero-extended or sign-extended depending on whether
388      * srcRaster's SampleModel treats the sample as a signed or unsigned
389      * quantity.
390      * <p>
391      * When copying a float or double source to an integral type destination,
392      * each source sample is cast to the destination type.  When copying an
393      * integral type source to a float or double destination, the source
394      * is first converted to a 32-bit int (if necessary), using the above
395      * rules for integral types, and then the int is cast to float or
396      * double.
397      * <p>
398      * @param srcRaster  The  Raster from which to copy pixels.
399      *
400      * @throws NullPointerException if srcRaster is null.
401      */
402     public void setRect(Raster srcRaster) {
403         setRect(0,0,srcRaster);
404     }
405 
406     /**
407      * Copies pixels from Raster srcRaster to this WritableRaster.
408      * For each (x, y) address in srcRaster, the corresponding pixel
409      * is copied to address (x+dx, y+dy) in this WritableRaster,
410      * unless (x+dx, y+dy) falls outside the bounds of this raster.
411      * srcRaster must have the same number of bands as this WritableRaster.
412      * The copy is a simple copy of source samples to the corresponding
413      * destination samples.  For details, see
414      * {@link WritableRaster#setRect(Raster)}.
415      *
416      * @param dx        The X translation factor from src space to dst space
417      *                  of the copy.
418      * @param dy        The Y translation factor from src space to dst space
419      *                  of the copy.
420      * @param srcRaster The Raster from which to copy pixels.
421      *
422      * @throws NullPointerException if srcRaster is null.
423      */
424     public void setRect(int dx, int dy, Raster srcRaster) {
425         int width  = srcRaster.getWidth();
426         int height = srcRaster.getHeight();
427         int srcOffX = srcRaster.getMinX();
428         int srcOffY = srcRaster.getMinY();
429         int dstOffX = dx+srcOffX;
430         int dstOffY = dy+srcOffY;
431 
432         // Clip to this raster
433         if (dstOffX < this.minX) {
434             int skipX = this.minX - dstOffX;
435             width -= skipX;
436             srcOffX += skipX;
437             dstOffX = this.minX;
438         }
439         if (dstOffY < this.minY) {
440             int skipY = this.minY - dstOffY;
441             height -= skipY;
442             srcOffY += skipY;
443             dstOffY = this.minY;
444         }
445         if (dstOffX+width > this.minX+this.width) {
446             width = this.minX + this.width - dstOffX;
447         }
448         if (dstOffY+height > this.minY+this.height) {
449             height = this.minY + this.height - dstOffY;
450         }
451 
452         if (width <= 0 || height <= 0) {
453             return;
454         }
455 
456         switch (srcRaster.getSampleModel().getDataType()) {
457         case DataBuffer.TYPE_BYTE:
458         case DataBuffer.TYPE_SHORT:
459         case DataBuffer.TYPE_USHORT:
460         case DataBuffer.TYPE_INT:
461             int[] iData = null;
462             for (int startY=0; startY < height; startY++) {
463                 // Grab one scanline at a time
464                 iData =
465                     srcRaster.getPixels(srcOffX, srcOffY+startY, width, 1,
466                                         iData);
467                 setPixels(dstOffX, dstOffY+startY, width, 1, iData);
468             }
469             break;
470 
471         case DataBuffer.TYPE_FLOAT:
472             float[] fData = null;
473             for (int startY=0; startY < height; startY++) {
474                 fData =
475                     srcRaster.getPixels(srcOffX, srcOffY+startY, width, 1,
476                                         fData);
477                 setPixels(dstOffX, dstOffY+startY, width, 1, fData);
478             }
479             break;
480 
481         case DataBuffer.TYPE_DOUBLE:
482             double[] dData = null;
483             for (int startY=0; startY < height; startY++) {
484                 // Grab one scanline at a time
485                 dData =
486                     srcRaster.getPixels(srcOffX, srcOffY+startY, width, 1,
487                                         dData);
488                 setPixels(dstOffX, dstOffY+startY, width, 1, dData);
489             }
490             break;
491         }
492     }
493 
494     /**
495      * Sets a pixel in the DataBuffer using an int array of samples for input.
496      * An ArrayIndexOutOfBoundsException may be thrown if the coordinates are
497      * not in bounds.
498      * However, explicit bounds checking is not guaranteed.
499      * @param x      The X coordinate of the pixel location.
500      * @param y      The Y coordinate of the pixel location.
501      * @param iArray The input samples in a int array.
502      *
503      * @throws NullPointerException if iArray is null.
504      * @throws ArrayIndexOutOfBoundsException if the coordinates are not
505      * in bounds, or if iArray is too small to hold the input.
506      */
507     public void setPixel(int x, int y, int iArray[]) {
508         sampleModel.setPixel(x-sampleModelTranslateX,y-sampleModelTranslateY,
509                              iArray,dataBuffer);
510     }
511 
512     /**
513      * Sets a pixel in the DataBuffer using a float array of samples for input.
514      * An ArrayIndexOutOfBoundsException may be thrown if the coordinates are
515      * not in bounds.
516      * However, explicit bounds checking is not guaranteed.
517      * @param x      The X coordinate of the pixel location.
518      * @param y      The Y coordinate of the pixel location.
519      * @param fArray The input samples in a float array.
520      *
521      * @throws NullPointerException if fArray is null.
522      * @throws ArrayIndexOutOfBoundsException if the coordinates are not
523      * in bounds, or if fArray is too small to hold the input.
524      */
525     public void setPixel(int x, int y, float fArray[]) {
526         sampleModel.setPixel(x-sampleModelTranslateX,y-sampleModelTranslateY,
527                              fArray,dataBuffer);
528     }
529 
530     /**
531      * Sets a pixel in the DataBuffer using a double array of samples for input.
532      * An ArrayIndexOutOfBoundsException may be thrown if the coordinates are
533      * not in bounds.
534      * However, explicit bounds checking is not guaranteed.
535      * @param x      The X coordinate of the pixel location.
536      * @param y      The Y coordinate of the pixel location.
537      * @param dArray The input samples in a double array.
538      *
539      * @throws NullPointerException if dArray is null.
540      * @throws ArrayIndexOutOfBoundsException if the coordinates are not
541      * in bounds, or if dArray is too small to hold the input.
542      */
543     public void setPixel(int x, int y, double dArray[]) {
544         sampleModel.setPixel(x-sampleModelTranslateX,y-sampleModelTranslateY,
545                              dArray,dataBuffer);
546     }
547 
548     /**
549      * Sets all samples for a rectangle of pixels from an int array containing
550      * one sample per array element.
551      * An ArrayIndexOutOfBoundsException may be thrown if the coordinates are
552      * not in bounds.
553      * However, explicit bounds checking is not guaranteed.
554      * @param x        The X coordinate of the upper left pixel location.
555      * @param y        The Y coordinate of the upper left pixel location.
556      * @param w        Width of the pixel rectangle.
557      * @param h        Height of the pixel rectangle.
558      * @param iArray   The input int pixel array.
559      *
560      * @throws NullPointerException if iArray is null.
561      * @throws ArrayIndexOutOfBoundsException if the coordinates are not
562      * in bounds, or if iArray is too small to hold the input.
563      */
564     public void setPixels(int x, int y, int w, int h, int iArray[]) {
565         sampleModel.setPixels(x-sampleModelTranslateX,y-sampleModelTranslateY,
566                               w,h,iArray,dataBuffer);
567     }
568 
569     /**
570      * Sets all samples for a rectangle of pixels from a float array containing
571      * one sample per array element.
572      * An ArrayIndexOutOfBoundsException may be thrown if the coordinates are
573      * not in bounds.
574      * However, explicit bounds checking is not guaranteed.
575      * @param x        The X coordinate of the upper left pixel location.
576      * @param y        The Y coordinate of the upper left pixel location.
577      * @param w        Width of the pixel rectangle.
578      * @param h        Height of the pixel rectangle.
579      * @param fArray   The input float pixel array.
580      *
581      * @throws NullPointerException if fArray is null.
582      * @throws ArrayIndexOutOfBoundsException if the coordinates are not
583      * in bounds, or if fArray is too small to hold the input.
584      */
585     public void setPixels(int x, int y, int w, int h, float fArray[]) {
586         sampleModel.setPixels(x-sampleModelTranslateX,y-sampleModelTranslateY,
587                               w,h,fArray,dataBuffer);
588     }
589 
590     /**
591      * Sets all samples for a rectangle of pixels from a double array containing
592      * one sample per array element.
593      * An ArrayIndexOutOfBoundsException may be thrown if the coordinates are
594      * not in bounds.
595      * However, explicit bounds checking is not guaranteed.
596      * @param x        The X coordinate of the upper left pixel location.
597      * @param y        The Y coordinate of the upper left pixel location.
598      * @param w        Width of the pixel rectangle.
599      * @param h        Height of the pixel rectangle.
600      * @param dArray   The input double pixel array.
601      *
602      * @throws NullPointerException if dArray is null.
603      * @throws ArrayIndexOutOfBoundsException if the coordinates are not
604      * in bounds, or if dArray is too small to hold the input.
605      */
606     public void setPixels(int x, int y, int w, int h, double dArray[]) {
607         sampleModel.setPixels(x-sampleModelTranslateX,y-sampleModelTranslateY,
608                               w,h,dArray,dataBuffer);
609     }
610 
611     /**
612      * Sets a sample in the specified band for the pixel located at (x,y)
613      * in the DataBuffer using an int for input.
614      * An ArrayIndexOutOfBoundsException may be thrown if the coordinates are
615      * not in bounds.
616      * However, explicit bounds checking is not guaranteed.
617      * @param x        The X coordinate of the pixel location.
618      * @param y        The Y coordinate of the pixel location.
619      * @param b        The band to set.
620      * @param s        The input sample.
621      *
622      * @throws ArrayIndexOutOfBoundsException if the coordinates or
623      * the band index are not in bounds.
624      */
625     public void setSample(int x, int y, int b, int s) {
626         sampleModel.setSample(x-sampleModelTranslateX,
627                               y-sampleModelTranslateY, b, s,
628                               dataBuffer);
629     }
630 
631     /**
632      * Sets a sample in the specified band for the pixel located at (x,y)
633      * in the DataBuffer using a float for input.
634      * An ArrayIndexOutOfBoundsException may be thrown if the coordinates are
635      * not in bounds.
636      * However, explicit bounds checking is not guaranteed.
637      * @param x        The X coordinate of the pixel location.
638      * @param y        The Y coordinate of the pixel location.
639      * @param b        The band to set.
640      * @param s        The input sample as a float.
641      *
642      * @throws ArrayIndexOutOfBoundsException if the coordinates or
643      * the band index are not in bounds.
644      */
645     public void setSample(int x, int y, int b, float s){
646         sampleModel.setSample(x-sampleModelTranslateX,y-sampleModelTranslateY,
647                               b,s,dataBuffer);
648     }
649 
650     /**
651      * Sets a sample in the specified band for the pixel located at (x,y)
652      * in the DataBuffer using a double for input.
653      * An ArrayIndexOutOfBoundsException may be thrown if the coordinates are
654      * not in bounds.
655      * However, explicit bounds checking is not guaranteed.
656      * @param x        The X coordinate of the pixel location.
657      * @param y        The Y coordinate of the pixel location.
658      * @param b        The band to set.
659      * @param s        The input sample as a double.
660      *
661      * @throws ArrayIndexOutOfBoundsException if the coordinates or
662      * the band index are not in bounds.
663      */
664     public void setSample(int x, int y, int b, double s){
665         sampleModel.setSample(x-sampleModelTranslateX,y-sampleModelTranslateY,
666                                     b,s,dataBuffer);
667     }
668 
669     /**
670      * Sets the samples in the specified band for the specified rectangle
671      * of pixels from an int array containing one sample per array element.
672      * An ArrayIndexOutOfBoundsException may be thrown if the coordinates are
673      * not in bounds.
674      * However, explicit bounds checking is not guaranteed.
675      * @param x        The X coordinate of the upper left pixel location.
676      * @param y        The Y coordinate of the upper left pixel location.
677      * @param w        Width of the pixel rectangle.
678      * @param h        Height of the pixel rectangle.
679      * @param b        The band to set.
680      * @param iArray   The input int sample array.
681      *
682      * @throws NullPointerException if iArray is null.
683      * @throws ArrayIndexOutOfBoundsException if the coordinates or
684      * the band index are not in bounds, or if iArray is too small to
685      * hold the input.
686      */
687     public void setSamples(int x, int y, int w, int h, int b,
688                            int iArray[]) {
689         sampleModel.setSamples(x-sampleModelTranslateX,y-sampleModelTranslateY,
690                                w,h,b,iArray,dataBuffer);
691     }
692 
693     /**
694      * Sets the samples in the specified band for the specified rectangle
695      * of pixels from a float array containing one sample per array element.
696      * An ArrayIndexOutOfBoundsException may be thrown if the coordinates are
697      * not in bounds.
698      * However, explicit bounds checking is not guaranteed.
699      * @param x        The X coordinate of the upper left pixel location.
700      * @param y        The Y coordinate of the upper left pixel location.
701      * @param w        Width of the pixel rectangle.
702      * @param h        Height of the pixel rectangle.
703      * @param b        The band to set.
704      * @param fArray   The input float sample array.
705      *
706      * @throws NullPointerException if fArray is null.
707      * @throws ArrayIndexOutOfBoundsException if the coordinates or
708      * the band index are not in bounds, or if fArray is too small to
709      * hold the input.
710      */
711     public void setSamples(int x, int y, int w, int h, int b,
712                            float fArray[]) {
713         sampleModel.setSamples(x-sampleModelTranslateX,y-sampleModelTranslateY,
714                                w,h,b,fArray,dataBuffer);
715     }
716 
717     /**
718      * Sets the samples in the specified band for the specified rectangle
719      * of pixels from a double array containing one sample per array element.
720      * An ArrayIndexOutOfBoundsException may be thrown if the coordinates are
721      * not in bounds.
722      * However, explicit bounds checking is not guaranteed.
723      * @param x        The X coordinate of the upper left pixel location.
724      * @param y        The Y coordinate of the upper left pixel location.
725      * @param w        Width of the pixel rectangle.
726      * @param h        Height of the pixel rectangle.
727      * @param b        The band to set.
728      * @param dArray   The input double sample array.
729      *
730      * @throws NullPointerException if dArray is null.
731      * @throws ArrayIndexOutOfBoundsException if the coordinates or
732      * the band index are not in bounds, or if dArray is too small to
733      * hold the input.
734      */
735     public void setSamples(int x, int y, int w, int h, int b,
736                            double dArray[]) {
737         sampleModel.setSamples(x-sampleModelTranslateX,y-sampleModelTranslateY,
738                               w,h,b,dArray,dataBuffer);
739     }
740 
741 }