From 554fd8c5195424bdbcabf5de30fdc183aba391bd Mon Sep 17 00:00:00 2001 From: upstream source tree Date: Sun, 15 Mar 2015 20:14:05 -0400 Subject: obtained gcc-4.6.4.tar.bz2 from upstream website; verified gcc-4.6.4.tar.bz2.sig; imported gcc-4.6.4 source tree from verified upstream tarball. downloading a git-generated archive based on the 'upstream' tag should provide you with a source tree that is binary identical to the one extracted from the above tarball. if you have obtained the source via the command 'git clone', however, do note that line-endings of files in your working directory might differ from line-endings of the respective files in the upstream repository. --- libjava/classpath/java/awt/image/SampleModel.java | 974 ++++++++++++++++++++++ 1 file changed, 974 insertions(+) create mode 100644 libjava/classpath/java/awt/image/SampleModel.java (limited to 'libjava/classpath/java/awt/image/SampleModel.java') diff --git a/libjava/classpath/java/awt/image/SampleModel.java b/libjava/classpath/java/awt/image/SampleModel.java new file mode 100644 index 000000000..7e0b18c55 --- /dev/null +++ b/libjava/classpath/java/awt/image/SampleModel.java @@ -0,0 +1,974 @@ +/* Copyright (C) 2000, 2001, 2002, 2005, 2006, Free Software Foundation + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath is distributed in the hope that it will be useful, but +WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + +package java.awt.image; + +/** + * A SampleModel is used to access pixel data from a + * {@link DataBuffer}. This is used by the {@link Raster} class. + * + * @author Rolf W. Rasmussen (rolfwr@ii.uib.no) + */ +public abstract class SampleModel +{ + /** Width of image described. */ + protected int width; + + /** Height of image described. */ + protected int height; + + /** Number of bands in the image described. Package-private here, + shadowed by ComponentSampleModel. */ + protected int numBands; + + /** + * The DataBuffer type that is used to store the data of the image + * described. + */ + protected int dataType; + + /** + * Creates a new sample model with the specified attributes. + * + * @param dataType the data type (one of {@link DataBuffer#TYPE_BYTE}, + * {@link DataBuffer#TYPE_USHORT}, {@link DataBuffer#TYPE_SHORT}, + * {@link DataBuffer#TYPE_INT}, {@link DataBuffer#TYPE_FLOAT}, + * {@link DataBuffer#TYPE_DOUBLE} or {@link DataBuffer#TYPE_UNDEFINED}). + * @param w the width in pixels (must be greater than zero). + * @param h the height in pixels (must be greater than zero). + * @param numBands the number of bands (must be greater than zero). + * + * @throws IllegalArgumentException if dataType is not one of + * the listed values. + * @throws IllegalArgumentException if w is less than or equal + * to zero. + * @throws IllegalArgumentException if h is less than or equal + * to zero. + * @throws IllegalArgumentException if w * h is greater than + * {@link Integer#MAX_VALUE}. + */ + public SampleModel(int dataType, int w, int h, int numBands) + { + if (dataType != DataBuffer.TYPE_UNDEFINED) + if (dataType < DataBuffer.TYPE_BYTE || dataType > DataBuffer.TYPE_DOUBLE) + throw new IllegalArgumentException("Unrecognised 'dataType' argument."); + + if ((w <= 0) || (h <= 0)) + throw new IllegalArgumentException((w <= 0 ? " width<=0" : " width is ok") + + (h <= 0 ? " height<=0" : " height is ok")); + + long area = (long) w * (long) h; + if (area > Integer.MAX_VALUE) + throw new IllegalArgumentException("w * h exceeds Integer.MAX_VALUE."); + + if (numBands <= 0) + throw new IllegalArgumentException("Requires numBands > 0."); + + this.dataType = dataType; + this.width = w; + this.height = h; + this.numBands = numBands; + } + + /** + * Returns the width of the pixel data accessible via this + * SampleModel. + * + * @return The width. + * + * @see #getHeight() + */ + public final int getWidth() + { + return width; + } + + /** + * Returns the height of the pixel data accessible via this + * SampleModel. + * + * @return The height. + * + * @see #getWidth() + */ + public final int getHeight() + { + return height; + } + + /** + * Returns the number of bands for this SampleModel. + * + * @return The number of bands. + */ + public final int getNumBands() + { + return numBands; + } + + public abstract int getNumDataElements(); + + /** + * Returns the type of the {@link DataBuffer} that this + * SampleModel accesses. + * + * @return The data buffer type. + */ + public final int getDataType() + { + return dataType; + } + + public int getTransferType() + { + // FIXME: Is this a reasonable default implementation? + return dataType; + } + + /** + * Returns an array containing the samples for the pixel at (x, y) in the + * specified data buffer. If iArray is not null, + * it will be populated with the sample values and returned as the result of + * this function (this avoids allocating a new array instance). + * + * @param x the x-coordinate of the pixel. + * @param y the y-coordinate of the pixel. + * @param iArray an array to populate with the sample values and return as + * the result (if null, a new array will be allocated). + * @param data the data buffer (null not permitted). + * + * @return The pixel sample values. + * + * @throws NullPointerException if data is null. + */ + public int[] getPixel(int x, int y, int[] iArray, DataBuffer data) + { + if (iArray == null) + iArray = new int[numBands]; + for (int b = 0; b < numBands; b++) + iArray[b] = getSample(x, y, b, data); + return iArray; + } + + /** + * + * This method is provided as a faster alternative to getPixel(), + * that can be used when there is no need to decode the pixel into + * separate sample values. + * + * @param obj An array to return the pixel data in. If null, an + * array of the right type and size will be created. + * + * @return A single pixel as an array object of a primitive type, + * based on the transfer type. Eg. if transfer type is + * DataBuffer.TYPE_USHORT, then a short[] object is returned. + */ + public abstract Object getDataElements(int x, int y, Object obj, + DataBuffer data); + + + public Object getDataElements(int x, int y, int w, int h, Object obj, + DataBuffer data) + { + int size = w * h; + int numDataElements = getNumDataElements(); + int dataSize = numDataElements * size; + + if (obj == null) + { + switch (getTransferType()) + { + case DataBuffer.TYPE_BYTE: + obj = new byte[dataSize]; + break; + case DataBuffer.TYPE_USHORT: + obj = new short[dataSize]; + break; + case DataBuffer.TYPE_INT: + obj = new int[dataSize]; + break; + default: + // Seems like the only sensible thing to do. + throw new ClassCastException(); + } + } + Object pixelData = null; + int outOffset = 0; + for (int yy = y; yy < (y + h); yy++) + { + for (int xx = x; xx < (x + w); xx++) + { + pixelData = getDataElements(xx, yy, pixelData, data); + System.arraycopy(pixelData, 0, obj, outOffset, + numDataElements); + outOffset += numDataElements; + } + } + return obj; + } + + public abstract void setDataElements(int x, int y, Object obj, + DataBuffer data); + + public void setDataElements(int x, int y, int w, int h, + Object obj, DataBuffer data) + { + int numDataElements = getNumDataElements(); + + Object pixelData; + switch (getTransferType()) + { + case DataBuffer.TYPE_BYTE: + pixelData = new byte[numDataElements]; + break; + case DataBuffer.TYPE_USHORT: + case DataBuffer.TYPE_SHORT: + pixelData = new short[numDataElements]; + break; + case DataBuffer.TYPE_INT: + pixelData = new int[numDataElements]; + break; + case DataBuffer.TYPE_FLOAT: + pixelData = new float[numDataElements]; + break; + case DataBuffer.TYPE_DOUBLE: + pixelData = new double[numDataElements]; + break; + default: + // The RI silently igores invalid types. + pixelData = null; + } + + int inOffset = 0; + if (pixelData != null) + { + for (int yy=y; yy<(y+h); yy++) + { + for (int xx=x; xx<(x+w); xx++) + { + System.arraycopy(obj, inOffset, pixelData, 0, numDataElements); + setDataElements(xx, yy, pixelData, data); + inOffset += numDataElements; + } + } + } + } + + /** + * Returns an array containing the samples for the pixel at (x, y) in the + * specified data buffer. If fArray is not null, + * it will be populated with the sample values and returned as the result of + * this function (this avoids allocating a new array instance). + * + * @param x the x-coordinate of the pixel. + * @param y the y-coordinate of the pixel. + * @param fArray an array to populate with the sample values and return as + * the result (if null, a new array will be allocated). + * @param data the data buffer (null not permitted). + * + * @return The pixel sample values. + * + * @throws NullPointerException if data is null. + */ + public float[] getPixel(int x, int y, float[] fArray, DataBuffer data) + { + if (fArray == null) + fArray = new float[numBands]; + + for (int b = 0; b < numBands; b++) + { + fArray[b] = getSampleFloat(x, y, b, data); + } + return fArray; + } + + /** + * Returns an array containing the samples for the pixel at (x, y) in the + * specified data buffer. If dArray is not null, + * it will be populated with the sample values and returned as the result of + * this function (this avoids allocating a new array instance). + * + * @param x the x-coordinate of the pixel. + * @param y the y-coordinate of the pixel. + * @param dArray an array to populate with the sample values and return as + * the result (if null, a new array will be allocated). + * @param data the data buffer (null not permitted). + * + * @return The pixel sample values. + * + * @throws NullPointerException if data is null. + */ + public double[] getPixel(int x, int y, double[] dArray, DataBuffer data) { + if (dArray == null) + dArray = new double[numBands]; + for (int b = 0; b < numBands; b++) + { + dArray[b] = getSampleDouble(x, y, b, data); + } + return dArray; + } + + /** + * Returns an array containing the samples for the pixels in the region + * specified by (x, y, w, h) in the specified data buffer. The array is + * ordered by pixels (that is, all the samples for the first pixel are + * grouped together, followed by all the samples for the second pixel, and so + * on). If iArray is not null, it will be + * populated with the sample values and returned as the result of this + * function (this avoids allocating a new array instance). + * + * @param x the x-coordinate of the top-left pixel. + * @param y the y-coordinate of the top-left pixel. + * @param w the width of the region of pixels. + * @param h the height of the region of pixels. + * @param iArray an array to populate with the sample values and return as + * the result (if null, a new array will be allocated). + * @param data the data buffer (null not permitted). + * + * @return The pixel sample values. + * + * @throws NullPointerException if data is null. + */ + public int[] getPixels(int x, int y, int w, int h, int[] iArray, + DataBuffer data) + { + int size = w * h; + int outOffset = 0; + int[] pixel = null; + if (iArray == null) + iArray = new int[w * h * numBands]; + for (int yy = y; yy < (y + h); yy++) + { + for (int xx = x; xx < (x + w); xx++) + { + pixel = getPixel(xx, yy, pixel, data); + System.arraycopy(pixel, 0, iArray, outOffset, numBands); + outOffset += numBands; + } + } + return iArray; + } + + /** + * Returns an array containing the samples for the pixels in the region + * specified by (x, y, w, h) in the specified data buffer. The array is + * ordered by pixels (that is, all the samples for the first pixel are + * grouped together, followed by all the samples for the second pixel, and so + * on). If fArray is not null, it will be + * populated with the sample values and returned as the result of this + * function (this avoids allocating a new array instance). + * + * @param x the x-coordinate of the top-left pixel. + * @param y the y-coordinate of the top-left pixel. + * @param w the width of the region of pixels. + * @param h the height of the region of pixels. + * @param fArray an array to populate with the sample values and return as + * the result (if null, a new array will be allocated). + * @param data the data buffer (null not permitted). + * + * @return The pixel sample values. + * + * @throws NullPointerException if data is null. + */ + public float[] getPixels(int x, int y, int w, int h, float[] fArray, + DataBuffer data) + { + int size = w * h; + int outOffset = 0; + float[] pixel = null; + if (fArray == null) fArray = new float[w * h * numBands]; + for (int yy = y; yy < (y + h); yy++) + { + for (int xx = x; xx < (x + w); xx++) + { + pixel = getPixel(xx, yy, pixel, data); + System.arraycopy(pixel, 0, fArray, outOffset, numBands); + outOffset += numBands; + } + } + return fArray; + } + + /** + * Returns an array containing the samples for the pixels in the region + * specified by (x, y, w, h) in the specified data buffer. The array is + * ordered by pixels (that is, all the samples for the first pixel are + * grouped together, followed by all the samples for the second pixel, and so + * on). If dArray is not null, it will be + * populated with the sample values and returned as the result of this + * function (this avoids allocating a new array instance). + * + * @param x the x-coordinate of the top-left pixel. + * @param y the y-coordinate of the top-left pixel. + * @param w the width of the region of pixels. + * @param h the height of the region of pixels. + * @param dArray an array to populate with the sample values and return as + * the result (if null, a new array will be allocated). + * @param data the data buffer (null not permitted). + * + * @return The pixel sample values. + * + * @throws NullPointerException if data is null. + */ + public double[] getPixels(int x, int y, int w, int h, double[] dArray, + DataBuffer data) + { + int size = w * h; + int outOffset = 0; + double[] pixel = null; + if (dArray == null) + dArray = new double[w * h * numBands]; + for (int yy = y; yy < (y + h); yy++) + { + for (int xx = x; xx < (x + w); xx++) + { + pixel = getPixel(xx, yy, pixel, data); + System.arraycopy(pixel, 0, dArray, outOffset, numBands); + outOffset += numBands; + } + } + return dArray; + } + + /** + * Returns the sample value for the pixel at (x, y) in the specified data + * buffer. + * + * @param x the x-coordinate of the pixel. + * @param y the y-coordinate of the pixel. + * @param b the band (in the range 0 to + * getNumBands() - 1). + * @param data the data buffer (null not permitted). + * + * @return The sample value. + * + * @throws NullPointerException if data is null. + */ + public abstract int getSample(int x, int y, int b, DataBuffer data); + + /** + * Returns the sample value for the pixel at (x, y) in the specified data + * buffer. + * + * @param x the x-coordinate of the pixel. + * @param y the y-coordinate of the pixel. + * @param b the band (in the range 0 to + * getNumBands() - 1). + * @param data the data buffer (null not permitted). + * + * @return The sample value. + * + * @throws NullPointerException if data is null. + * + * @see #getSample(int, int, int, DataBuffer) + */ + public float getSampleFloat(int x, int y, int b, DataBuffer data) + { + return getSample(x, y, b, data); + } + + /** + * Returns the sample value for the pixel at (x, y) in the specified data + * buffer. + * + * @param x the x-coordinate of the pixel. + * @param y the y-coordinate of the pixel. + * @param b the band (in the range 0 to + * getNumBands() - 1). + * @param data the data buffer (null not permitted). + * + * @return The sample value. + * + * @throws NullPointerException if data is null. + * + * @see #getSample(int, int, int, DataBuffer) + */ + public double getSampleDouble(int x, int y, int b, DataBuffer data) + { + return getSampleFloat(x, y, b, data); + } + + /** + * Returns an array containing the samples from one band for the pixels in + * the region specified by (x, y, w, h) in the specified data buffer. If + * iArray is not null, it will be + * populated with the sample values and returned as the result of this + * function (this avoids allocating a new array instance). + * + * @param x the x-coordinate of the top-left pixel. + * @param y the y-coordinate of the top-left pixel. + * @param w the width of the region of pixels. + * @param h the height of the region of pixels. + * @param b the band (in the range 0 to + * getNumBands() - 1). + * @param iArray an array to populate with the sample values and return as + * the result (if null, a new array will be allocated). + * @param data the data buffer (null not permitted). + * + * @return The sample values. + * + * @throws NullPointerException if data is null. + */ + public int[] getSamples(int x, int y, int w, int h, int b, + int[] iArray, DataBuffer data) + { + int size = w * h; + int outOffset = 0; + if (iArray == null) + iArray = new int[size]; + for (int yy = y; yy < (y + h); yy++) + { + for (int xx = x; xx < (x + w); xx++) + { + iArray[outOffset++] = getSample(xx, yy, b, data); + } + } + return iArray; + } + + /** + * Returns an array containing the samples from one band for the pixels in + * the region specified by (x, y, w, h) in the specified data buffer. If + * fArray is not null, it will be + * populated with the sample values and returned as the result of this + * function (this avoids allocating a new array instance). + * + * @param x the x-coordinate of the top-left pixel. + * @param y the y-coordinate of the top-left pixel. + * @param w the width of the region of pixels. + * @param h the height of the region of pixels. + * @param b the band (in the range 0 to + * getNumBands() - 1). + * @param fArray an array to populate with the sample values and return as + * the result (if null, a new array will be allocated). + * @param data the data buffer (null not permitted). + * + * @return The sample values. + * + * @throws NullPointerException if data is null. + */ + public float[] getSamples(int x, int y, int w, int h, int b, + float[] fArray, DataBuffer data) + { + int size = w * h; + int outOffset = 0; + if (fArray == null) + fArray = new float[size]; + for (int yy = y; yy < (y + h); yy++) + { + for (int xx = x; xx < (x + w); xx++) + { + fArray[outOffset++] = getSampleFloat(xx, yy, b, data); + } + } + return fArray; + } + + /** + * Returns an array containing the samples from one band for the pixels in + * the region specified by (x, y, w, h) in the specified data buffer. If + * dArray is not null, it will be + * populated with the sample values and returned as the result of this + * function (this avoids allocating a new array instance). + * + * @param x the x-coordinate of the top-left pixel. + * @param y the y-coordinate of the top-left pixel. + * @param w the width of the region of pixels. + * @param h the height of the region of pixels. + * @param b the band (in the range 0 to + * getNumBands() - 1). + * @param dArray an array to populate with the sample values and return as + * the result (if null, a new array will be allocated). + * @param data the data buffer (null not permitted). + * + * @return The sample values. + * + * @throws NullPointerException if data is null. + */ + public double[] getSamples(int x, int y, int w, int h, int b, + double[] dArray, DataBuffer data) + { + int size = w * h; + int outOffset = 0; + if (dArray == null) + dArray = new double[size]; + for (int yy = y; yy < (y + h); yy++) + { + for (int xx = x; xx < (x + w); xx++) + { + dArray[outOffset++] = getSampleDouble(xx, yy, b, data); + } + } + return dArray; + } + + /** + * Sets the samples for the pixel at (x, y) in the specified data buffer to + * the specified values. + * + * @param x the x-coordinate of the pixel. + * @param y the y-coordinate of the pixel. + * @param iArray the sample values (null not permitted). + * @param data the data buffer (null not permitted). + * + * @throws NullPointerException if either iArray or + * data is null. + */ + public void setPixel(int x, int y, int[] iArray, DataBuffer data) + { + for (int b = 0; b < numBands; b++) + setSample(x, y, b, iArray[b], data); + } + + /** + * Sets the samples for the pixel at (x, y) in the specified data buffer to + * the specified values. + * + * @param x the x-coordinate of the pixel. + * @param y the y-coordinate of the pixel. + * @param fArray the sample values (null not permitted). + * @param data the data buffer (null not permitted). + * + * @throws NullPointerException if either fArray or + * data is null. + */ + public void setPixel(int x, int y, float[] fArray, DataBuffer data) + { + for (int b = 0; b < numBands; b++) + setSample(x, y, b, fArray[b], data); + } + + /** + * Sets the samples for the pixel at (x, y) in the specified data buffer to + * the specified values. + * + * @param x the x-coordinate of the pixel. + * @param y the y-coordinate of the pixel. + * @param dArray the sample values (null not permitted). + * @param data the data buffer (null not permitted). + * + * @throws NullPointerException if either dArray or + * data is null. + */ + public void setPixel(int x, int y, double[] dArray, DataBuffer data) + { + for (int b = 0; b < numBands; b++) + setSample(x, y, b, dArray[b], data); + } + + /** + * Sets the sample values for the pixels in the region specified by + * (x, y, w, h) in the specified data buffer. The array is + * ordered by pixels (that is, all the samples for the first pixel are + * grouped together, followed by all the samples for the second pixel, and so + * on). + * + * @param x the x-coordinate of the top-left pixel. + * @param y the y-coordinate of the top-left pixel. + * @param w the width of the region of pixels. + * @param h the height of the region of pixels. + * @param iArray the pixel sample values (null not permitted). + * @param data the data buffer (null not permitted). + * + * @throws NullPointerException if either iArray or + * data is null. + */ + public void setPixels(int x, int y, int w, int h, int[] iArray, + DataBuffer data) + { + int inOffset = 0; + int[] pixel = new int[numBands]; + for (int yy = y; yy < (y + h); yy++) + { + for (int xx = x; xx < (x + w); xx++) + { + System.arraycopy(iArray, inOffset, pixel, 0, numBands); + setPixel(xx, yy, pixel, data); + inOffset += numBands; + } + } + } + + /** + * Sets the sample values for the pixels in the region specified by + * (x, y, w, h) in the specified data buffer. The array is + * ordered by pixels (that is, all the samples for the first pixel are + * grouped together, followed by all the samples for the second pixel, and so + * on). + * + * @param x the x-coordinate of the top-left pixel. + * @param y the y-coordinate of the top-left pixel. + * @param w the width of the region of pixels. + * @param h the height of the region of pixels. + * @param fArray the pixel sample values (null not permitted). + * @param data the data buffer (null not permitted). + * + * @throws NullPointerException if either fArray or + * data is null. + */ + public void setPixels(int x, int y, int w, int h, float[] fArray, + DataBuffer data) + { + int inOffset = 0; + float[] pixel = new float[numBands]; + for (int yy = y; yy < (y + h); yy++) + { + for (int xx = x; xx < (x + w); xx++) + { + System.arraycopy(fArray, inOffset, pixel, 0, numBands); + setPixel(xx, yy, pixel, data); + inOffset += numBands; + } + } + } + + /** + * Sets the sample values for the pixels in the region specified by + * (x, y, w, h) in the specified data buffer. The array is + * ordered by pixels (that is, all the samples for the first pixel are + * grouped together, followed by all the samples for the second pixel, and so + * on). + * + * @param x the x-coordinate of the top-left pixel. + * @param y the y-coordinate of the top-left pixel. + * @param w the width of the region of pixels. + * @param h the height of the region of pixels. + * @param dArray the pixel sample values (null not permitted). + * @param data the data buffer (null not permitted). + * + * @throws NullPointerException if either dArray or + * data is null. + */ + public void setPixels(int x, int y, int w, int h, double[] dArray, + DataBuffer data) + { + int inOffset = 0; + double[] pixel = new double[numBands]; + for (int yy = y; yy < (y + h); yy++) + { + for (int xx = x; xx < (x + w); xx++) + { + System.arraycopy(dArray, inOffset, pixel, 0, numBands); + setPixel(xx, yy, pixel, data); + inOffset += numBands; + } + } + } + + /** + * Sets the sample value for a band for the pixel at (x, y) in the + * specified data buffer. + * + * @param x the x-coordinate of the pixel. + * @param y the y-coordinate of the pixel. + * @param b the band (in the range 0 to + * getNumBands() - 1). + * @param s the sample value. + * @param data the data buffer (null not permitted). + * + * @throws NullPointerException if data is null. + */ + public abstract void setSample(int x, int y, int b, int s, + DataBuffer data); + + /** + * Sets the sample value for a band for the pixel at (x, y) in the + * specified data buffer. + * + * @param x the x-coordinate of the pixel. + * @param y the y-coordinate of the pixel. + * @param b the band (in the range 0 to + * getNumBands() - 1). + * @param s the sample value. + * @param data the data buffer (null not permitted). + * + * @throws NullPointerException if data is null. + */ + public void setSample(int x, int y, int b, float s, + DataBuffer data) + { + setSample(x, y, b, (int) s, data); + } + + /** + * Sets the sample value for a band for the pixel at (x, y) in the + * specified data buffer. + * + * @param x the x-coordinate of the pixel. + * @param y the y-coordinate of the pixel. + * @param b the band (in the range 0 to + * getNumBands() - 1). + * @param s the sample value. + * @param data the data buffer (null not permitted). + * + * @throws NullPointerException if data is null. + */ + public void setSample(int x, int y, int b, double s, + DataBuffer data) + { + setSample(x, y, b, (float) s, data); + } + + /** + * Sets the sample values for one band for the pixels in the region + * specified by (x, y, w, h) in the specified data buffer. + * + * @param x the x-coordinate of the top-left pixel. + * @param y the y-coordinate of the top-left pixel. + * @param w the width of the region of pixels. + * @param h the height of the region of pixels. + * @param b the band (in the range 0 to + * getNumBands() - 1). + * @param iArray the sample values (null not permitted). + * @param data the data buffer (null not permitted). + * + * @throws NullPointerException if either iArray or + * data is null. + */ + public void setSamples(int x, int y, int w, int h, int b, + int[] iArray, DataBuffer data) + { + int size = w * h; + int inOffset = 0; + for (int yy = y; yy < (y + h); yy++) + for (int xx = x; xx < (x + w); xx++) + setSample(xx, yy, b, iArray[inOffset++], data); + } + + /** + * Sets the sample values for one band for the pixels in the region + * specified by (x, y, w, h) in the specified data buffer. + * + * @param x the x-coordinate of the top-left pixel. + * @param y the y-coordinate of the top-left pixel. + * @param w the width of the region of pixels. + * @param h the height of the region of pixels. + * @param b the band (in the range 0 to + * getNumBands() - 1). + * @param fArray the sample values (null not permitted). + * @param data the data buffer (null not permitted). + * + * @throws NullPointerException if either iArray or + * data is null. + */ + public void setSamples(int x, int y, int w, int h, int b, + float[] fArray, DataBuffer data) + { + int size = w * h; + int inOffset = 0; + for (int yy = y; yy < (y + h); yy++) + for (int xx = x; xx < (x + w); xx++) + setSample(xx, yy, b, fArray[inOffset++], data); + + } + + /** + * Sets the sample values for one band for the pixels in the region + * specified by (x, y, w, h) in the specified data buffer. + * + * @param x the x-coordinate of the top-left pixel. + * @param y the y-coordinate of the top-left pixel. + * @param w the width of the region of pixels. + * @param h the height of the region of pixels. + * @param b the band (in the range 0 to + * getNumBands() - 1). + * @param dArray the sample values (null not permitted). + * @param data the data buffer (null not permitted). + * + * @throws NullPointerException if either iArray or + * data is null. + */ + public void setSamples(int x, int y, int w, int h, int b, + double[] dArray, DataBuffer data) { + int size = w * h; + int inOffset = 0; + for (int yy = y; yy < (y + h); yy++) + for (int xx = x; xx < (x + w); xx++) + setSample(xx, yy, b, dArray[inOffset++], data); + } + + /** + * Creates a new SampleModel that is compatible with this + * model and has the specified width and height. + * + * @param w the width (in pixels). + * @param h the height (in pixels). + * + * @return The new sample model. + */ + public abstract SampleModel createCompatibleSampleModel(int w, int h); + + /** + * Return a SampleModel with a subset of the bands in this model. + * + * Selects bands.length bands from this sample model. The bands chosen + * are specified in the indices of bands[]. This also permits permuting + * the bands as well as taking a subset. Thus, giving an array with + * 1, 2, 3, ..., numbands, will give an identical sample model. + * + * @param bands Array with band indices to include. + * @return A new sample model + */ + public abstract SampleModel createSubsetSampleModel(int[] bands); + + /** + * Creates a new {@link DataBuffer} of the correct type and size for this + * SampleModel. + * + * @return The data buffer. + */ + public abstract DataBuffer createDataBuffer(); + + /** + * Returns an array containing the size (in bits) for each band accessed by + * the SampleModel. + * + * @return An array. + * + * @see #getSampleSize(int) + */ + public abstract int[] getSampleSize(); + + /** + * Returns the size (in bits) of the samples for the specified band. + * + * @param band the band (in the range 0 to + * getNumBands() - 1). + * + * @return The sample size (in bits). + */ + public abstract int getSampleSize(int band); +} -- cgit v1.2.3