001 /* Copyright (C) 2000, 2001, 2002, 2005, 2006, Free Software Foundation
002
003 This file is part of GNU Classpath.
004
005 GNU Classpath is free software; you can redistribute it and/or modify
006 it under the terms of the GNU General Public License as published by
007 the Free Software Foundation; either version 2, or (at your option)
008 any later version.
009
010 GNU Classpath is distributed in the hope that it will be useful, but
011 WITHOUT ANY WARRANTY; without even the implied warranty of
012 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
013 General Public License for more details.
014
015 You should have received a copy of the GNU General Public License
016 along with GNU Classpath; see the file COPYING. If not, write to the
017 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
018 02110-1301 USA.
019
020 Linking this library statically or dynamically with other modules is
021 making a combined work based on this library. Thus, the terms and
022 conditions of the GNU General Public License cover the whole
023 combination.
024
025 As a special exception, the copyright holders of this library give you
026 permission to link this library with independent modules to produce an
027 executable, regardless of the license terms of these independent
028 modules, and to copy and distribute the resulting executable under
029 terms of your choice, provided that you also meet, for each linked
030 independent module, the terms and conditions of the license of that
031 module. An independent module is a module which is not derived from
032 or based on this library. If you modify this library, you may extend
033 this exception to your version of the library, but you are not
034 obligated to do so. If you do not wish to do so, delete this
035 exception statement from your version. */
036
037 package java.awt.image;
038
039 /**
040 * A <code>SampleModel</code> is used to access pixel data from a
041 * {@link DataBuffer}. This is used by the {@link Raster} class.
042 *
043 * @author Rolf W. Rasmussen (rolfwr@ii.uib.no)
044 */
045 public abstract class SampleModel
046 {
047 /** Width of image described. */
048 protected int width;
049
050 /** Height of image described. */
051 protected int height;
052
053 /** Number of bands in the image described. Package-private here,
054 shadowed by ComponentSampleModel. */
055 protected int numBands;
056
057 /**
058 * The DataBuffer type that is used to store the data of the image
059 * described.
060 */
061 protected int dataType;
062
063 /**
064 * Creates a new sample model with the specified attributes.
065 *
066 * @param dataType the data type (one of {@link DataBuffer#TYPE_BYTE},
067 * {@link DataBuffer#TYPE_USHORT}, {@link DataBuffer#TYPE_SHORT},
068 * {@link DataBuffer#TYPE_INT}, {@link DataBuffer#TYPE_FLOAT},
069 * {@link DataBuffer#TYPE_DOUBLE} or {@link DataBuffer#TYPE_UNDEFINED}).
070 * @param w the width in pixels (must be greater than zero).
071 * @param h the height in pixels (must be greater than zero).
072 * @param numBands the number of bands (must be greater than zero).
073 *
074 * @throws IllegalArgumentException if <code>dataType</code> is not one of
075 * the listed values.
076 * @throws IllegalArgumentException if <code>w</code> is less than or equal
077 * to zero.
078 * @throws IllegalArgumentException if <code>h</code> is less than or equal
079 * to zero.
080 * @throws IllegalArgumentException if <code>w * h</code> is greater than
081 * {@link Integer#MAX_VALUE}.
082 */
083 public SampleModel(int dataType, int w, int h, int numBands)
084 {
085 if (dataType != DataBuffer.TYPE_UNDEFINED)
086 if (dataType < DataBuffer.TYPE_BYTE || dataType > DataBuffer.TYPE_DOUBLE)
087 throw new IllegalArgumentException("Unrecognised 'dataType' argument.");
088
089 if ((w <= 0) || (h <= 0))
090 throw new IllegalArgumentException((w <= 0 ? " width<=0" : " width is ok")
091 + (h <= 0 ? " height<=0" : " height is ok"));
092
093 long area = (long) w * (long) h;
094 if (area > Integer.MAX_VALUE)
095 throw new IllegalArgumentException("w * h exceeds Integer.MAX_VALUE.");
096
097 if (numBands <= 0)
098 throw new IllegalArgumentException("Requires numBands > 0.");
099
100 this.dataType = dataType;
101 this.width = w;
102 this.height = h;
103 this.numBands = numBands;
104 }
105
106 /**
107 * Returns the width of the pixel data accessible via this
108 * <code>SampleModel</code>.
109 *
110 * @return The width.
111 *
112 * @see #getHeight()
113 */
114 public final int getWidth()
115 {
116 return width;
117 }
118
119 /**
120 * Returns the height of the pixel data accessible via this
121 * <code>SampleModel</code>.
122 *
123 * @return The height.
124 *
125 * @see #getWidth()
126 */
127 public final int getHeight()
128 {
129 return height;
130 }
131
132 /**
133 * Returns the number of bands for this <code>SampleModel</code>.
134 *
135 * @return The number of bands.
136 */
137 public final int getNumBands()
138 {
139 return numBands;
140 }
141
142 public abstract int getNumDataElements();
143
144 /**
145 * Returns the type of the {@link DataBuffer} that this
146 * <code>SampleModel</code> accesses.
147 *
148 * @return The data buffer type.
149 */
150 public final int getDataType()
151 {
152 return dataType;
153 }
154
155 public int getTransferType()
156 {
157 // FIXME: Is this a reasonable default implementation?
158 return dataType;
159 }
160
161 /**
162 * Returns an array containing the samples for the pixel at (x, y) in the
163 * specified data buffer. If <code>iArray</code> is not <code>null</code>,
164 * it will be populated with the sample values and returned as the result of
165 * this function (this avoids allocating a new array instance).
166 *
167 * @param x the x-coordinate of the pixel.
168 * @param y the y-coordinate of the pixel.
169 * @param iArray an array to populate with the sample values and return as
170 * the result (if <code>null</code>, a new array will be allocated).
171 * @param data the data buffer (<code>null</code> not permitted).
172 *
173 * @return The pixel sample values.
174 *
175 * @throws NullPointerException if <code>data</code> is <code>null</code>.
176 */
177 public int[] getPixel(int x, int y, int[] iArray, DataBuffer data)
178 {
179 if (iArray == null)
180 iArray = new int[numBands];
181 for (int b = 0; b < numBands; b++)
182 iArray[b] = getSample(x, y, b, data);
183 return iArray;
184 }
185
186 /**
187 *
188 * This method is provided as a faster alternative to getPixel(),
189 * that can be used when there is no need to decode the pixel into
190 * separate sample values.
191 *
192 * @param obj An array to return the pixel data in. If null, an
193 * array of the right type and size will be created.
194 *
195 * @return A single pixel as an array object of a primitive type,
196 * based on the transfer type. Eg. if transfer type is
197 * DataBuffer.TYPE_USHORT, then a short[] object is returned.
198 */
199 public abstract Object getDataElements(int x, int y, Object obj,
200 DataBuffer data);
201
202
203 public Object getDataElements(int x, int y, int w, int h, Object obj,
204 DataBuffer data)
205 {
206 int size = w * h;
207 int numDataElements = getNumDataElements();
208 int dataSize = numDataElements * size;
209
210 if (obj == null)
211 {
212 switch (getTransferType())
213 {
214 case DataBuffer.TYPE_BYTE:
215 obj = new byte[dataSize];
216 break;
217 case DataBuffer.TYPE_USHORT:
218 obj = new short[dataSize];
219 break;
220 case DataBuffer.TYPE_INT:
221 obj = new int[dataSize];
222 break;
223 default:
224 // Seems like the only sensible thing to do.
225 throw new ClassCastException();
226 }
227 }
228 Object pixelData = null;
229 int outOffset = 0;
230 for (int yy = y; yy < (y + h); yy++)
231 {
232 for (int xx = x; xx < (x + w); xx++)
233 {
234 pixelData = getDataElements(xx, yy, pixelData, data);
235 System.arraycopy(pixelData, 0, obj, outOffset,
236 numDataElements);
237 outOffset += numDataElements;
238 }
239 }
240 return obj;
241 }
242
243 public abstract void setDataElements(int x, int y, Object obj,
244 DataBuffer data);
245
246 public void setDataElements(int x, int y, int w, int h,
247 Object obj, DataBuffer data)
248 {
249 int numDataElements = getNumDataElements();
250
251 Object pixelData;
252 switch (getTransferType())
253 {
254 case DataBuffer.TYPE_BYTE:
255 pixelData = new byte[numDataElements];
256 break;
257 case DataBuffer.TYPE_USHORT:
258 case DataBuffer.TYPE_SHORT:
259 pixelData = new short[numDataElements];
260 break;
261 case DataBuffer.TYPE_INT:
262 pixelData = new int[numDataElements];
263 break;
264 case DataBuffer.TYPE_FLOAT:
265 pixelData = new float[numDataElements];
266 break;
267 case DataBuffer.TYPE_DOUBLE:
268 pixelData = new double[numDataElements];
269 break;
270 default:
271 // The RI silently igores invalid types.
272 pixelData = null;
273 }
274
275 int inOffset = 0;
276 if (pixelData != null)
277 {
278 for (int yy=y; yy<(y+h); yy++)
279 {
280 for (int xx=x; xx<(x+w); xx++)
281 {
282 System.arraycopy(obj, inOffset, pixelData, 0, numDataElements);
283 setDataElements(xx, yy, pixelData, data);
284 inOffset += numDataElements;
285 }
286 }
287 }
288 }
289
290 /**
291 * Returns an array containing the samples for the pixel at (x, y) in the
292 * specified data buffer. If <code>fArray</code> is not <code>null</code>,
293 * it will be populated with the sample values and returned as the result of
294 * this function (this avoids allocating a new array instance).
295 *
296 * @param x the x-coordinate of the pixel.
297 * @param y the y-coordinate of the pixel.
298 * @param fArray an array to populate with the sample values and return as
299 * the result (if <code>null</code>, a new array will be allocated).
300 * @param data the data buffer (<code>null</code> not permitted).
301 *
302 * @return The pixel sample values.
303 *
304 * @throws NullPointerException if <code>data</code> is <code>null</code>.
305 */
306 public float[] getPixel(int x, int y, float[] fArray, DataBuffer data)
307 {
308 if (fArray == null)
309 fArray = new float[numBands];
310
311 for (int b = 0; b < numBands; b++)
312 {
313 fArray[b] = getSampleFloat(x, y, b, data);
314 }
315 return fArray;
316 }
317
318 /**
319 * Returns an array containing the samples for the pixel at (x, y) in the
320 * specified data buffer. If <code>dArray</code> is not <code>null</code>,
321 * it will be populated with the sample values and returned as the result of
322 * this function (this avoids allocating a new array instance).
323 *
324 * @param x the x-coordinate of the pixel.
325 * @param y the y-coordinate of the pixel.
326 * @param dArray an array to populate with the sample values and return as
327 * the result (if <code>null</code>, a new array will be allocated).
328 * @param data the data buffer (<code>null</code> not permitted).
329 *
330 * @return The pixel sample values.
331 *
332 * @throws NullPointerException if <code>data</code> is <code>null</code>.
333 */
334 public double[] getPixel(int x, int y, double[] dArray, DataBuffer data) {
335 if (dArray == null)
336 dArray = new double[numBands];
337 for (int b = 0; b < numBands; b++)
338 {
339 dArray[b] = getSampleDouble(x, y, b, data);
340 }
341 return dArray;
342 }
343
344 /**
345 * Returns an array containing the samples for the pixels in the region
346 * specified by (x, y, w, h) in the specified data buffer. The array is
347 * ordered by pixels (that is, all the samples for the first pixel are
348 * grouped together, followed by all the samples for the second pixel, and so
349 * on). If <code>iArray</code> is not <code>null</code>, it will be
350 * populated with the sample values and returned as the result of this
351 * function (this avoids allocating a new array instance).
352 *
353 * @param x the x-coordinate of the top-left pixel.
354 * @param y the y-coordinate of the top-left pixel.
355 * @param w the width of the region of pixels.
356 * @param h the height of the region of pixels.
357 * @param iArray an array to populate with the sample values and return as
358 * the result (if <code>null</code>, a new array will be allocated).
359 * @param data the data buffer (<code>null</code> not permitted).
360 *
361 * @return The pixel sample values.
362 *
363 * @throws NullPointerException if <code>data</code> is <code>null</code>.
364 */
365 public int[] getPixels(int x, int y, int w, int h, int[] iArray,
366 DataBuffer data)
367 {
368 int size = w * h;
369 int outOffset = 0;
370 int[] pixel = null;
371 if (iArray == null)
372 iArray = new int[w * h * numBands];
373 for (int yy = y; yy < (y + h); yy++)
374 {
375 for (int xx = x; xx < (x + w); xx++)
376 {
377 pixel = getPixel(xx, yy, pixel, data);
378 System.arraycopy(pixel, 0, iArray, outOffset, numBands);
379 outOffset += numBands;
380 }
381 }
382 return iArray;
383 }
384
385 /**
386 * Returns an array containing the samples for the pixels in the region
387 * specified by (x, y, w, h) in the specified data buffer. The array is
388 * ordered by pixels (that is, all the samples for the first pixel are
389 * grouped together, followed by all the samples for the second pixel, and so
390 * on). If <code>fArray</code> is not <code>null</code>, it will be
391 * populated with the sample values and returned as the result of this
392 * function (this avoids allocating a new array instance).
393 *
394 * @param x the x-coordinate of the top-left pixel.
395 * @param y the y-coordinate of the top-left pixel.
396 * @param w the width of the region of pixels.
397 * @param h the height of the region of pixels.
398 * @param fArray an array to populate with the sample values and return as
399 * the result (if <code>null</code>, a new array will be allocated).
400 * @param data the data buffer (<code>null</code> not permitted).
401 *
402 * @return The pixel sample values.
403 *
404 * @throws NullPointerException if <code>data</code> is <code>null</code>.
405 */
406 public float[] getPixels(int x, int y, int w, int h, float[] fArray,
407 DataBuffer data)
408 {
409 int size = w * h;
410 int outOffset = 0;
411 float[] pixel = null;
412 if (fArray == null) fArray = new float[w * h * numBands];
413 for (int yy = y; yy < (y + h); yy++)
414 {
415 for (int xx = x; xx < (x + w); xx++)
416 {
417 pixel = getPixel(xx, yy, pixel, data);
418 System.arraycopy(pixel, 0, fArray, outOffset, numBands);
419 outOffset += numBands;
420 }
421 }
422 return fArray;
423 }
424
425 /**
426 * Returns an array containing the samples for the pixels in the region
427 * specified by (x, y, w, h) in the specified data buffer. The array is
428 * ordered by pixels (that is, all the samples for the first pixel are
429 * grouped together, followed by all the samples for the second pixel, and so
430 * on). If <code>dArray</code> is not <code>null</code>, it will be
431 * populated with the sample values and returned as the result of this
432 * function (this avoids allocating a new array instance).
433 *
434 * @param x the x-coordinate of the top-left pixel.
435 * @param y the y-coordinate of the top-left pixel.
436 * @param w the width of the region of pixels.
437 * @param h the height of the region of pixels.
438 * @param dArray an array to populate with the sample values and return as
439 * the result (if <code>null</code>, a new array will be allocated).
440 * @param data the data buffer (<code>null</code> not permitted).
441 *
442 * @return The pixel sample values.
443 *
444 * @throws NullPointerException if <code>data</code> is <code>null</code>.
445 */
446 public double[] getPixels(int x, int y, int w, int h, double[] dArray,
447 DataBuffer data)
448 {
449 int size = w * h;
450 int outOffset = 0;
451 double[] pixel = null;
452 if (dArray == null)
453 dArray = new double[w * h * numBands];
454 for (int yy = y; yy < (y + h); yy++)
455 {
456 for (int xx = x; xx < (x + w); xx++)
457 {
458 pixel = getPixel(xx, yy, pixel, data);
459 System.arraycopy(pixel, 0, dArray, outOffset, numBands);
460 outOffset += numBands;
461 }
462 }
463 return dArray;
464 }
465
466 /**
467 * Returns the sample value for the pixel at (x, y) in the specified data
468 * buffer.
469 *
470 * @param x the x-coordinate of the pixel.
471 * @param y the y-coordinate of the pixel.
472 * @param b the band (in the range <code>0</code> to
473 * <code>getNumBands() - 1</code>).
474 * @param data the data buffer (<code>null</code> not permitted).
475 *
476 * @return The sample value.
477 *
478 * @throws NullPointerException if <code>data</code> is <code>null</code>.
479 */
480 public abstract int getSample(int x, int y, int b, DataBuffer data);
481
482 /**
483 * Returns the sample value for the pixel at (x, y) in the specified data
484 * buffer.
485 *
486 * @param x the x-coordinate of the pixel.
487 * @param y the y-coordinate of the pixel.
488 * @param b the band (in the range <code>0</code> to
489 * <code>getNumBands() - 1</code>).
490 * @param data the data buffer (<code>null</code> not permitted).
491 *
492 * @return The sample value.
493 *
494 * @throws NullPointerException if <code>data</code> is <code>null</code>.
495 *
496 * @see #getSample(int, int, int, DataBuffer)
497 */
498 public float getSampleFloat(int x, int y, int b, DataBuffer data)
499 {
500 return getSample(x, y, b, data);
501 }
502
503 /**
504 * Returns the sample value for the pixel at (x, y) in the specified data
505 * buffer.
506 *
507 * @param x the x-coordinate of the pixel.
508 * @param y the y-coordinate of the pixel.
509 * @param b the band (in the range <code>0</code> to
510 * <code>getNumBands() - 1</code>).
511 * @param data the data buffer (<code>null</code> not permitted).
512 *
513 * @return The sample value.
514 *
515 * @throws NullPointerException if <code>data</code> is <code>null</code>.
516 *
517 * @see #getSample(int, int, int, DataBuffer)
518 */
519 public double getSampleDouble(int x, int y, int b, DataBuffer data)
520 {
521 return getSampleFloat(x, y, b, data);
522 }
523
524 /**
525 * Returns an array containing the samples from one band for the pixels in
526 * the region specified by (x, y, w, h) in the specified data buffer. If
527 * <code>iArray</code> is not <code>null</code>, it will be
528 * populated with the sample values and returned as the result of this
529 * function (this avoids allocating a new array instance).
530 *
531 * @param x the x-coordinate of the top-left pixel.
532 * @param y the y-coordinate of the top-left pixel.
533 * @param w the width of the region of pixels.
534 * @param h the height of the region of pixels.
535 * @param b the band (in the range <code>0</code> to
536 * </code>getNumBands() - 1</code>).
537 * @param iArray an array to populate with the sample values and return as
538 * the result (if <code>null</code>, a new array will be allocated).
539 * @param data the data buffer (<code>null</code> not permitted).
540 *
541 * @return The sample values.
542 *
543 * @throws NullPointerException if <code>data</code> is <code>null</code>.
544 */
545 public int[] getSamples(int x, int y, int w, int h, int b,
546 int[] iArray, DataBuffer data)
547 {
548 int size = w * h;
549 int outOffset = 0;
550 if (iArray == null)
551 iArray = new int[size];
552 for (int yy = y; yy < (y + h); yy++)
553 {
554 for (int xx = x; xx < (x + w); xx++)
555 {
556 iArray[outOffset++] = getSample(xx, yy, b, data);
557 }
558 }
559 return iArray;
560 }
561
562 /**
563 * Returns an array containing the samples from one band for the pixels in
564 * the region specified by (x, y, w, h) in the specified data buffer. If
565 * <code>fArray</code> is not <code>null</code>, it will be
566 * populated with the sample values and returned as the result of this
567 * function (this avoids allocating a new array instance).
568 *
569 * @param x the x-coordinate of the top-left pixel.
570 * @param y the y-coordinate of the top-left pixel.
571 * @param w the width of the region of pixels.
572 * @param h the height of the region of pixels.
573 * @param b the band (in the range <code>0</code> to
574 * </code>getNumBands() - 1</code>).
575 * @param fArray an array to populate with the sample values and return as
576 * the result (if <code>null</code>, a new array will be allocated).
577 * @param data the data buffer (<code>null</code> not permitted).
578 *
579 * @return The sample values.
580 *
581 * @throws NullPointerException if <code>data</code> is <code>null</code>.
582 */
583 public float[] getSamples(int x, int y, int w, int h, int b,
584 float[] fArray, DataBuffer data)
585 {
586 int size = w * h;
587 int outOffset = 0;
588 if (fArray == null)
589 fArray = new float[size];
590 for (int yy = y; yy < (y + h); yy++)
591 {
592 for (int xx = x; xx < (x + w); xx++)
593 {
594 fArray[outOffset++] = getSampleFloat(xx, yy, b, data);
595 }
596 }
597 return fArray;
598 }
599
600 /**
601 * Returns an array containing the samples from one band for the pixels in
602 * the region specified by (x, y, w, h) in the specified data buffer. If
603 * <code>dArray</code> is not <code>null</code>, it will be
604 * populated with the sample values and returned as the result of this
605 * function (this avoids allocating a new array instance).
606 *
607 * @param x the x-coordinate of the top-left pixel.
608 * @param y the y-coordinate of the top-left pixel.
609 * @param w the width of the region of pixels.
610 * @param h the height of the region of pixels.
611 * @param b the band (in the range <code>0</code> to
612 * </code>getNumBands() - 1</code>).
613 * @param dArray an array to populate with the sample values and return as
614 * the result (if <code>null</code>, a new array will be allocated).
615 * @param data the data buffer (<code>null</code> not permitted).
616 *
617 * @return The sample values.
618 *
619 * @throws NullPointerException if <code>data</code> is <code>null</code>.
620 */
621 public double[] getSamples(int x, int y, int w, int h, int b,
622 double[] dArray, DataBuffer data)
623 {
624 int size = w * h;
625 int outOffset = 0;
626 if (dArray == null)
627 dArray = new double[size];
628 for (int yy = y; yy < (y + h); yy++)
629 {
630 for (int xx = x; xx < (x + w); xx++)
631 {
632 dArray[outOffset++] = getSampleDouble(xx, yy, b, data);
633 }
634 }
635 return dArray;
636 }
637
638 /**
639 * Sets the samples for the pixel at (x, y) in the specified data buffer to
640 * the specified values.
641 *
642 * @param x the x-coordinate of the pixel.
643 * @param y the y-coordinate of the pixel.
644 * @param iArray the sample values (<code>null</code> not permitted).
645 * @param data the data buffer (<code>null</code> not permitted).
646 *
647 * @throws NullPointerException if either <code>iArray</code> or
648 * <code>data</code> is <code>null</code>.
649 */
650 public void setPixel(int x, int y, int[] iArray, DataBuffer data)
651 {
652 for (int b = 0; b < numBands; b++)
653 setSample(x, y, b, iArray[b], data);
654 }
655
656 /**
657 * Sets the samples for the pixel at (x, y) in the specified data buffer to
658 * the specified values.
659 *
660 * @param x the x-coordinate of the pixel.
661 * @param y the y-coordinate of the pixel.
662 * @param fArray the sample values (<code>null</code> not permitted).
663 * @param data the data buffer (<code>null</code> not permitted).
664 *
665 * @throws NullPointerException if either <code>fArray</code> or
666 * <code>data</code> is <code>null</code>.
667 */
668 public void setPixel(int x, int y, float[] fArray, DataBuffer data)
669 {
670 for (int b = 0; b < numBands; b++)
671 setSample(x, y, b, fArray[b], data);
672 }
673
674 /**
675 * Sets the samples for the pixel at (x, y) in the specified data buffer to
676 * the specified values.
677 *
678 * @param x the x-coordinate of the pixel.
679 * @param y the y-coordinate of the pixel.
680 * @param dArray the sample values (<code>null</code> not permitted).
681 * @param data the data buffer (<code>null</code> not permitted).
682 *
683 * @throws NullPointerException if either <code>dArray</code> or
684 * <code>data</code> is <code>null</code>.
685 */
686 public void setPixel(int x, int y, double[] dArray, DataBuffer data)
687 {
688 for (int b = 0; b < numBands; b++)
689 setSample(x, y, b, dArray[b], data);
690 }
691
692 /**
693 * Sets the sample values for the pixels in the region specified by
694 * (x, y, w, h) in the specified data buffer. The array is
695 * ordered by pixels (that is, all the samples for the first pixel are
696 * grouped together, followed by all the samples for the second pixel, and so
697 * on).
698 *
699 * @param x the x-coordinate of the top-left pixel.
700 * @param y the y-coordinate of the top-left pixel.
701 * @param w the width of the region of pixels.
702 * @param h the height of the region of pixels.
703 * @param iArray the pixel sample values (<code>null</code> not permitted).
704 * @param data the data buffer (<code>null</code> not permitted).
705 *
706 * @throws NullPointerException if either <code>iArray</code> or
707 * <code>data</code> is <code>null</code>.
708 */
709 public void setPixels(int x, int y, int w, int h, int[] iArray,
710 DataBuffer data)
711 {
712 int inOffset = 0;
713 int[] pixel = new int[numBands];
714 for (int yy = y; yy < (y + h); yy++)
715 {
716 for (int xx = x; xx < (x + w); xx++)
717 {
718 System.arraycopy(iArray, inOffset, pixel, 0, numBands);
719 setPixel(xx, yy, pixel, data);
720 inOffset += numBands;
721 }
722 }
723 }
724
725 /**
726 * Sets the sample values for the pixels in the region specified by
727 * (x, y, w, h) in the specified data buffer. The array is
728 * ordered by pixels (that is, all the samples for the first pixel are
729 * grouped together, followed by all the samples for the second pixel, and so
730 * on).
731 *
732 * @param x the x-coordinate of the top-left pixel.
733 * @param y the y-coordinate of the top-left pixel.
734 * @param w the width of the region of pixels.
735 * @param h the height of the region of pixels.
736 * @param fArray the pixel sample values (<code>null</code> not permitted).
737 * @param data the data buffer (<code>null</code> not permitted).
738 *
739 * @throws NullPointerException if either <code>fArray</code> or
740 * <code>data</code> is <code>null</code>.
741 */
742 public void setPixels(int x, int y, int w, int h, float[] fArray,
743 DataBuffer data)
744 {
745 int inOffset = 0;
746 float[] pixel = new float[numBands];
747 for (int yy = y; yy < (y + h); yy++)
748 {
749 for (int xx = x; xx < (x + w); xx++)
750 {
751 System.arraycopy(fArray, inOffset, pixel, 0, numBands);
752 setPixel(xx, yy, pixel, data);
753 inOffset += numBands;
754 }
755 }
756 }
757
758 /**
759 * Sets the sample values for the pixels in the region specified by
760 * (x, y, w, h) in the specified data buffer. The array is
761 * ordered by pixels (that is, all the samples for the first pixel are
762 * grouped together, followed by all the samples for the second pixel, and so
763 * on).
764 *
765 * @param x the x-coordinate of the top-left pixel.
766 * @param y the y-coordinate of the top-left pixel.
767 * @param w the width of the region of pixels.
768 * @param h the height of the region of pixels.
769 * @param dArray the pixel sample values (<code>null</code> not permitted).
770 * @param data the data buffer (<code>null</code> not permitted).
771 *
772 * @throws NullPointerException if either <code>dArray</code> or
773 * <code>data</code> is <code>null</code>.
774 */
775 public void setPixels(int x, int y, int w, int h, double[] dArray,
776 DataBuffer data)
777 {
778 int inOffset = 0;
779 double[] pixel = new double[numBands];
780 for (int yy = y; yy < (y + h); yy++)
781 {
782 for (int xx = x; xx < (x + w); xx++)
783 {
784 System.arraycopy(dArray, inOffset, pixel, 0, numBands);
785 setPixel(xx, yy, pixel, data);
786 inOffset += numBands;
787 }
788 }
789 }
790
791 /**
792 * Sets the sample value for a band for the pixel at (x, y) in the
793 * specified data buffer.
794 *
795 * @param x the x-coordinate of the pixel.
796 * @param y the y-coordinate of the pixel.
797 * @param b the band (in the range <code>0</code> to
798 * <code>getNumBands() - 1</code>).
799 * @param s the sample value.
800 * @param data the data buffer (<code>null</code> not permitted).
801 *
802 * @throws NullPointerException if <code>data</code> is <code>null</code>.
803 */
804 public abstract void setSample(int x, int y, int b, int s,
805 DataBuffer data);
806
807 /**
808 * Sets the sample value for a band for the pixel at (x, y) in the
809 * specified data buffer.
810 *
811 * @param x the x-coordinate of the pixel.
812 * @param y the y-coordinate of the pixel.
813 * @param b the band (in the range <code>0</code> to
814 * <code>getNumBands() - 1</code>).
815 * @param s the sample value.
816 * @param data the data buffer (<code>null</code> not permitted).
817 *
818 * @throws NullPointerException if <code>data</code> is <code>null</code>.
819 */
820 public void setSample(int x, int y, int b, float s,
821 DataBuffer data)
822 {
823 setSample(x, y, b, (int) s, data);
824 }
825
826 /**
827 * Sets the sample value for a band for the pixel at (x, y) in the
828 * specified data buffer.
829 *
830 * @param x the x-coordinate of the pixel.
831 * @param y the y-coordinate of the pixel.
832 * @param b the band (in the range <code>0</code> to
833 * <code>getNumBands() - 1</code>).
834 * @param s the sample value.
835 * @param data the data buffer (<code>null</code> not permitted).
836 *
837 * @throws NullPointerException if <code>data</code> is <code>null</code>.
838 */
839 public void setSample(int x, int y, int b, double s,
840 DataBuffer data)
841 {
842 setSample(x, y, b, (float) s, data);
843 }
844
845 /**
846 * Sets the sample values for one band for the pixels in the region
847 * specified by (x, y, w, h) in the specified data buffer.
848 *
849 * @param x the x-coordinate of the top-left pixel.
850 * @param y the y-coordinate of the top-left pixel.
851 * @param w the width of the region of pixels.
852 * @param h the height of the region of pixels.
853 * @param b the band (in the range <code>0</code> to
854 * </code>getNumBands() - 1</code>).
855 * @param iArray the sample values (<code>null</code> not permitted).
856 * @param data the data buffer (<code>null</code> not permitted).
857 *
858 * @throws NullPointerException if either <code>iArray</code> or
859 * <code>data</code> is <code>null</code>.
860 */
861 public void setSamples(int x, int y, int w, int h, int b,
862 int[] iArray, DataBuffer data)
863 {
864 int size = w * h;
865 int inOffset = 0;
866 for (int yy = y; yy < (y + h); yy++)
867 for (int xx = x; xx < (x + w); xx++)
868 setSample(xx, yy, b, iArray[inOffset++], data);
869 }
870
871 /**
872 * Sets the sample values for one band for the pixels in the region
873 * specified by (x, y, w, h) in the specified data buffer.
874 *
875 * @param x the x-coordinate of the top-left pixel.
876 * @param y the y-coordinate of the top-left pixel.
877 * @param w the width of the region of pixels.
878 * @param h the height of the region of pixels.
879 * @param b the band (in the range <code>0</code> to
880 * </code>getNumBands() - 1</code>).
881 * @param fArray the sample values (<code>null</code> not permitted).
882 * @param data the data buffer (<code>null</code> not permitted).
883 *
884 * @throws NullPointerException if either <code>iArray</code> or
885 * <code>data</code> is <code>null</code>.
886 */
887 public void setSamples(int x, int y, int w, int h, int b,
888 float[] fArray, DataBuffer data)
889 {
890 int size = w * h;
891 int inOffset = 0;
892 for (int yy = y; yy < (y + h); yy++)
893 for (int xx = x; xx < (x + w); xx++)
894 setSample(xx, yy, b, fArray[inOffset++], data);
895
896 }
897
898 /**
899 * Sets the sample values for one band for the pixels in the region
900 * specified by (x, y, w, h) in the specified data buffer.
901 *
902 * @param x the x-coordinate of the top-left pixel.
903 * @param y the y-coordinate of the top-left pixel.
904 * @param w the width of the region of pixels.
905 * @param h the height of the region of pixels.
906 * @param b the band (in the range <code>0</code> to
907 * </code>getNumBands() - 1</code>).
908 * @param dArray the sample values (<code>null</code> not permitted).
909 * @param data the data buffer (<code>null</code> not permitted).
910 *
911 * @throws NullPointerException if either <code>iArray</code> or
912 * <code>data</code> is <code>null</code>.
913 */
914 public void setSamples(int x, int y, int w, int h, int b,
915 double[] dArray, DataBuffer data) {
916 int size = w * h;
917 int inOffset = 0;
918 for (int yy = y; yy < (y + h); yy++)
919 for (int xx = x; xx < (x + w); xx++)
920 setSample(xx, yy, b, dArray[inOffset++], data);
921 }
922
923 /**
924 * Creates a new <code>SampleModel</code> that is compatible with this
925 * model and has the specified width and height.
926 *
927 * @param w the width (in pixels).
928 * @param h the height (in pixels).
929 *
930 * @return The new sample model.
931 */
932 public abstract SampleModel createCompatibleSampleModel(int w, int h);
933
934 /**
935 * Return a SampleModel with a subset of the bands in this model.
936 *
937 * Selects bands.length bands from this sample model. The bands chosen
938 * are specified in the indices of bands[]. This also permits permuting
939 * the bands as well as taking a subset. Thus, giving an array with
940 * 1, 2, 3, ..., numbands, will give an identical sample model.
941 *
942 * @param bands Array with band indices to include.
943 * @return A new sample model
944 */
945 public abstract SampleModel createSubsetSampleModel(int[] bands);
946
947 /**
948 * Creates a new {@link DataBuffer} of the correct type and size for this
949 * <code>SampleModel</code>.
950 *
951 * @return The data buffer.
952 */
953 public abstract DataBuffer createDataBuffer();
954
955 /**
956 * Returns an array containing the size (in bits) for each band accessed by
957 * the <code>SampleModel</code>.
958 *
959 * @return An array.
960 *
961 * @see #getSampleSize(int)
962 */
963 public abstract int[] getSampleSize();
964
965 /**
966 * Returns the size (in bits) of the samples for the specified band.
967 *
968 * @param band the band (in the range <code>0</code> to
969 * <code>getNumBands() - 1</code>).
970 *
971 * @return The sample size (in bits).
972 */
973 public abstract int getSampleSize(int band);
974 }