001 /* Copyright (C) 2000, 2002, 2003, 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
038 package java.awt.image;
039
040 import java.awt.Point;
041 import java.awt.Rectangle;
042
043 /**
044 * A rectangular collection of pixels composed from a {@link DataBuffer} which
045 * stores the pixel values, and a {@link SampleModel} which is used to retrieve
046 * the pixel values.
047 *
048 * @author Rolf W. Rasmussen (rolfwr@ii.uib.no)
049 */
050 public class Raster
051 {
052 /** The sample model used to access the pixel values. */
053 protected SampleModel sampleModel;
054
055 /** The data buffer used to store the pixel values. */
056 protected DataBuffer dataBuffer;
057
058 /** The x-coordinate of the top left corner of the raster. */
059 protected int minX;
060
061 /** The y-coordinate of the top left corner of the raster. */
062 protected int minY;
063
064 /** The width of the raster. */
065 protected int width;
066
067 /** The height of the raster. */
068 protected int height;
069
070 protected int sampleModelTranslateX;
071
072 protected int sampleModelTranslateY;
073
074 /** The number of bands. */
075 protected int numBands;
076
077 protected int numDataElements;
078
079 /** The raster's parent. */
080 protected Raster parent;
081
082 /**
083 * Creates a new raster.
084 *
085 * @param sampleModel the sample model.
086 * @param origin the origin.
087 */
088 protected Raster(SampleModel sampleModel, Point origin)
089 {
090 this(sampleModel, sampleModel.createDataBuffer(), origin);
091 }
092
093 /**
094 * Creates a new raster.
095 *
096 * @param sampleModel the sample model.
097 * @param dataBuffer the data buffer.
098 * @param origin the origin.
099 */
100 protected Raster(SampleModel sampleModel, DataBuffer dataBuffer,
101 Point origin)
102 {
103 this(sampleModel, dataBuffer, new Rectangle(origin.x, origin.y,
104 sampleModel.getWidth(), sampleModel.getHeight()), origin, null);
105 }
106
107 /**
108 * Creates a new raster.
109 *
110 * @param sampleModel the sample model.
111 * @param dataBuffer the data buffer.
112 * @param aRegion the raster's bounds.
113 * @param sampleModelTranslate the translation (<code>null</code> permitted).
114 * @param parent the raster's parent.
115 */
116 protected Raster(SampleModel sampleModel, DataBuffer dataBuffer,
117 Rectangle aRegion, Point sampleModelTranslate, Raster parent)
118 {
119 this.sampleModel = sampleModel;
120 this.dataBuffer = dataBuffer;
121 this.minX = aRegion.x;
122 this.minY = aRegion.y;
123 this.width = aRegion.width;
124 this.height = aRegion.height;
125
126 // If sampleModelTranslate is null, use (0,0). Methods such as
127 // Raster.createRaster are specified to allow for a null argument.
128 if (sampleModelTranslate != null)
129 {
130 this.sampleModelTranslateX = sampleModelTranslate.x;
131 this.sampleModelTranslateY = sampleModelTranslate.y;
132 }
133
134 this.numBands = sampleModel.getNumBands();
135 this.numDataElements = sampleModel.getNumDataElements();
136 this.parent = parent;
137 }
138
139 /**
140 * Creates an interleaved raster using the specified data type.
141 *
142 * @param dataType the data type.
143 * @param w the width.
144 * @param h the height.
145 * @param bands the number of bands.
146 * @param location
147 *
148 * @return The new raster.
149 */
150 public static WritableRaster createInterleavedRaster(int dataType,
151 int w, int h, int bands, Point location)
152 {
153 int[] bandOffsets = new int[bands];
154 // TODO: Maybe not generate this every time.
155 for (int b = 0; b < bands; b++)
156 bandOffsets[b] = b;
157
158 int scanlineStride = bands * w;
159 return createInterleavedRaster(dataType, w, h, scanlineStride, bands,
160 bandOffsets, location);
161 }
162
163 /**
164 * Creates an interleaved raster.
165 *
166 * @param dataType the data type.
167 * @param w the width.
168 * @param h the height.
169 * @param scanlineStride the number of data elements from a sample on one
170 * row to the corresponding sample on the next row.
171 * @param pixelStride the number of elements from a sample in one pixel to
172 * the corresponding sample in the next pixel.
173 * @param bandOffsets the band offsets.
174 * @param location
175 *
176 * @return The new raster.
177 */
178 public static WritableRaster createInterleavedRaster(int dataType,
179 int w, int h, int scanlineStride, int pixelStride, int[] bandOffsets,
180 Point location)
181 {
182 SampleModel sm = new ComponentSampleModel(dataType, w, h, pixelStride,
183 scanlineStride, bandOffsets);
184 return createWritableRaster(sm, location);
185 }
186
187 /**
188 * Creates a new banded raster.
189 *
190 * @param dataType the data type.
191 * @param w the width.
192 * @param h the height.
193 * @param bands the number of bands.
194 * @param location
195 *
196 * @return The new raster.
197 */
198 public static WritableRaster createBandedRaster(int dataType, int w, int h,
199 int bands, Point location)
200 {
201 SampleModel sm = new BandedSampleModel(dataType, w, h, bands);
202 return createWritableRaster(sm, location);
203 }
204
205 /**
206 * Creates a new banded raster.
207 *
208 * @param dataType the data type.
209 * @param w the width.
210 * @param h the height.
211 * @param scanlineStride the number of data elements from a sample on one
212 * row to the corresponding sample on the next row.
213 * @param bankIndices the index for each bank.
214 * @param bandOffsets the offset for each band.
215 * @param location
216 *
217 * @return The new raster.
218 */
219 public static WritableRaster createBandedRaster(int dataType, int w, int h,
220 int scanlineStride, int[] bankIndices, int[] bandOffsets, Point location)
221 {
222 SampleModel sm = new BandedSampleModel(dataType, w, h, scanlineStride,
223 bankIndices, bandOffsets);
224 return createWritableRaster(sm, location);
225 }
226
227 /**
228 * Creates a new packed raster.
229 *
230 * @param dataType the data type.
231 * @param w the width.
232 * @param h the height.
233 * @param bandMasks the bit mask for each band.
234 * @param location
235 *
236 * @return The new raster.
237 */
238 public static WritableRaster createPackedRaster(int dataType, int w, int h,
239 int[] bandMasks, Point location)
240 {
241 SampleModel sm = new SinglePixelPackedSampleModel(dataType, w, h,
242 bandMasks);
243 return createWritableRaster(sm, location);
244 }
245
246 /**
247 * Creates a new raster.
248 *
249 * @param dataType the data type.
250 * @param w the width.
251 * @param h the height.
252 * @param bands the number of bands.
253 * @param bitsPerBand the number of bits per band.
254 * @param location
255 *
256 * @return The new raster.
257 */
258 public static WritableRaster createPackedRaster(int dataType,
259 int w, int h, int bands, int bitsPerBand, Point location)
260 {
261 if (bands <= 0 || (bands * bitsPerBand > getTypeBits(dataType)))
262 throw new IllegalArgumentException();
263
264 SampleModel sm;
265
266 if (bands == 1)
267 sm = new MultiPixelPackedSampleModel(dataType, w, h, bitsPerBand);
268 else
269 {
270 int[] bandMasks = new int[bands];
271 int mask = 0x1;
272 for (int bits = bitsPerBand; --bits != 0;)
273 mask = (mask << 1) | 0x1;
274 for (int i = 0; i < bands; i++)
275 {
276 bandMasks[i] = mask;
277 mask <<= bitsPerBand;
278 }
279
280 sm = new SinglePixelPackedSampleModel(dataType, w, h, bandMasks);
281 }
282 return createWritableRaster(sm, location);
283 }
284
285 /**
286 * Creates a new interleaved raster.
287 *
288 * @param dataBuffer the data buffer.
289 * @param w the width.
290 * @param h the height.
291 * @param scanlineStride the number of data elements from a sample on one
292 * row to the corresponding sample on the next row.
293 * @param pixelStride the number of elements from a sample in one pixel to
294 * the corresponding sample in the next pixel.
295 * @param bandOffsets the offset for each band.
296 * @param location
297 *
298 * @return The new raster.
299 */
300 public static WritableRaster createInterleavedRaster(DataBuffer dataBuffer,
301 int w, int h, int scanlineStride, int pixelStride, int[] bandOffsets,
302 Point location)
303 {
304 SampleModel sm = new ComponentSampleModel(dataBuffer.getDataType(),
305 w, h, scanlineStride, pixelStride, bandOffsets);
306 return createWritableRaster(sm, dataBuffer, location);
307 }
308
309 /**
310 * Creates a new banded raster.
311 *
312 * @param dataBuffer the data buffer.
313 * @param w the width.
314 * @param h the height.
315 * @param scanlineStride the number of data elements from a sample on one
316 * row to the corresponding sample on the next row.
317 * @param bankIndices the index for each bank.
318 * @param bandOffsets the band offsets.
319 * @param location
320 *
321 * @return The new raster.
322 */
323 public static WritableRaster createBandedRaster(DataBuffer dataBuffer,
324 int w, int h, int scanlineStride, int[] bankIndices, int[] bandOffsets,
325 Point location)
326 {
327 SampleModel sm = new BandedSampleModel(dataBuffer.getDataType(),
328 w, h, scanlineStride, bankIndices, bandOffsets);
329 return createWritableRaster(sm, dataBuffer, location);
330 }
331
332 /**
333 * Creates a new packed raster.
334 *
335 * @param dataBuffer the data buffer.
336 * @param w the width.
337 * @param h the height.
338 * @param scanlineStride the number of data elements from a sample on one
339 * row to the corresponding sample on the next row.
340 * @param bandMasks the bit mask for each band.
341 * @param location
342 *
343 * @return The new raster.
344 */
345 public static WritableRaster createPackedRaster(DataBuffer dataBuffer,
346 int w, int h, int scanlineStride, int[] bandMasks, Point location)
347 {
348 SampleModel sm = new SinglePixelPackedSampleModel(dataBuffer.getDataType(),
349 w, h, scanlineStride, bandMasks);
350 return createWritableRaster(sm, dataBuffer, location);
351 }
352
353 /**
354 * Creates a new packed raster.
355 *
356 * @param dataBuffer the data buffer.
357 * @param w the width.
358 * @param h the height.
359 * @param bitsPerPixel the number of bits per pixel.
360 * @param location
361 *
362 * @return The new raster.
363 */
364 public static WritableRaster createPackedRaster(DataBuffer dataBuffer,
365 int w, int h, int bitsPerPixel, Point location)
366 {
367 SampleModel sm = new MultiPixelPackedSampleModel(dataBuffer.getDataType(),
368 w, h, bitsPerPixel);
369 return createWritableRaster(sm, dataBuffer, location);
370 }
371
372 /**
373 * Creates a new raster.
374 *
375 * @param sm the sample model.
376 * @param db the data buffer.
377 * @param location
378 *
379 * @return The new raster.
380 */
381 public static Raster createRaster(SampleModel sm, DataBuffer db,
382 Point location)
383 {
384 return new Raster(sm, db, location);
385 }
386
387 /**
388 * Creates a new writable raster.
389 *
390 * @param sm the sample model.
391 * @param location
392 *
393 * @return The new writable raster.
394 */
395 public static WritableRaster createWritableRaster(SampleModel sm,
396 Point location)
397 {
398 return new WritableRaster(sm, location);
399 }
400
401 /**
402 * Creates a new writable raster.
403 *
404 * @param sm the sample model.
405 * @param db the data buffer.
406 * @param location
407 *
408 * @return The new writable raster.
409 */
410 public static WritableRaster createWritableRaster(SampleModel sm,
411 DataBuffer db, Point location)
412 {
413 return new WritableRaster(sm, db, location);
414 }
415
416 /**
417 * Returns the raster's parent.
418 *
419 * @return The raster's parent.
420 */
421 public Raster getParent()
422 {
423 return parent;
424 }
425
426 /**
427 * Returns the x-translation.
428 *
429 * @return The x-translation.
430 */
431 public final int getSampleModelTranslateX()
432 {
433 return sampleModelTranslateX;
434 }
435
436 /**
437 * Returns the y-translation.
438 *
439 * @return The y-translation.
440 */
441 public final int getSampleModelTranslateY()
442 {
443 return sampleModelTranslateY;
444 }
445
446 /**
447 * Creates a new writable raster that is compatible with this raster.
448 *
449 * @return A new writable raster.
450 */
451 public WritableRaster createCompatibleWritableRaster()
452 {
453 return new WritableRaster(getSampleModel(), new Point(minX, minY));
454 }
455
456 /**
457 * Creates a new writable raster that is compatible with this raster.
458 *
459 * @param w the width.
460 * @param h the height.
461 *
462 * @return A new writable raster.
463 */
464 public WritableRaster createCompatibleWritableRaster(int w, int h)
465 {
466 return createCompatibleWritableRaster(minX, minY, w, h);
467 }
468
469 /**
470 * Creates a new writable raster that is compatible with this raster, with
471 * the specified bounds.
472 *
473 * @param rect the raster bounds.
474 *
475 * @return A new writable raster.
476 */
477 public WritableRaster createCompatibleWritableRaster(Rectangle rect)
478 {
479 return createCompatibleWritableRaster(rect.x, rect.y,
480 rect.width, rect.height);
481 }
482
483 /**
484 * Creates a new writable raster that is compatible with this raster, with
485 * the specified bounds.
486 *
487 * @param x the x-coordinate of the top-left corner of the raster.
488 * @param y the y-coordinate of the top-left corner of the raster.
489 * @param w the raster width.
490 * @param h the raster height.
491 *
492 * @return A new writable raster.
493 */
494 public WritableRaster createCompatibleWritableRaster(int x, int y,
495 int w, int h)
496 {
497 SampleModel sm = getSampleModel().createCompatibleSampleModel(w, h);
498 return new WritableRaster(sm, sm.createDataBuffer(), new Point(x, y));
499 }
500
501 public Raster createTranslatedChild(int childMinX, int childMinY) {
502 int tcx = sampleModelTranslateX - minX + childMinX;
503 int tcy = sampleModelTranslateY - minY + childMinY;
504
505 return new Raster(sampleModel, dataBuffer,
506 new Rectangle(childMinX, childMinY, width, height),
507 new Point(tcx, tcy), this);
508 }
509
510 public Raster createChild(int parentX, int parentY, int width,
511 int height, int childMinX, int childMinY,
512 int[] bandList)
513 {
514 if (parentX < minX || parentX + width > minX + this.width
515 || parentY < minY || parentY + height > minY + this.height)
516 throw new RasterFormatException("Child raster extends beyond parent");
517
518 SampleModel sm = (bandList == null) ?
519 sampleModel :
520 sampleModel.createSubsetSampleModel(bandList);
521
522 /*
523 data origin
524 /
525 +-------------------------
526 |\. __ parent trans
527 | \`.
528 | \ `. parent origin
529 | \ `. /
530 | /\ +-------- - -
531 |trans\ /<\-- deltaTrans
532 |child +-+-\---- - -
533 | /|`| \__ parent [x, y]
534 |child | |`. \
535 |origin| : `.\
536 | | / `\
537 | : / +
538 | child [x, y]
539
540 parent_xy - parent_trans = child_xy - child_trans
541
542 child_trans = parent_trans + child_xy - parent_xy
543 */
544
545 return new Raster(sm, dataBuffer,
546 new Rectangle(childMinX, childMinY, width, height),
547 new Point(sampleModelTranslateX + childMinX - parentX,
548 sampleModelTranslateY + childMinY - parentY),
549 this);
550 }
551
552 /**
553 * Returns a new rectangle containing the bounds of this raster.
554 *
555 * @return A new rectangle containing the bounds of this raster.
556 */
557 public Rectangle getBounds()
558 {
559 return new Rectangle(minX, minY, width, height);
560 }
561
562 /**
563 * Returns the x-coordinate of the top left corner of the raster.
564 *
565 * @return The x-coordinate of the top left corner of the raster.
566 */
567 public final int getMinX()
568 {
569 return minX;
570 }
571
572 /**
573 * Returns the t-coordinate of the top left corner of the raster.
574 *
575 * @return The t-coordinate of the top left corner of the raster.
576 */
577 public final int getMinY()
578 {
579 return minY;
580 }
581
582 /**
583 * Returns the width of the raster.
584 *
585 * @return The width of the raster.
586 */
587 public final int getWidth()
588 {
589 return width;
590 }
591
592 /**
593 * Returns the height of the raster.
594 *
595 * @return The height of the raster.
596 */
597 public final int getHeight()
598 {
599 return height;
600 }
601
602 /**
603 * Returns the number of bands for this raster.
604 *
605 * @return The number of bands.
606 */
607 public final int getNumBands()
608 {
609 return numBands;
610 }
611
612 public final int getNumDataElements()
613 {
614 return numDataElements;
615 }
616
617 /**
618 * Returns the transfer type for the raster (this is determined by the
619 * raster's sample model).
620 *
621 * @return The transfer type.
622 */
623 public final int getTransferType()
624 {
625 return sampleModel.getTransferType();
626 }
627
628 /**
629 * Returns the data buffer that stores the pixel data for this raster.
630 *
631 * @return The data buffer.
632 */
633 public DataBuffer getDataBuffer()
634 {
635 return dataBuffer;
636 }
637
638 /**
639 * Returns the sample model that accesses the data buffer (to extract pixel
640 * data) for this raster.
641 *
642 * @return The sample model.
643 */
644 public SampleModel getSampleModel()
645 {
646 return sampleModel;
647 }
648
649 public Object getDataElements(int x, int y, Object outData)
650 {
651 return sampleModel.getDataElements(x - sampleModelTranslateX,
652 y - sampleModelTranslateY, outData, dataBuffer);
653 }
654
655 public Object getDataElements(int x, int y, int w, int h, Object outData)
656 {
657 return sampleModel.getDataElements(x - sampleModelTranslateX,
658 y - sampleModelTranslateY, w, h, outData, dataBuffer);
659 }
660
661 /**
662 * Returns an array containing the samples for the pixel at (x, y) in the
663 * raster. If <code>iArray</code> is not <code>null</code>, it will be
664 * populated with the sample values and returned as the result of
665 * this function (this avoids allocating a new array instance).
666 *
667 * @param x the x-coordinate of the pixel.
668 * @param y the y-coordinate of the pixel.
669 * @param iArray an array to populate with the sample values and return as
670 * the result (if <code>null</code>, a new array will be allocated).
671 *
672 * @return The pixel sample values.
673 */
674 public int[] getPixel(int x, int y, int[] iArray)
675 {
676 return sampleModel.getPixel(x - sampleModelTranslateX,
677 y - sampleModelTranslateY, iArray, dataBuffer);
678 }
679
680 /**
681 * Returns an array containing the samples for the pixel at (x, y) in the
682 * raster. If <code>fArray</code> is not <code>null</code>, it will be
683 * populated with the sample values and returned as the result of
684 * this function (this avoids allocating a new array instance).
685 *
686 * @param x the x-coordinate of the pixel.
687 * @param y the y-coordinate of the pixel.
688 * @param fArray an array to populate with the sample values and return as
689 * the result (if <code>null</code>, a new array will be allocated).
690 *
691 * @return The pixel sample values.
692 */
693 public float[] getPixel(int x, int y, float[] fArray)
694 {
695 return sampleModel.getPixel(x - sampleModelTranslateX,
696 y - sampleModelTranslateY, fArray, dataBuffer);
697 }
698
699 /**
700 * Returns an array containing the samples for the pixel at (x, y) in the
701 * raster. If <code>dArray</code> is not <code>null</code>, it will be
702 * populated with the sample values and returned as the result of
703 * this function (this avoids allocating a new array instance).
704 *
705 * @param x the x-coordinate of the pixel.
706 * @param y the y-coordinate of the pixel.
707 * @param dArray an array to populate with the sample values and return as
708 * the result (if <code>null</code>, a new array will be allocated).
709 *
710 * @return The pixel sample values.
711 */
712 public double[] getPixel(int x, int y, double[] dArray)
713 {
714 return sampleModel.getPixel(x - sampleModelTranslateX,
715 y - sampleModelTranslateY, dArray, dataBuffer);
716 }
717
718 /**
719 * Returns an array containing the samples for the pixels in the region
720 * specified by (x, y, w, h) in the raster. The array is ordered by pixels
721 * (that is, all the samples for the first pixel are grouped together,
722 * followed by all the samples for the second pixel, and so on).
723 * If <code>iArray</code> is not <code>null</code>, it will be populated
724 * with the sample values and returned as the result of this function (this
725 * avoids allocating a new array instance).
726 *
727 * @param x the x-coordinate of the top-left pixel.
728 * @param y the y-coordinate of the top-left pixel.
729 * @param w the width of the region of pixels.
730 * @param h the height of the region of pixels.
731 * @param iArray an array to populate with the sample values and return as
732 * the result (if <code>null</code>, a new array will be allocated).
733 *
734 * @return The pixel sample values.
735 */
736 public int[] getPixels(int x, int y, int w, int h, int[] iArray)
737 {
738 return sampleModel.getPixels(x - sampleModelTranslateX,
739 y - sampleModelTranslateY, w, h, iArray, dataBuffer);
740 }
741
742 /**
743 * Returns an array containing the samples for the pixels in the region
744 * specified by (x, y, w, h) in the raster. The array is ordered by pixels
745 * (that is, all the samples for the first pixel are grouped together,
746 * followed by all the samples for the second pixel, and so on).
747 * If <code>fArray</code> is not <code>null</code>, it will be populated
748 * with the sample values and returned as the result of this function (this
749 * avoids allocating a new array instance).
750 *
751 * @param x the x-coordinate of the top-left pixel.
752 * @param y the y-coordinate of the top-left pixel.
753 * @param w the width of the region of pixels.
754 * @param h the height of the region of pixels.
755 * @param fArray an array to populate with the sample values and return as
756 * the result (if <code>null</code>, a new array will be allocated).
757 *
758 * @return The pixel sample values.
759 */
760 public float[] getPixels(int x, int y, int w, int h, float[] fArray)
761 {
762 return sampleModel.getPixels(x - sampleModelTranslateX,
763 y - sampleModelTranslateY, w, h, fArray, dataBuffer);
764 }
765
766 /**
767 * Returns an array containing the samples for the pixels in the region
768 * specified by (x, y, w, h) in the raster. The array is ordered by pixels
769 * (that is, all the samples for the first pixel are grouped together,
770 * followed by all the samples for the second pixel, and so on).
771 * If <code>dArray</code> is not <code>null</code>, it will be populated
772 * with the sample values and returned as the result of this function (this
773 * avoids allocating a new array instance).
774 *
775 * @param x the x-coordinate of the top-left pixel.
776 * @param y the y-coordinate of the top-left pixel.
777 * @param w the width of the region of pixels.
778 * @param h the height of the region of pixels.
779 * @param dArray an array to populate with the sample values and return as
780 * the result (if <code>null</code>, a new array will be allocated).
781 *
782 * @return The pixel sample values.
783 */
784 public double[] getPixels(int x, int y, int w, int h, double[] dArray)
785 {
786 return sampleModel.getPixels(x - sampleModelTranslateX,
787 y - sampleModelTranslateY, w, h, dArray, dataBuffer);
788 }
789
790 /**
791 * Returns the sample value for the pixel at (x, y) in the raster.
792 *
793 * @param x the x-coordinate of the pixel.
794 * @param y the y-coordinate of the pixel.
795 * @param b the band (in the range <code>0</code> to
796 * <code>getNumBands() - 1</code>).
797 *
798 * @return The sample value.
799 */
800 public int getSample(int x, int y, int b)
801 {
802 return sampleModel.getSample(x - sampleModelTranslateX,
803 y - sampleModelTranslateY, b, dataBuffer);
804 }
805
806 /**
807 * Returns the sample value for the pixel at (x, y) in the raster.
808 *
809 * @param x the x-coordinate of the pixel.
810 * @param y the y-coordinate of the pixel.
811 * @param b the band (in the range <code>0</code> to
812 * <code>getNumBands() - 1</code>).
813 *
814 * @return The sample value.
815 *
816 * @see #getSample(int, int, int)
817 */
818 public float getSampleFloat(int x, int y, int b)
819 {
820 return sampleModel.getSampleFloat(x - sampleModelTranslateX,
821 y - sampleModelTranslateY, b, dataBuffer);
822 }
823
824 /**
825 * Returns the sample value for the pixel at (x, y) in the raster.
826 *
827 * @param x the x-coordinate of the pixel.
828 * @param y the y-coordinate of the pixel.
829 * @param b the band (in the range <code>0</code> to
830 * <code>getNumBands() - 1</code>).
831 *
832 * @return The sample value.
833 *
834 * @see #getSample(int, int, int)
835 */
836 public double getSampleDouble(int x, int y, int b)
837 {
838 return sampleModel.getSampleDouble(x - sampleModelTranslateX,
839 y - sampleModelTranslateY, b, dataBuffer);
840 }
841
842 /**
843 * Returns an array containing the samples from one band for the pixels in
844 * the region specified by (x, y, w, h) in the raster. If
845 * <code>iArray</code> is not <code>null</code>, it will be
846 * populated with the sample values and returned as the result of this
847 * function (this avoids allocating a new array instance).
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 an array to populate with the sample values and return as
856 * the result (if <code>null</code>, a new array will be allocated).
857 *
858 * @return The sample values.
859 */
860 public int[] getSamples(int x, int y, int w, int h, int b,
861 int[] iArray)
862 {
863 return sampleModel.getSamples(x - sampleModelTranslateX,
864 y - sampleModelTranslateY, w, h, b, iArray, dataBuffer);
865 }
866
867 /**
868 * Returns an array containing the samples from one band for the pixels in
869 * the region specified by (x, y, w, h) in the raster. If
870 * <code>fArray</code> is not <code>null</code>, it will be
871 * populated with the sample values and returned as the result of this
872 * function (this avoids allocating a new array instance).
873 *
874 * @param x the x-coordinate of the top-left pixel.
875 * @param y the y-coordinate of the top-left pixel.
876 * @param w the width of the region of pixels.
877 * @param h the height of the region of pixels.
878 * @param b the band (in the range <code>0</code> to
879 * </code>getNumBands() - 1</code>).
880 * @param fArray an array to populate with the sample values and return as
881 * the result (if <code>null</code>, a new array will be allocated).
882 *
883 * @return The sample values.
884 */
885 public float[] getSamples(int x, int y, int w, int h, int b, float[] fArray)
886 {
887 return sampleModel.getSamples(x - sampleModelTranslateX,
888 y - sampleModelTranslateY, w, h, b, fArray, dataBuffer);
889 }
890
891 /**
892 * Returns an array containing the samples from one band for the pixels in
893 * the region specified by (x, y, w, h) in the raster. If
894 * <code>dArray</code> is not <code>null</code>, it will be
895 * populated with the sample values and returned as the result of this
896 * function (this avoids allocating a new array instance).
897 *
898 * @param x the x-coordinate of the top-left pixel.
899 * @param y the y-coordinate of the top-left pixel.
900 * @param w the width of the region of pixels.
901 * @param h the height of the region of pixels.
902 * @param b the band (in the range <code>0</code> to
903 * </code>getNumBands() - 1</code>).
904 * @param dArray an array to populate with the sample values and return as
905 * the result (if <code>null</code>, a new array will be allocated).
906 *
907 * @return The sample values.
908 */
909 public double[] getSamples(int x, int y, int w, int h, int b,
910 double[] dArray)
911 {
912 return sampleModel.getSamples(x - sampleModelTranslateX,
913 y - sampleModelTranslateY, w, h, b, dArray, dataBuffer);
914 }
915
916 /**
917 * Create a String representing the state of this Raster.
918 *
919 * @return A String representing the stat of this Raster.
920 */
921 public String toString()
922 {
923 StringBuffer result = new StringBuffer();
924
925 result.append(getClass().getName());
926 result.append("[(");
927 result.append(minX).append(",").append(minY).append("), ");
928 result.append(width).append(" x ").append(height).append(",");
929 result.append(sampleModel).append(",");
930 result.append(dataBuffer);
931 result.append("]");
932
933 return result.toString();
934 }
935
936 /**
937 * Returns the number of bits used to represent the specified data type.
938 * Valid types are:
939 * <ul>
940 * <li>{@link DataBuffer#TYPE_BYTE};</li>
941 * <li>{@link DataBuffer#TYPE_USHORT};</li>
942 * <li>{@link DataBuffer#TYPE_SHORT};</li>
943 * <li>{@link DataBuffer#TYPE_INT};</li>
944 * <li>{@link DataBuffer#TYPE_FLOAT};</li>
945 * <li>{@link DataBuffer#TYPE_DOUBLE};</li>
946 * </ul>
947 * This method returns 0 for invalid data types.
948 *
949 * @param dataType the data type.
950 *
951 * @return The number of bits used to represent the specified data type.
952 */
953 private static int getTypeBits(int dataType)
954 {
955 switch (dataType)
956 {
957 case DataBuffer.TYPE_BYTE:
958 return 8;
959 case DataBuffer.TYPE_USHORT:
960 case DataBuffer.TYPE_SHORT:
961 return 16;
962 case DataBuffer.TYPE_INT:
963 case DataBuffer.TYPE_FLOAT:
964 return 32;
965 case DataBuffer.TYPE_DOUBLE:
966 return 64;
967 default:
968 return 0;
969 }
970 }
971 }