Java > Open Source Codes > java > awt > image > SampleModel


1 /*
2  * @(#)SampleModel.java 1.36 03/12/19
3  *
4  * Copyright 2004 Sun Microsystems, Inc. All rights reserved.
5  * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
6  */
7
8 /* ****************************************************************
9  ******************************************************************
10  ******************************************************************
11  *** COPYRIGHT (c) Eastman Kodak Company, 1997
12  *** As an unpublished work pursuant to Title 17 of the United
13  *** States Code. All rights reserved.
14  ******************************************************************
15  ******************************************************************
16  ******************************************************************/
17
18 package java.awt.image;
19
20 /**
21  * This abstract class defines an interface for extracting samples of pixels
22  * in an image. All image data is expressed as a collection of pixels.
23  * Each pixel consists of a number of samples. A sample is a datum
24  * for one band of an image and a band consists of all samples of a
25  * particular type in an image. For example, a pixel might contain
26  * three samples representing its red, green and blue components.
27  * There are three bands in the image containing this pixel. One band
28  * consists of all the red samples from all pixels in the
29  * image. The second band consists of all the green samples and
30  * the remaining band consists of all of the blue samples. The pixel
31  * can be stored in various formats. For example, all samples from
32  * a particular band can be stored contiguously or all samples from a
33  * single pixel can be stored contiguously.
34  * <p>
35  * Subclasses of SampleModel specify the types of samples they can
36  * represent (e.g. unsigned 8-bit byte, signed 16-bit short, etc.)
37  * and may specify how the samples are organized in memory.
38  * In the Java 2D(tm) API, built-in image processing operators may
39  * not operate on all possible sample types, but generally will work
40  * for unsigned integral samples of 16 bits or less. Some operators
41  * support a wider variety of sample types.
42  * <p>
43  * A collection of pixels is represented as a Raster, which consists of
44  * a DataBuffer and a SampleModel. The SampleModel allows access to
45  * samples in the DataBuffer and may provide low-level information that
46  * a programmer can use to directly manipulate samples and pixels in the
47  * DataBuffer.
48  * <p>
49  * This class is generally a fall back method for dealing with
50  * images. More efficient code will cast the SampleModel to the
51  * appropriate subclass and extract the information needed to directly
52  * manipulate pixels in the DataBuffer.
53  *
54  * @see java.awt.image.DataBuffer
55  * @see java.awt.image.Raster
56  * @see java.awt.image.ComponentSampleModel
57  * @see java.awt.image.PixelInterleavedSampleModel
58  * @see java.awt.image.BandedSampleModel
59  * @see java.awt.image.MultiPixelPackedSampleModel
60  * @see java.awt.image.SinglePixelPackedSampleModel
61  */
62
63 public abstract class SampleModel
64 {
65
66     /** Width in pixels of the region of image data that this SampleModel
67      * describes.
68      */
69     protected int width;
70
71     /** Height in pixels of the region of image data that this SampleModel
72      * describes.
73      */
74     protected int height;
75
76     /** Number of bands of the image data that this SampleModel describes. */
77     protected int numBands;
78
79     /** Data type of the DataBuffer storing the pixel data.
80      * @see java.awt.image.DataBuffer
81      */
82     protected int dataType;
83
84     static private native void initIDs();
85     static {
86         ColorModel.loadLibraries();
87         initIDs();
88     }
89
90     /**
91      * Constructs a SampleModel with the specified parameters.
92      * @param dataType The data type of the DataBuffer storing the pixel data.
93      * @param w The width (in pixels) of the region of image data.
94      * @param h The height (in pixels) of the region of image data.
95      * @param numBands The number of bands of the image data.
96      * @throws IllegalArgumentException if <code>w</code> or <code>h</code>
97      * is not greater than 0
98      * @throws IllegalArgumentException if the product of <code>w</code>
99      * and <code>h</code> is greater than
100      * <code>Integer.MAX_VALUE</code>
101      * @throws IllegalArgumentException if <code>dataType</code> is not
102      * one of the supported data types
103      */
104     public SampleModel(int dataType, int w, int h, int numBands)
105     {
106         float size = (float)w*h;
107         if (w <= 0 || h <= 0) {
108             throw new IllegalArgumentException ("Width ("+w+") and height ("+
109                                                h+") must be > 0");
110         }
111         if (size >= Integer.MAX_VALUE) {
112             throw new IllegalArgumentException ("Dimensions (width="+w+
113                                                " height="+h+") are too large");
114         }
115
116         if (dataType < DataBuffer.TYPE_BYTE ||
117             (dataType > DataBuffer.TYPE_DOUBLE &&
118              dataType != DataBuffer.TYPE_UNDEFINED))
119         {
120             throw new IllegalArgumentException ("Unsupported dataType: "+
121                                                dataType);
122         }
123
124         if (numBands <= 0) {
125             throw new IllegalArgumentException ("Number of bands must be > 0");
126         }
127         
128     this.dataType = dataType;
129     this.width = w;
130     this.height = h;
131     this.numBands = numBands;
132     }
133
134     /** Returns the width in pixels.
135      * @return the width in pixels of the region of image data
136      * that this <code>SampleModel</code> describes.
137      */
138     final public int getWidth() {
139      return width;
140     }
141
142     /** Returns the height in pixels.
143      * @return the height in pixels of the region of image data
144      * that this <code>SampleModel</code> describes.
145      */
146     final public int getHeight() {
147      return height;
148     }
149
150     /** Returns the total number of bands of image data.
151      * @return the number of bands of image data that this
152      * <code>SampleModel</code> describes.
153      */
154     final public int getNumBands() {
155      return numBands;
156     }
157
158     /** Returns the number of data elements needed to transfer a pixel
159      * via the getDataElements and setDataElements methods. When pixels
160      * are transferred via these methods, they may be transferred in a
161      * packed or unpacked format, depending on the implementation of the
162      * SampleModel. Using these methods, pixels are transferred as an
163      * array of getNumDataElements() elements of a primitive type given
164      * by getTransferType(). The TransferType may or may not be the same
165      * as the storage DataType.
166      * @return the number of data elements.
167      * @see #getDataElements(int, int, Object, DataBuffer)
168      * @see #getDataElements(int, int, int, int, Object, DataBuffer)
169      * @see #setDataElements(int, int, Object, DataBuffer)
170      * @see #setDataElements(int, int, int, int, Object, DataBuffer)
171      * @see #getTransferType
172      */
173     public abstract int getNumDataElements();
174     
175     /** Returns the data type of the DataBuffer storing the pixel data.
176      * @return the data type.
177      */
178     final public int getDataType() {
179     return dataType;
180     }
181
182     /** Returns the TransferType used to transfer pixels via the
183      * getDataElements and setDataElements methods. When pixels
184      * are transferred via these methods, they may be transferred in a
185      * packed or unpacked format, depending on the implementation of the
186      * SampleModel. Using these methods, pixels are transferred as an
187      * array of getNumDataElements() elements of a primitive type given
188      * by getTransferType(). The TransferType may or may not be the same
189      * as the storage DataType. The TransferType will be one of the types
190      * defined in DataBuffer.
191      * @return the transfer type.
192      * @see #getDataElements(int, int, Object, DataBuffer)
193      * @see #getDataElements(int, int, int, int, Object, DataBuffer)
194      * @see #setDataElements(int, int, Object, DataBuffer)
195      * @see #setDataElements(int, int, int, int, Object, DataBuffer)
196      * @see #getNumDataElements
197      * @see java.awt.image.DataBuffer
198      */
199     public int getTransferType() {
200         return dataType;
201     }
202
203     /**
204      * Returns the samples for a specified pixel in an int array,
205      * one sample per array element.
206      * ArrayIndexOutOfBoundsException may be thrown if the coordinates are
207      * not in bounds.
208      * @param x,&nbsp;y The coordinates of the pixel location
209      * @param iArray If non-null, returns the samples in this array
210      * @param data The DataBuffer containing the image data
211      * @return the samples for the specified pixel.
212      * @see #setPixel(int, int, int[], DataBuffer)
213      *
214      * @throws NullPointerException if data is null.
215      * @throws ArrayIndexOutOfBoundsException if the coordinates are
216      * not in bounds, or if iArray is too small to hold the output.
217      */
218     public int[] getPixel(int x, int y, int iArray[], DataBuffer data) {
219
220     int pixels[];
221
222     if (iArray != null)
223         pixels = iArray;
224     else
225         pixels = new int[numBands];
226
227     for (int i=0; i<numBands; i++) {
228         pixels[i] = getSample(x, y, i, data);
229     }
230
231     return pixels;
232     }
233
234     /**
235      * Returns data for a single pixel in a primitive array of type
236      * TransferType. For image data supported by the Java 2D API, this
237      * will be one of DataBuffer.TYPE_BYTE, DataBuffer.TYPE_USHORT,
238      * DataBuffer.TYPE_INT, DataBuffer.TYPE_SHORT, DataBuffer.TYPE_FLOAT,
239      * or DataBuffer.TYPE_DOUBLE. Data may be returned in a packed format,
240      * thus increasing efficiency for data transfers. Generally, obj
241      * should be passed in as null, so that the Object will be created
242      * automatically and will be of the right primitive data type.
243      * <p>
244      * The following code illustrates transferring data for one pixel from
245      * DataBuffer <code>db1</code>, whose storage layout is described by
246      * SampleModel <code>sm1</code>, to DataBuffer <code>db2</code>, whose
247      * storage layout is described by SampleModel <code>sm2</code>.
248      * The transfer will generally be more efficient than using
249      * getPixel/setPixel.
250      * <pre>
251      * SampleModel sm1, sm2;
252      * DataBuffer db1, db2;
253      * sm2.setDataElements(x, y, sm1.getDataElements(x, y, null, db1), db2);
254      * </pre>
255      * Using getDataElements/setDataElements to transfer between two
256      * DataBuffer/SampleModel pairs is legitimate if the SampleModels have
257      * the same number of bands, corresponding bands have the same number of
258      * bits per sample, and the TransferTypes are the same.
259      * <p>
260      * If obj is non-null, it should be a primitive array of type TransferType.
261      * Otherwise, a ClassCastException is thrown. An
262      * ArrayIndexOutOfBoundsException may be thrown if the coordinates are
263      * not in bounds, or if obj is non-null and is not large enough to hold
264      * the pixel data.
265      * @param x The X coordinate of the pixel location.
266      * @param y The Y coordinate of the pixel location.
267      * @param obj If non-null, a primitive array in which to return
268      * the pixel data.
269      * @param data The DataBuffer containing the image data.
270      * @return the data elements for the specified pixel.
271      * @see #getNumDataElements
272      * @see #getTransferType
273      * @see java.awt.image.DataBuffer
274      * @see #setDataElements(int, int, Object, DataBuffer)
275      *
276      * @throws NullPointerException if data is null.
277      * @throws ArrayIndexOutOfBoundsException if the coordinates are
278      * not in bounds, or if obj is too small to hold the output.
279      */
280     public abstract Object getDataElements(int x, int y,
281                                            Object obj, DataBuffer data);
282
283     /**
284      * Returns the pixel data for the specified rectangle of pixels in a
285      * primitive array of type TransferType.
286      * For image data supported by the Java 2D API, this
287      * will be one of DataBuffer.TYPE_BYTE, DataBuffer.TYPE_USHORT,
288      * DataBuffer.TYPE_INT, DataBuffer.TYPE_SHORT, DataBuffer.TYPE_FLOAT,
289      * or DataBuffer.TYPE_DOUBLE. Data may be returned in a packed format,
290      * thus increasing efficiency for data transfers. Generally, obj
291      * should be passed in as null, so that the Object will be created
292      * automatically and will be of the right primitive data type.
293      * <p>
294      * The following code illustrates transferring data for a rectangular
295      * region of pixels from
296      * DataBuffer <code>db1</code>, whose storage layout is described by
297      * SampleModel <code>sm1</code>, to DataBuffer <code>db2</code>, whose
298      * storage layout is described by SampleModel <code>sm2</code>.
299      * The transfer will generally be more efficient than using
300      * getPixels/setPixels.
301      * <pre>
302      * SampleModel sm1, sm2;
303      * DataBuffer db1, db2;
304      * sm2.setDataElements(x, y, w, h, sm1.getDataElements(x, y, w,
305      * h, null, db1), db2);
306      * </pre>
307      * Using getDataElements/setDataElements to transfer between two
308      * DataBuffer/SampleModel pairs is legitimate if the SampleModels have
309      * the same number of bands, corresponding bands have the same number of
310      * bits per sample, and the TransferTypes are the same.
311      * <p>
312      * If obj is non-null, it should be a primitive array of type TransferType.
313      * Otherwise, a ClassCastException is thrown. An
314      * ArrayIndexOutOfBoundsException may be thrown if the coordinates are
315      * not in bounds, or if obj is non-null and is not large enough to hold
316      * the pixel data.
317      * @param x The minimum X coordinate of the pixel rectangle.
318      * @param y The minimum Y coordinate of the pixel rectangle.
319      * @param w The width of the pixel rectangle.
320      * @param h The height of the pixel rectangle.
321      * @param obj If non-null, a primitive array in which to return
322      * the pixel data.
323      * @param data The DataBuffer containing the image data.
324      * @return the data elements for the specified region of pixels.
325      * @see #getNumDataElements
326      * @see #getTransferType
327      * @see #setDataElements(int, int, int, int, Object, DataBuffer)
328      * @see java.awt.image.DataBuffer
329      *
330      * @throws NullPointerException if data is null.
331      * @throws ArrayIndexOutOfBoundsException if the coordinates are
332      * not in bounds, or if obj is too small to hold the output.
333      */
334     public Object getDataElements(int x, int y, int w, int h,
335                                   Object obj, DataBuffer data) {
336
337     int type = getTransferType();
338     int numDataElems = getNumDataElements();
339     int cnt = 0;
340     Object o = null;
341
342     switch(type) {
343
344     case DataBuffer.TYPE_BYTE:
345
346         byte[] btemp;
347         byte[] bdata;
348
349         if (obj == null)
350         bdata = new byte[numDataElems*w*h];
351         else
352         bdata = (byte[])obj;
353
354         for (int i=y; i<y+h; i++) {
355         for (int j=x; j<x+w; j++) {
356             o = getDataElements(j, i, o, data);
357             btemp = (byte[])o;
358             for (int k=0; k<numDataElems; k++) {
359             bdata[cnt++] = btemp[k];
360             }
361         }
362         }
363         obj = (Object )bdata;
364         break;
365
366     case DataBuffer.TYPE_USHORT:
367     case DataBuffer.TYPE_SHORT:
368
369         short[] sdata;
370         short[] stemp;
371
372         if (obj == null)
373         sdata = new short[numDataElems*w*h];
374         else
375         sdata = (short[])obj;
376
377         for (int i=y; i<y+h; i++) {
378         for (int j=x; j<x+w; j++) {
379             o = getDataElements(j, i, o, data);
380             stemp = (short[])o;
381             for (int k=0; k<numDataElems; k++) {
382             sdata[cnt++] = stemp[k];
383             }
384         }
385         }
386
387         obj = (Object )sdata;
388         break;
389
390     case DataBuffer.TYPE_INT:
391
392         int[] idata;
393         int[] itemp;
394
395         if (obj == null)
396         idata = new int[numDataElems*w*h];
397         else
398         idata = (int[])obj;
399
400         for (int i=y; i<y+h; i++) {
401         for (int j=x; j<x+w; j++) {
402             o = getDataElements(j, i, o, data);
403             itemp = (int[])o;
404             for (int k=0; k<numDataElems; k++) {
405             idata[cnt++] = itemp[k];
406             }
407         }
408         }
409
410         obj = (Object )idata;
411         break;
412
413     case DataBuffer.TYPE_FLOAT:
414
415         float[] fdata;
416         float[] ftemp;
417
418         if (obj == null)
419         fdata = new float[numDataElems*w*h];
420         else
421         fdata = (float[])obj;
422
423         for (int i=y; i<y+h; i++) {
424         for (int j=x; j<x+w; j++) {
425             o = getDataElements(j, i, o, data);
426             ftemp = (float[])o;
427             for (int k=0; k<numDataElems; k++) {
428             fdata[cnt++] = ftemp[k];
429             }
430         }
431         }
432
433         obj = (Object )fdata;
434         break;
435
436     case DataBuffer.TYPE_DOUBLE:
437
438         double[] ddata;
439         double[] dtemp;
440
441         if (obj == null)
442         ddata = new double[numDataElems*w*h];
443         else
444         ddata = (double[])obj;
445
446         for (int i=y; i<y+h; i++) {
447         for (int j=x; j<x+w; j++) {
448             o = getDataElements(j, i, o, data);
449             dtemp = (double[])o;
450             for (int k=0; k<numDataElems; k++) {
451             ddata[cnt++] = dtemp[k];
452             }
453         }
454         }
455
456         obj = (Object )ddata;
457         break;
458     }
459
460     return obj;
461     }
462
463     /**
464      * Sets the data for a single pixel in the specified DataBuffer from a
465      * primitive array of type TransferType. For image data supported by
466      * the Java 2D API, this will be one of DataBuffer.TYPE_BYTE,
467      * DataBuffer.TYPE_USHORT, DataBuffer.TYPE_INT, DataBuffer.TYPE_SHORT,
468      * DataBuffer.TYPE_FLOAT, or DataBuffer.TYPE_DOUBLE. Data in the array
469      * may be in a packed format, thus increasing efficiency for data
470      * transfers.
471      * <p>
472      * The following code illustrates transferring data for one pixel from
473      * DataBuffer <code>db1</code>, whose storage layout is described by
474      * SampleModel <code>sm1</code>, to DataBuffer <code>db2</code>, whose
475      * storage layout is described by SampleModel <code>sm2</code>.
476      * The transfer will generally be more efficient than using
477      * getPixel/setPixel.
478      * <pre>
479      * SampleModel sm1, sm2;
480      * DataBuffer db1, db2;
481      * sm2.setDataElements(x, y, sm1.getDataElements(x, y, null, db1),
482      * db2);
483      * </pre>
484      * Using getDataElements/setDataElements to transfer between two
485      * DataBuffer/SampleModel pairs is legitimate if the SampleModels have
486      * the same number of bands, corresponding bands have the same number of
487      * bits per sample, and the TransferTypes are the same.
488      * <p>
489      * obj must be a primitive array of type TransferType. Otherwise,
490      * a ClassCastException is thrown. An
491      * ArrayIndexOutOfBoundsException may be thrown if the coordinates are
492      * not in bounds, or if obj is not large enough to hold the pixel data.
493      * @param x The X coordinate of the pixel location.
494      * @param y The Y coordinate of the pixel location.
495      * @param obj A primitive array containing pixel data.
496      * @param data The DataBuffer containing the image data.
497      * @see #getNumDataElements
498      * @see #getTransferType
499      * @see #getDataElements(int, int, Object, DataBuffer)
500      * @see java.awt.image.DataBuffer
501      *
502      * @throws NullPointerException if data is null.
503      * @throws ArrayIndexOutOfBoundsException if the coordinates are
504      * not in bounds, or if obj is too small to hold the input.
505      */
506     public abstract void setDataElements(int x, int y,
507                                          Object obj, DataBuffer data);
508
509     /**
510      * Sets the data for a rectangle of pixels in the specified DataBuffer
511      * from a primitive array of type TransferType. For image data supported
512      * by the Java 2D API, this will be one of DataBuffer.TYPE_BYTE,
513      * DataBuffer.TYPE_USHORT, DataBuffer.TYPE_INT, DataBuffer.TYPE_SHORT,
514      * DataBuffer.TYPE_FLOAT, or DataBuffer.TYPE_DOUBLE. Data in the array
515      * may be in a packed format, thus increasing efficiency for data
516      * transfers.
517      * <p>
518      * The following code illustrates transferring data for a rectangular
519      * region of pixels from
520      * DataBuffer <code>db1</code>, whose storage layout is described by
521      * SampleModel <code>sm1</code>, to DataBuffer <code>db2</code>, whose
522      * storage layout is described by SampleModel <code>sm2</code>.
523      * The transfer will generally be more efficient than using
524      * getPixels/setPixels.
525      * <pre>
526      * SampleModel sm1, sm2;
527      * DataBuffer db1, db2;
528      * sm2.setDataElements(x, y, w, h, sm1.getDataElements(x, y, w, h,
529      * null, db1), db2);
530      * </pre>
531      * Using getDataElements/setDataElements to transfer between two
532      * DataBuffer/SampleModel pairs is legitimate if the SampleModels have
533      * the same number of bands, corresponding bands have the same number of
534      * bits per sample, and the TransferTypes are the same.
535      * <p>
536      * obj must be a primitive array of type TransferType. Otherwise,
537      * a ClassCastException is thrown. An
538      * ArrayIndexOutOfBoundsException may be thrown if the coordinates are
539      * not in bounds, or if obj is not large enough to hold the pixel data.
540      * @param x The minimum X coordinate of the pixel rectangle.
541      * @param y The minimum Y coordinate of the pixel rectangle.
542      * @param w The width of the pixel rectangle.
543      * @param h The height of the pixel rectangle.
544      * @param obj A primitive array containing pixel data.
545      * @param data The DataBuffer containing the image data.
546      * @see #getNumDataElements
547      * @see #getTransferType
548      * @see #getDataElements(int, int, int, int, Object, DataBuffer)
549      * @see java.awt.image.DataBuffer
550      *
551      * @throws NullPointerException if data is null.
552      * @throws ArrayIndexOutOfBoundsException if the coordinates are
553      * not in bounds, or if obj is too small to hold the input.
554      */
555     public void setDataElements(int x, int y, int w, int h,
556                                 Object obj, DataBuffer data) {
557
558     int cnt = 0;
559     Object o = null;
560     int type = getTransferType();
561     int numDataElems = getNumDataElements();
562
563     switch(type) {
564
565     case DataBuffer.TYPE_BYTE:
566
567         byte[] barray = (byte[])obj;
568         byte[] btemp = new byte[numDataElems];
569
570         for (int i=y; i<y+h; i++) {
571         for (int j=x; j<x+w; j++) {
572             for (int k=0; k<numDataElems; k++) {
573             btemp[k] = barray[cnt++];
574             }
575
576             setDataElements(j, i, btemp, data);
577         }
578         }
579         break;
580
581     case DataBuffer.TYPE_USHORT:
582     case DataBuffer.TYPE_SHORT:
583
584         short[] sarray = (short[])obj;
585         short[] stemp = new short[numDataElems];
586
587         for (int i=y; i<y+h; i++) {
588         for (int j=x; j<x+w; j++) {
589             for (int k=0; k<numDataElems; k++) {
590             stemp[k] = sarray[cnt++];
591             }
592
593             setDataElements(j, i, stemp, data);
594         }
595         }
596         break;
597
598     case DataBuffer.TYPE_INT:
599
600         int[] iArray = (int[])obj;
601         int[] itemp = new int[numDataElems];
602
603         for (int i=y; i<y+h; i++) {
604         for (int j=x; j<x+w; j++) {
605             for (int k=0; k<numDataElems; k++) {
606             itemp[k] = iArray[cnt++];
607             }
608
609             setDataElements(j, i, itemp, data);
610         }
611         }
612         break;
613
614     case DataBuffer.TYPE_FLOAT:
615
616         float[] fArray = (float[])obj;
617         float[] ftemp = new float[numDataElems];
618
619         for (int i=y; i<y+h; i++) {
620         for (int j=x; j<x+w; j++) {
621             for (int k=0; k<numDataElems; k++) {
622             ftemp[k] = fArray[cnt++];
623             }
624
625             setDataElements(j, i, ftemp, data);
626         }
627         }
628         break;
629
630     case DataBuffer.TYPE_DOUBLE:
631
632         double[] dArray = (double[])obj;
633         double[] dtemp = new double[numDataElems];
634
635         for (int i=y; i<y+h; i++) {
636         for (int j=x; j<x+w; j++) {
637             for (int k=0; k<numDataElems; k++) {
638             dtemp[k] = dArray[cnt++];
639             }
640
641             setDataElements(j, i, dtemp, data);
642         }
643         }
644         break;
645     }
646
647     }
648
649     /**
650      * Returns the samples for the specified pixel in an array of float.
651      * ArrayIndexOutOfBoundsException may be thrown if the coordinates are
652      * not in bounds.
653      * @param x The X coordinate of the pixel location.
654      * @param y The Y coordinate of the pixel location.
655      * @param fArray If non-null, returns the samples in this array.
656      * @param data The DataBuffer containing the image data.
657      * @return the samples for the specified pixel.
658      * @see #setPixel(int, int, float[], DataBuffer)
659      *
660      * @throws NullPointerException if data is null.
661      * @throws ArrayIndexOutOfBoundsException if the coordinates are
662      * not in bounds, or if fArray is too small to hold the output.
663      */
664     public float[] getPixel(int x, int y, float fArray[],
665                 DataBuffer data) {
666
667     float pixels[];
668
669     if (fArray != null)
670         pixels = fArray;
671     else
672         pixels = new float[numBands];
673
674     for (int i=0; i<numBands; i++)
675         pixels[i] = getSampleFloat(x, y, i, data);
676
677     return pixels;
678     }
679
680     /**
681      * Returns the samples for the specified pixel in an array of double.
682      * ArrayIndexOutOfBoundsException may be thrown if the coordinates are
683      * not in bounds.
684      * @param x The X coordinate of the pixel location.
685      * @param y The Y coordinate of the pixel location.
686      * @param dArray If non-null, returns the samples in this array.
687      * @param data The DataBuffer containing the image data.
688      * @return the samples for the specified pixel.
689      * @see #setPixel(int, int, double[], DataBuffer)
690      *
691      * @throws NullPointerException if data is null.
692      * @throws ArrayIndexOutOfBoundsException if the coordinates are
693      * not in bounds, or if dArray is too small to hold the output.
694      */
695     public double[] getPixel(int x, int y, double dArray[],
696                  DataBuffer data) {
697
698     double pixels[];
699
700     if(dArray != null)
701         pixels = dArray;
702     else
703         pixels = new double[numBands];
704
705     for (int i=0; i<numBands; i++)
706         pixels[i] = getSampleDouble(x, y, i, data);
707
708     return pixels;
709     }
710
711     /**
712      * Returns all samples for a rectangle of pixels in an
713      * int array, one sample per array element.
714      * ArrayIndexOutOfBoundsException may be thrown if the coordinates are
715      * not in bounds.
716      * @param x The X coordinate of the upper left pixel location.
717      * @param y The Y coordinate of the upper left pixel location.
718      * @param w The width of the pixel rectangle.
719      * @param h The height of the pixel rectangle.
720      * @param iArray If non-null, returns the samples in this array.
721      * @param data The DataBuffer containing the image data.
722      * @return the samples for the specified region of pixels.
723      * @see #setPixels(int, int, int, int, int[], DataBuffer)
724      *
725      * @throws NullPointerException if data is null.
726      * @throws ArrayIndexOutOfBoundsException if the coordinates are
727      * not in bounds, or if iArray is too small to hold the output.
728      */
729     public int[] getPixels(int x, int y, int w, int h,
730                            int iArray[], DataBuffer data) {
731
732     int pixels[];
733     int Offset=0;
734
735     if (iArray != null)
736         pixels = iArray;
737     else
738         pixels = new int[numBands * w * h];
739
740     for (int i=y; i<(h+y); i++) {
741         for (int j=x; j<(w+x); j++) {
742         for(int k=0; k<numBands; k++) {
743             pixels[Offset++] = getSample(j, i, k, data);
744         }
745         }
746     }
747
748     return pixels;
749     }
750
751     /**
752      * Returns all samples for a rectangle of pixels in a float
753      * array, one sample per array element.
754      * ArrayIndexOutOfBoundsException may be thrown if the coordinates are
755      * not in bounds.
756      * @param x The X coordinate of the upper left pixel location.
757      * @param y The Y coordinate of the upper left pixel location.
758      * @param w The width of the pixel rectangle.
759      * @param h The height of the pixel rectangle.
760      * @param fArray If non-null, returns the samples in this array.
761      * @param data The DataBuffer containing the image data.
762      * @return the samples for the specified region of pixels.
763      * @see #setPixels(int, int, int, int, float[], DataBuffer)
764      *
765      * @throws NullPointerException if data is null.
766      * @throws ArrayIndexOutOfBoundsException if the coordinates are
767      * not in bounds, or if fArray is too small to hold the output.
768      */
769     public float[] getPixels(int x, int y, int w, int h,
770                              float fArray[], DataBuffer data) {
771
772     float pixels[];
773     int Offset = 0;
774
775     if (fArray != null)
776         pixels = fArray;
777     else
778         pixels = new float[numBands * w * h];
779
780     for (int i=y; i<(h+y); i++) {
781         for(int j=x; j<(w+x); j++) {
782         for(int k=0; k<numBands; k++) {
783             pixels[Offset++] = getSampleFloat(j, i, k, data);
784         }
785         }
786     }
787
788     return pixels;
789     }
790
791     /**
792      * Returns all samples for a rectangle of pixels in a double
793      * array, one sample per array element.
794      * ArrayIndexOutOfBoundsException may be thrown if the coordinates are
795      * not in bounds.
796      * @param x The X coordinate of the upper left pixel location.
797      * @param y The Y coordinate of the upper left pixel location.
798      * @param w The width of the pixel rectangle.
799      * @param h The height of the pixel rectangle.
800      * @param dArray If non-null, returns the samples in this array.
801      * @param data The DataBuffer containing the image data.
802      * @return the samples for the specified region of pixels.
803      * @see #setPixels(int, int, int, int, double[], DataBuffer)
804      *
805      * @throws NullPointerException if data is null.
806      * @throws ArrayIndexOutOfBoundsException if the coordinates are
807      * not in bounds, or if dArray is too small to hold the output.
808      */
809     public double[] getPixels(int x, int y, int w, int h,
810                               double dArray[], DataBuffer data) {
811     double pixels[];
812     int Offset = 0;
813
814     if (dArray != null)
815         pixels = dArray;
816     else
817         pixels = new double[numBands * w * h];
818
819         // Fix 4217412
820 for (int i=y; i<(h+y); i++) {
821         for (int j=x; j<(w+x); j++) {
822         for (int k=0; k<numBands; k++) {
823             pixels[Offset++] = getSampleDouble(j, i, k, data);
824         }
825         }
826     }
827
828     return pixels;
829     }
830
831
832     /**
833      * Returns the sample in a specified band for the pixel located
834      * at (x,y) as an int.
835      * ArrayIndexOutOfBoundsException may be thrown if the coordinates are
836      * not in bounds.
837      * @param x The X coordinate of the pixel location.
838      * @param y The Y coordinate of the pixel location.
839      * @param b The band to return.
840      * @param data The DataBuffer containing the image data.
841      * @return the sample in a specified band for the specified pixel.
842      * @see #setSample(int, int, int, int, DataBuffer)
843      *
844      * @throws NullPointerException if data is null.
845      * @throws ArrayIndexOutOfBoundsException if the coordinates or
846      * the band index are not in bounds.
847      */
848     public abstract int getSample(int x, int y, int b, DataBuffer data);
849
850
851     /**
852      * Returns the sample in a specified band
853      * for the pixel located at (x,y) as a float.
854      * ArrayIndexOutOfBoundsException may be thrown if the coordinates are
855      * not in bounds.
856      * @param x The X coordinate of the pixel location.
857      * @param y The Y coordinate of the pixel location.
858      * @param b The band to return.
859      * @param data The DataBuffer containing the image data.
860      * @return the sample in a specified band for the specified pixel.
861      *
862      * @throws NullPointerException if data is null.
863      * @throws ArrayIndexOutOfBoundsException if the coordinates or
864      * the band index are not in bounds.
865      */
866     public float getSampleFloat(int x, int y, int b, DataBuffer data) {
867
868     float sample;
869     sample = (float) getSample(x, y, b, data);
870     return sample;
871     }
872
873     /**
874      * Returns the sample in a specified band
875      * for a pixel located at (x,y) as a double.
876      * ArrayIndexOutOfBoundsException may be thrown if the coordinates are
877      * not in bounds.
878      * @param x The X coordinate of the pixel location.
879      * @param y The Y coordinate of the pixel location.
880      * @param b The band to return.
881      * @param data The DataBuffer containing the image data.
882      * @return the sample in a specified band for the specified pixel.
883      *
884      * @throws NullPointerException if data is null.
885      * @throws ArrayIndexOutOfBoundsException if the coordinates or
886      * the band index are not in bounds.
887      */
888     public double getSampleDouble(int x, int y, int b, DataBuffer data) {
889
890     double sample;
891
892     sample = (double) getSample(x, y, b, data);
893     return sample;
894     }
895
896     /**
897      * Returns the samples for a specified band for the specified rectangle
898      * of pixels in an int array, one sample per array element.
899      * ArrayIndexOutOfBoundsException may be thrown if the coordinates are
900      * not in bounds.
901      * @param x The X coordinate of the upper left pixel location.
902      * @param y The Y coordinate of the upper left pixel location.
903      * @param w The width of the pixel rectangle.
904      * @param h The height of the pixel rectangle.
905      * @param b The band to return.
906      * @param iArray If non-null, returns the samples in this array.
907      * @param data The DataBuffer containing the image data.
908      * @return the samples for the specified band for the specified region
909      * of pixels.
910      * @see #setSamples(int, int, int, int, int, int[], DataBuffer)
911      *
912      * @throws NullPointerException if data is null.
913      * @throws ArrayIndexOutOfBoundsException if the coordinates or
914      * the band index are not in bounds, or if iArray is too small to
915      * hold the output.
916      */
917     public int[] getSamples(int x, int y, int w, int h, int b,
918                             int iArray[], DataBuffer data) {
919     int pixels[];
920     int Offset=0;
921
922     if (iArray != null)
923         pixels = iArray;
924     else
925         pixels = new int[w * h];
926
927     for(int i=y; i<(h+y); i++) {
928         for (int j=x; j<(w+x); j++) {
929         pixels[Offset++] = getSample(j, i, b, data);
930         }
931     }
932
933     return pixels;
934     }
935
936     /**
937      * Returns the samples for a specified band for the specified rectangle
938      * of pixels in a float array, one sample per array element.
939      * ArrayIndexOutOfBoundsException may be thrown if the coordinates are
940      * not in bounds.
941      * @param x The X coordinate of the upper left pixel location.
942      * @param y The Y coordinate of the upper left pixel location.
943      * @param w The width of the pixel rectangle.
944      * @param h The height of the pixel rectangle.
945      * @param b The band to return.
946      * @param fArray If non-null, returns the samples in this array.
947      * @param data The DataBuffer containing the image data.
948      * @return the samples for the specified band for the specified region
949      * of pixels.
950      * @see #setSamples(int, int, int, int, int, float[], DataBuffer)
951      *
952      * @throws NullPointerException if data is null.
953      * @throws ArrayIndexOutOfBoundsException if the coordinates or
954      * the band index are not in bounds, or if fArray is too small to
955      * hold the output.
956      */
957     public float[] getSamples(int x, int y, int w, int h,
958                               int b, float fArray[],
959                               DataBuffer data) {
960     float pixels[];
961     int Offset=0;
962
963     if (fArray != null)
964         pixels = fArray;
965     else
966         pixels = new float[w * h];
967
968     for (int i=y; i<(h+y); i++) {
969         for (int j=x; j<(w+x); j++) {
970         pixels[Offset++] = getSampleFloat(j, i, b, data);
971         }
972     }
973
974     return pixels;
975     }
976
977     /**
978      * Returns the samples for a specified band for a specified rectangle
979      * of pixels in a double array, one sample per array element.
980      * ArrayIndexOutOfBoundsException may be thrown if the coordinates are
981      * not in bounds.
982      * @param x The X coordinate of the upper left pixel location.
983      * @param y The Y coordinate of the upper left pixel location.
984      * @param w The width of the pixel rectangle.
985      * @param h The height of the pixel rectangle.
986      * @param b The band to return.
987      * @param dArray If non-null, returns the samples in this array.
988      * @param data The DataBuffer containing the image data.
989      * @return the samples for the specified band for the specified region
990      * of pixels.
991      * @see #setSamples(int, int, int, int, int, double[], DataBuffer)
992      *
993      * @throws NullPointerException if data is null.
994      * @throws ArrayIndexOutOfBoundsException if the coordinates or
995      * the band index are not in bounds, or if dArray is too small to
996      * hold the output.
997      */
998     public double[] getSamples(int x, int y, int w, int h,
999                                int b, double dArray[],
1000                               DataBuffer data) {
1001    double pixels[];
1002    int Offset=0;
1003
1004    if (dArray != null)
1005        pixels = dArray;
1006    else
1007        pixels = new double[w * h];
1008
1009    for (int i=y; i<(y+h); i++) {
1010        for (int j=x; j<(x+w); j++) {
1011        pixels[Offset++] = getSampleDouble(j, i, b, data);
1012        }
1013    }
1014
1015    return pixels;
1016    }
1017
1018    /**
1019     * Sets a pixel in the DataBuffer using an int array of samples for input.
1020     * ArrayIndexOutOfBoundsException may be thrown if the coordinates are
1021     * not in bounds.
1022     * @param x The X coordinate of the pixel location.
1023     * @param y The Y coordinate of the pixel location.
1024     * @param iArray The input samples in an int array.
1025     * @param data The DataBuffer containing the image data.
1026     * @see #getPixel(int, int, int[], DataBuffer)
1027     *
1028     * @throws NullPointerException if iArray or data is null.
1029     * @throws ArrayIndexOutOfBoundsException if the coordinates are
1030     * not in bounds, or if iArray is too small to hold the input.
1031     */
1032    public void setPixel(int x, int y, int iArray[], DataBuffer data) {
1033
1034    for (int i=0; i<numBands; i++)
1035        setSample(x, y, i, iArray[i], data);
1036    }
1037
1038    /**
1039     * Sets a pixel in the DataBuffer using a float array of samples for input.
1040     * ArrayIndexOutOfBoundsException may be thrown if the coordinates are
1041     * not in bounds.
1042     * @param x The X coordinate of the pixel location.
1043     * @param y The Y coordinate of the pixel location.
1044     * @param fArray The input samples in a float array.
1045     * @param data The DataBuffer containing the image data.
1046     * @see #getPixel(int, int, float[], DataBuffer)
1047     *
1048     * @throws NullPointerException if fArray or data is null.
1049     * @throws ArrayIndexOutOfBoundsException if the coordinates are
1050     * not in bounds, or if fArray is too small to hold the input.
1051     */
1052    public void setPixel(int x, int y, float fArray[], DataBuffer data) {
1053
1054    for (int i=0; i<numBands; i++)
1055        setSample(x, y, i, fArray[i], data);
1056    }
1057
1058    /**
1059     * Sets a pixel in the DataBuffer using a double array of samples
1060     * for input.
1061     * @param x The X coordinate of the pixel location.
1062     * @param y The Y coordinate of the pixel location.
1063     * @param dArray The input samples in a double array.
1064     * @param data The DataBuffer containing the image data.
1065     * @see #getPixel(int, int, double[], DataBuffer)
1066     *
1067     * @throws NullPointerException if dArray or data is null.
1068     * @throws ArrayIndexOutOfBoundsException if the coordinates are
1069     * not in bounds, or if fArray is too small to hold the input.
1070     */
1071    public void setPixel(int x, int y, double dArray[], DataBuffer data) {
1072
1073    for (int i=0; i<numBands; i++)
1074        setSample(x, y, i, dArray[i], data);
1075    }
1076
1077    /**
1078     * Sets all samples for a rectangle of pixels from an int array containing
1079     * one sample per array element.
1080     * ArrayIndexOutOfBoundsException may be thrown if the coordinates are
1081     * not in bounds.
1082     * @param x The X coordinate of the upper left pixel location.
1083     * @param y The Y coordinate of the upper left pixel location.
1084     * @param w The width of the pixel rectangle.
1085     * @param h The height of the pixel rectangle.
1086     * @param iArray The input samples in an int array.
1087     * @param data The DataBuffer containing the image data.
1088     * @see #getPixels(int, int, int, int, int[], DataBuffer)
1089     *
1090     * @throws NullPointerException if iArray or data is null.
1091     * @throws ArrayIndexOutOfBoundsException if the coordinates are
1092     * not in bounds, or if iArray is too small to hold the input.
1093     */
1094    public void setPixels(int x, int y, int w, int h,
1095                          int iArray[], DataBuffer data) {
1096    int Offset=0;
1097
1098    for (int i=y; i<(y+h); i++) {
1099        for (int j=x; j<(x+w); j++) {
1100        for (int k=0; k<numBands; k++) {
1101            setSample(j, i, k, iArray[Offset++], data);
1102        }
1103        }
1104    }
1105    }
1106
1107    /**
1108     * Sets all samples for a rectangle of pixels from a float array containing
1109     * one sample per array element.
1110     * ArrayIndexOutOfBoundsException may be thrown if the coordinates are
1111     * not in bounds.
1112     * @param x The X coordinate of the upper left pixel location.
1113     * @param y The Y coordinate of the upper left pixel location.
1114     * @param w The width of the pixel rectangle.
1115     * @param h The height of the pixel rectangle.
1116     * @param fArray The input samples in a float array.
1117     * @param data The DataBuffer containing the image data.
1118     * @see #getPixels(int, int, int, int, float[], DataBuffer)
1119     *
1120     * @throws NullPointerException if fArray or data is null.
1121     * @throws ArrayIndexOutOfBoundsException if the coordinates are
1122     * not in bounds, or if fArray is too small to hold the input.
1123     */
1124    public void setPixels(int x, int y, int w, int h,
1125                          float fArray[], DataBuffer data) {
1126    int Offset=0;
1127
1128    for (int i=y; i<(y+h); i++) {
1129        for (int j=x; j<(x+w); j++) {
1130        for(int k=0; k<numBands; k++) {
1131            setSample(j, i, k, fArray[Offset++], data);
1132        }
1133        }
1134    }
1135    }
1136
1137    /**
1138     * Sets all samples for a rectangle of pixels from a double array
1139     * containing one sample per array element.
1140     * ArrayIndexOutOfBoundsException may be thrown if the coordinates are
1141     * not in bounds.
1142     * @param x The X coordinate of the upper left pixel location.
1143     * @param y The Y coordinate of the upper left pixel location.
1144     * @param w The width of the pixel rectangle.
1145     * @param h The height of the pixel rectangle.
1146     * @param dArray The input samples in a double array.
1147     * @param data The DataBuffer containing the image data.
1148     * @see #getPixels(int, int, int, int, double[], DataBuffer)
1149     *
1150     * @throws NullPointerException if dArray or data is null.
1151     * @throws ArrayIndexOutOfBoundsException if the coordinates are
1152     * not in bounds, or if dArray is too small to hold the input.
1153     */
1154    public void setPixels(int x, int y, int w, int h,
1155                          double dArray[], DataBuffer data) {
1156    int Offset=0;
1157
1158    for (int i=y; i<(y+h); i++) {
1159        for (int j=x; j<(x+w); j++) {
1160        for (int k=0; k<numBands; k++) {
1161            setSample(j, i, k, dArray[Offset++], data);
1162        }
1163        }
1164    }
1165    }
1166
1167    /**
1168     * Sets a sample in the specified band for the pixel located at (x,y)
1169     * in the DataBuffer using an int for input.
1170     * ArrayIndexOutOfBoundsException may be thrown if the coordinates are
1171     * not in bounds.
1172     * @param x The X coordinate of the pixel location.
1173     * @param y The Y coordinate of the pixel location.
1174     * @param b The band to set.
1175     * @param s The input sample as an int.
1176     * @param data The DataBuffer containing the image data.
1177     * @see #getSample(int, int, int, DataBuffer)
1178     *
1179     * @throws NullPointerException if data is null.
1180     * @throws ArrayIndexOutOfBoundsException if the coordinates or
1181     * the band index are not in bounds.
1182     */
1183    public abstract void setSample(int x, int y, int b,
1184                                   int s,
1185                                   DataBuffer data);
1186
1187    /**
1188     * Sets a sample in the specified band for the pixel located at (x,y)
1189     * in the DataBuffer using a float for input.
1190     * ArrayIndexOutOfBoundsException may be thrown if the coordinates are
1191     * not in bounds.
1192     * @param x The X coordinate of the pixel location.
1193     * @param y The Y coordinate of the pixel location.
1194     * @param b The band to set.
1195     * @param s The input sample as a float.
1196     * @param data The DataBuffer containing the image data.
1197     * @see #getSample(int, int, int, DataBuffer)
1198     *
1199     * @throws NullPointerException if data is null.
1200     * @throws ArrayIndexOutOfBoundsException if the coordinates or
1201     * the band index are not in bounds.
1202     */
1203    public void setSample(int x, int y, int b,
1204              float s ,
1205              DataBuffer data) {
1206    int sample = (int)s;
1207
1208    setSample(x, y, b, sample, data);
1209    }
1210
1211    /**
1212     * Sets a sample in the specified band for the pixel located at (x,y)
1213     * in the DataBuffer using a double for input.
1214     * ArrayIndexOutOfBoundsException may be thrown if the coordinates are
1215     * not in bounds.
1216     * @param x The X coordinate of the pixel location.
1217     * @param y The Y coordinate of the pixel location.
1218     * @param b The band to set.
1219     * @param s The input sample as a double.
1220     * @param data The DataBuffer containing the image data.
1221     * @see #getSample(int, int, int, DataBuffer)
1222     *
1223     * @throws NullPointerException if data is null.
1224     * @throws ArrayIndexOutOfBoundsException if the coordinates or
1225     * the band index are not in bounds.
1226     */
1227    public void setSample(int x, int y, int b,
1228              double s,
1229              DataBuffer data) {
1230    int sample = (int)s;
1231
1232    setSample(x, y, b, sample, data);
1233    }
1234
1235    /**
1236     * Sets the samples in the specified band for the specified rectangle
1237     * of pixels from an int array containing one sample per array element.
1238     * ArrayIndexOutOfBoundsException may be thrown if the coordinates are
1239     * not in bounds.
1240     * @param x The X coordinate of the upper left pixel location.
1241     * @param y The Y coordinate of the upper left pixel location.
1242     * @param w The width of the pixel rectangle.
1243     * @param h The height of the pixel rectangle.
1244     * @param b The band to set.
1245     * @param iArray The input samples in an int array.
1246     * @param data The DataBuffer containing the image data.
1247     * @see #getSamples(int, int, int, int, int, int[], DataBuffer)
1248     *
1249     * @throws NullPointerException if iArray or data is null.
1250     * @throws ArrayIndexOutOfBoundsException if the coordinates or
1251     * the band index are not in bounds, or if iArray is too small to
1252     * hold the input.
1253     */
1254    public void setSamples(int x, int y, int w, int h, int b,
1255                           int iArray[], DataBuffer data) {
1256
1257    int Offset=0;
1258
1259    for (int i=y; i<(y+h); i++) {
1260        for (int j=x; j<(x+w); j++) {
1261        setSample(j, i, b, iArray[Offset++], data);
1262        }
1263    }
1264    }
1265
1266    /**
1267     * Sets the samples in the specified band for the specified rectangle
1268     * of pixels from a float array containing one sample per array element.
1269     * ArrayIndexOutOfBoundsException may be thrown if the coordinates are
1270     * not in bounds.
1271     * @param x The X coordinate of the upper left pixel location.
1272     * @param y The Y coordinate of the upper left pixel location.
1273     * @param w The width of the pixel rectangle.
1274     * @param h The height of the pixel rectangle.
1275     * @param b The band to set.
1276     * @param fArray The input samples in a float array.
1277     * @param data The DataBuffer containing the image data.
1278     * @see #getSamples(int, int, int, int, int, float[], DataBuffer)
1279     *
1280     * @throws NullPointerException if fArray or data is null.
1281     * @throws ArrayIndexOutOfBoundsException if the coordinates or
1282     * the band index are not in bounds, or if fArray is too small to
1283     * hold the input.
1284     */
1285    public void setSamples(int x, int y, int w, int h, int b,
1286                           float fArray[], DataBuffer data) {
1287    int Offset=0;
1288
1289    for (int i=y; i<(y+h); i++) {
1290        for (int j=x; j<(x+w); j++) {
1291        setSample(j, i, b, fArray[Offset++], data);
1292        }
1293    }
1294    }
1295
1296    /**
1297     * Sets the samples in the specified band for the specified rectangle
1298     * of pixels from a double array containing one sample per array element.
1299     * ArrayIndexOutOfBoundsException may be thrown if the coordinates are
1300     * not in bounds.
1301     * @param x The X coordinate of the upper left pixel location.
1302     * @param y The Y coordinate of the upper left pixel location.
1303     * @param w The width of the pixel rectangle.
1304     * @param h The height of the pixel rectangle.
1305     * @param b The band to set.
1306     * @param dArray The input samples in a double array.
1307     * @param data The DataBuffer containing the image data.
1308     * @see #getSamples(int, int, int, int, int, double[], DataBuffer)
1309     *
1310     * @throws NullPointerException if dArray or data is null.
1311     * @throws ArrayIndexOutOfBoundsException if the coordinates or
1312     * the band index are not in bounds, or if dArray is too small to
1313     * hold the input.
1314     */
1315    public void setSamples(int x, int y, int w, int h, int b,
1316                           double dArray[], DataBuffer data) {
1317    int Offset=0;
1318
1319    for (int i=y; i<(y+h); i++) {
1320        for (int j=x; j<(x+w); j++) {
1321        setSample(j, i, b, dArray[Offset++], data);
1322        }
1323    }
1324    }
1325
1326    /**
1327     * Creates a SampleModel which describes data in this SampleModel's
1328     * format, but with a different width and height.
1329     * @param w the width of the image data
1330     * @param h the height of the image data
1331     * @return a <code>SampleModel</code> describing the same image
1332     * data as this <code>SampleModel</code>, but with a
1333     * different size.
1334     */
1335    public abstract SampleModel createCompatibleSampleModel(int w, int h);
1336
1337    /**
1338     * Creates a new SampleModel
1339     * with a subset of the bands of this
1340     * SampleModel.
1341     * @param bands the subset of bands of this <code>SampleModel</code>
1342     * @return a <code>SampleModel</code> with a subset of bands of this
1343     * <code>SampleModel</code>.
1344     */
1345    public abstract SampleModel createSubsetSampleModel(int bands[]);
1346
1347    /**
1348     * Creates a DataBuffer that corresponds to this SampleModel.
1349     * The DataBuffer's width and height will match this SampleModel's.
1350     * @return a <code>DataBuffer</code> corresponding to this
1351     * <code>SampleModel</code>.
1352     */
1353    public abstract DataBuffer createDataBuffer();
1354
1355    /** Returns the size in bits of samples for all bands.
1356     * @return the size of samples for all bands.
1357     */
1358    public abstract int[] getSampleSize();
1359
1360    /** Returns the size in bits of samples for the specified band.
1361     * @param band the specified band
1362     * @return the size of the samples of the specified band.
1363     */
1364    public abstract int getSampleSize(int band);
1365
1366}
1367

A to Z: JavaDoc & Examples

---

Daily Java News & Articles

---

Open Source Projects

---

Open Source Codes

---

Free Computer Books

---

Remove Frame

---

Popular Tags