| /* | |
| * Copyright (c) 1997, 2024, Oracle and/or its affiliates. All rights reserved. | |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. | |
| * | |
| * This code is free software; you can redistribute it and/or modify it | |
| * under the terms of the GNU General Public License version 2 only, as | |
| * published by the Free Software Foundation. Oracle designates this | |
| * particular file as subject to the "Classpath" exception as provided | |
| * by Oracle in the LICENSE file that accompanied this code. | |
| * | |
| * This code 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 | |
| * version 2 for more details (a copy is included in the LICENSE file that | |
| * accompanied this code). | |
| * | |
| * You should have received a copy of the GNU General Public License version | |
| * 2 along with this work; if not, write to the Free Software Foundation, | |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
| * | |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA | |
| * or visit www.oracle.com if you need additional information or have any | |
| * questions. | |
| */ | |
| /* **************************************************************** | |
| ****************************************************************** | |
| ****************************************************************** | |
| *** COPYRIGHT (c) Eastman Kodak Company, 1997 | |
| *** As an unpublished work pursuant to Title 17 of the United | |
| *** States Code. All rights reserved. | |
| ****************************************************************** | |
| ****************************************************************** | |
| ******************************************************************/ | |
| package java.awt.image; | |
| import java.awt.Rectangle; | |
| import java.awt.Point; | |
| /** | |
| * This class extends Raster to provide pixel writing capabilities. | |
| * Refer to the class comment for Raster for descriptions of how | |
| * a Raster stores pixels. | |
| * | |
| * <p> The constructors of this class are protected. To instantiate | |
| * a WritableRaster, use one of the createWritableRaster factory methods | |
| * in the Raster class. | |
| */ | |
| public class WritableRaster extends Raster { | |
| /** | |
| * Constructs a WritableRaster with the given SampleModel. The | |
| * WritableRaster's upper left corner is origin and it is the | |
| * same size as the SampleModel. A DataBuffer large enough to | |
| * describe the WritableRaster is automatically created. | |
| * @param sampleModel The SampleModel that specifies the layout. | |
| * @param origin The Point that specifies the origin. | |
| * @throws RasterFormatException if computing either | |
| * {@code origin.x + sampleModel.getWidth()} or | |
| * {@code origin.y + sampleModel.getHeight()} results | |
| * in integer overflow | |
| */ | |
| protected WritableRaster(SampleModel sampleModel, | |
| Point origin) { | |
| this(sampleModel, | |
| sampleModel.createDataBuffer(), | |
| new Rectangle(origin.x, | |
| origin.y, | |
| sampleModel.getWidth(), | |
| sampleModel.getHeight()), | |
| origin, | |
| null); | |
| } | |
| /** | |
| * Constructs a WritableRaster with the given SampleModel and DataBuffer. | |
| * The WritableRaster's upper left corner is origin and it is the same | |
| * size as the SampleModel. The DataBuffer is not initialized and must | |
| * be compatible with SampleModel. | |
| * @param sampleModel The SampleModel that specifies the layout. | |
| * @param dataBuffer The DataBuffer that contains the image data. | |
| * @param origin The Point that specifies the origin. | |
| * @throws RasterFormatException if computing either | |
| * {@code origin.x + sampleModel.getWidth()} or | |
| * {@code origin.y + sampleModel.getHeight()} results | |
| * in integer overflow | |
| */ | |
| protected WritableRaster(SampleModel sampleModel, | |
| DataBuffer dataBuffer, | |
| Point origin) { | |
| this(sampleModel, | |
| dataBuffer, | |
| new Rectangle(origin.x, | |
| origin.y, | |
| sampleModel.getWidth(), | |
| sampleModel.getHeight()), | |
| origin, | |
| null); | |
| } | |
| /** | |
| * Constructs a WritableRaster with the given SampleModel, DataBuffer, | |
| * and parent. aRegion specifies the bounding rectangle of the new | |
| * Raster. When translated into the base Raster's coordinate | |
| * system, aRegion must be contained by the base Raster. | |
| * (The base Raster is the Raster's ancestor which has no parent.) | |
| * sampleModelTranslate specifies the sampleModelTranslateX and | |
| * sampleModelTranslateY values of the new Raster. | |
| * | |
| * Note that this constructor should generally be called by other | |
| * constructors or create methods, it should not be used directly. | |
| * @param sampleModel The SampleModel that specifies the layout. | |
| * @param dataBuffer The DataBuffer that contains the image data. | |
| * @param aRegion The Rectangle that specifies the image area. | |
| * @param sampleModelTranslate The Point that specifies the translation | |
| * from SampleModel to Raster coordinates. | |
| * @param parent The parent (if any) of this raster. | |
| * @throws RasterFormatException if {@code aRegion} has width | |
| * or height less than or equal to zero, or computing either | |
| * {@code aRegion.x + aRegion.width} or | |
| * {@code aRegion.y + aRegion.height} results in integer | |
| * overflow | |
| */ | |
| protected WritableRaster(SampleModel sampleModel, | |
| DataBuffer dataBuffer, | |
| Rectangle aRegion, | |
| Point sampleModelTranslate, | |
| WritableRaster parent){ | |
| super(sampleModel,dataBuffer,aRegion,sampleModelTranslate,parent); | |
| } | |
| /** Returns the parent WritableRaster (if any) of this WritableRaster, | |
| * or else null. | |
| * @return the parent of this {@code WritableRaster}, or | |
| * {@code null}. | |
| */ | |
| public WritableRaster getWritableParent() { | |
| return (WritableRaster)parent; | |
| } | |
| /** | |
| * Create a WritableRaster with the same size, SampleModel and DataBuffer | |
| * as this one, but with a different location. The new WritableRaster | |
| * will possess a reference to the current WritableRaster, accessible | |
| * through its getParent() and getWritableParent() methods. | |
| * | |
| * @param childMinX X coord of the upper left corner of the new Raster. | |
| * @param childMinY Y coord of the upper left corner of the new Raster. | |
| * @return a {@code WritableRaster} the same as this one except | |
| * for the specified location. | |
| * @throws RasterFormatException if computing either | |
| * {@code childMinX + this.getWidth()} or | |
| * {@code childMinY + this.getHeight()} results in integer | |
| * overflow | |
| */ | |
| public WritableRaster createWritableTranslatedChild(int childMinX, | |
| int childMinY) { | |
| return createWritableChild(minX,minY,width,height, | |
| childMinX,childMinY,null); | |
| } | |
| /** | |
| * Returns a new WritableRaster which shares all or part of this | |
| * WritableRaster's DataBuffer. The new WritableRaster will | |
| * possess a reference to the current WritableRaster, accessible | |
| * through its getParent() and getWritableParent() methods. | |
| * | |
| * <p> The parentX, parentY, width and height parameters form a | |
| * Rectangle in this WritableRaster's coordinate space, indicating | |
| * the area of pixels to be shared. An error will be thrown if | |
| * this Rectangle is not contained with the bounds of the current | |
| * WritableRaster. | |
| * | |
| * <p> The new WritableRaster may additionally be translated to a | |
| * different coordinate system for the plane than that used by the current | |
| * WritableRaster. The childMinX and childMinY parameters give | |
| * the new (x, y) coordinate of the upper-left pixel of the | |
| * returned WritableRaster; the coordinate (childMinX, childMinY) | |
| * in the new WritableRaster will map to the same pixel as the | |
| * coordinate (parentX, parentY) in the current WritableRaster. | |
| * | |
| * <p> The new WritableRaster may be defined to contain only a | |
| * subset of the bands of the current WritableRaster, possibly | |
| * reordered, by means of the bandList parameter. If bandList is | |
| * null, it is taken to include all of the bands of the current | |
| * WritableRaster in their current order. | |
| * | |
| * <p> To create a new WritableRaster that contains a subregion of | |
| * the current WritableRaster, but shares its coordinate system | |
| * and bands, this method should be called with childMinX equal to | |
| * parentX, childMinY equal to parentY, and bandList equal to | |
| * null. | |
| * | |
| * @param parentX X coordinate of the upper left corner in this | |
| * WritableRaster's coordinates. | |
| * @param parentY Y coordinate of the upper left corner in this | |
| * WritableRaster's coordinates. | |
| * @param w Width of the region starting at (parentX, parentY). | |
| * @param h Height of the region starting at (parentX, parentY). | |
| * @param childMinX X coordinate of the upper left corner of | |
| * the returned WritableRaster. | |
| * @param childMinY Y coordinate of the upper left corner of | |
| * the returned WritableRaster. | |
| * @param bandList Array of band indices, or null to use all bands. | |
| * @return a {@code WritableRaster} sharing all or part of the | |
| * {@code DataBuffer} of this {@code WritableRaster}. | |
| * @throws RasterFormatException if the subregion is outside of the | |
| * raster bounds. | |
| * @throws RasterFormatException if {@code w} or | |
| * {@code h} | |
| * is less than or equal to zero, or computing any of | |
| * {@code parentX + w}, {@code parentY + h}, | |
| * {@code childMinX + w}, or | |
| * {@code childMinY + h} results in integer | |
| * overflow | |
| */ | |
| public WritableRaster createWritableChild(int parentX, int parentY, | |
| int w, int h, | |
| int childMinX, int childMinY, | |
| int[] bandList) { | |
| if (parentX < this.minX) { | |
| throw new RasterFormatException("parentX lies outside raster"); | |
| } | |
| if (parentY < this.minY) { | |
| throw new RasterFormatException("parentY lies outside raster"); | |
| } | |
| if ((parentX+w < parentX) || (parentX+w > this.width + this.minX)) { | |
| throw new RasterFormatException("(parentX + width) is outside raster"); | |
| } | |
| if ((parentY+h < parentY) || (parentY+h > this.height + this.minY)) { | |
| throw new RasterFormatException("(parentY + height) is outside raster"); | |
| } | |
| SampleModel sm; | |
| // Note: the SampleModel for the child Raster should have the same | |
| // width and height as that for the parent, since it represents | |
| // the physical layout of the pixel data. The child Raster's width | |
| // and height represent a "virtual" view of the pixel data, so | |
| // they may be different than those of the SampleModel. | |
| if (bandList != null) { | |
| sm = sampleModel.createSubsetSampleModel(bandList); | |
| } | |
| else { | |
| sm = sampleModel; | |
| } | |
| int deltaX = childMinX - parentX; | |
| int deltaY = childMinY - parentY; | |
| return new WritableRaster(sm, | |
| getDataBuffer(), | |
| new Rectangle(childMinX,childMinY, | |
| w, h), | |
| new Point(sampleModelTranslateX+deltaX, | |
| sampleModelTranslateY+deltaY), | |
| this); | |
| } | |
| /** | |
| * Sets the data for a single pixel from a | |
| * primitive array of type TransferType. For image data supported by | |
| * the Java 2D(tm) API, this will be one of DataBuffer.TYPE_BYTE, | |
| * DataBuffer.TYPE_USHORT, DataBuffer.TYPE_INT, DataBuffer.TYPE_SHORT, | |
| * DataBuffer.TYPE_FLOAT, or DataBuffer.TYPE_DOUBLE. Data in the array | |
| * may be in a packed format, thus increasing efficiency for data | |
| * transfers. | |
| * An ArrayIndexOutOfBoundsException may be thrown if the coordinates are | |
| * not in bounds, or if inData is not large enough to hold the pixel data. | |
| * However, explicit bounds checking is not guaranteed. | |
| * A ClassCastException will be thrown if the input object is not null | |
| * and references anything other than an array of TransferType. | |
| * @see java.awt.image.SampleModel#setDataElements(int, int, Object, DataBuffer) | |
| * @param x The X coordinate of the pixel location. | |
| * @param y The Y coordinate of the pixel location. | |
| * @param inData An object reference to an array of type defined by | |
| * getTransferType() and length getNumDataElements() | |
| * containing the pixel data to place at x,y. | |
| * | |
| * @throws ArrayIndexOutOfBoundsException if the coordinates are not | |
| * in bounds, or if inData is too small to hold the input. | |
| */ | |
| public void setDataElements(int x, int y, Object inData) { | |
| sampleModel.setDataElements(x-sampleModelTranslateX, | |
| y-sampleModelTranslateY, | |
| inData, dataBuffer); | |
| } | |
| /** | |
| * Sets the data for a rectangle of pixels from an input Raster. | |
| * The input Raster must be compatible with this WritableRaster | |
| * in that they must have the same number of bands, corresponding bands | |
| * must have the same number of bits per sample, the TransferTypes | |
| * and NumDataElements must be the same, and the packing used by | |
| * the getDataElements/setDataElements must be identical. | |
| * An ArrayIndexOutOfBoundsException may be thrown if the coordinates are | |
| * not in bounds. | |
| * However, explicit bounds checking is not guaranteed. | |
| * @param x The X coordinate of the pixel location. | |
| * @param y The Y coordinate of the pixel location. | |
| * @param inRaster Raster containing data to place at x,y. | |
| * | |
| * @throws NullPointerException if inRaster is null. | |
| * @throws ArrayIndexOutOfBoundsException if the coordinates are not | |
| * in bounds. | |
| */ | |
| public void setDataElements(int x, int y, Raster inRaster) { | |
| int dstOffX = x+inRaster.getMinX(); | |
| int dstOffY = y+inRaster.getMinY(); | |
| int width = inRaster.getWidth(); | |
| int height = inRaster.getHeight(); | |
| if ((dstOffX < this.minX) || (dstOffY < this.minY) || | |
| (dstOffX + width > this.minX + this.width) || | |
| (dstOffY + height > this.minY + this.height)) { | |
| throw new ArrayIndexOutOfBoundsException | |
| ("Coordinate out of bounds!"); | |
| } | |
| int srcOffX = inRaster.getMinX(); | |
| int srcOffY = inRaster.getMinY(); | |
| Object tdata = null; | |
| for (int startY=0; startY < height; startY++) { | |
| tdata = inRaster.getDataElements(srcOffX, srcOffY+startY, | |
| width, 1, tdata); | |
| setDataElements(dstOffX, dstOffY+startY, | |
| width, 1, tdata); | |
| } | |
| } | |
| /** | |
| * Sets the data for a rectangle of pixels from a | |
| * primitive array of type TransferType. For image data supported by | |
| * the Java 2D API, this will be one of DataBuffer.TYPE_BYTE, | |
| * DataBuffer.TYPE_USHORT, DataBuffer.TYPE_INT, DataBuffer.TYPE_SHORT, | |
| * DataBuffer.TYPE_FLOAT, or DataBuffer.TYPE_DOUBLE. Data in the array | |
| * may be in a packed format, thus increasing efficiency for data | |
| * transfers. | |
| * An ArrayIndexOutOfBoundsException may be thrown if the coordinates are | |
| * not in bounds, or if inData is not large enough to hold the pixel data. | |
| * However, explicit bounds checking is not guaranteed. | |
| * A ClassCastException will be thrown if the input object is not null | |
| * and references anything other than an array of TransferType. | |
| * @see java.awt.image.SampleModel#setDataElements(int, int, int, int, Object, DataBuffer) | |
| * @param x The X coordinate of the upper left pixel location. | |
| * @param y The Y coordinate of the upper left pixel location. | |
| * @param w Width of the pixel rectangle. | |
| * @param h Height of the pixel rectangle. | |
| * @param inData An object reference to an array of type defined by | |
| * getTransferType() and length w*h*getNumDataElements() | |
| * containing the pixel data to place between x,y and | |
| * x+w-1, y+h-1. | |
| * | |
| * @throws NullPointerException if inData is null. | |
| * @throws ArrayIndexOutOfBoundsException if the coordinates are not | |
| * in bounds, or if inData is too small to hold the input. | |
| */ | |
| public void setDataElements(int x, int y, int w, int h, Object inData) { | |
| sampleModel.setDataElements(x-sampleModelTranslateX, | |
| y-sampleModelTranslateY, | |
| w,h,inData,dataBuffer); | |
| } | |
| /** | |
| * Copies pixels from Raster srcRaster to this WritableRaster. Each pixel | |
| * in srcRaster is copied to the same x,y address in this raster, unless | |
| * the address falls outside the bounds of this raster. srcRaster | |
| * must have the same number of bands as this WritableRaster. The | |
| * copy is a simple copy of source samples to the corresponding destination | |
| * samples. | |
| * <p> | |
| * If all samples of both source and destination Rasters are of | |
| * integral type and less than or equal to 32 bits in size, then calling | |
| * this method is equivalent to executing the following code for all | |
| * {@code x,y} addresses valid in both Rasters. | |
| * <pre>{@code | |
| * Raster srcRaster; | |
| * WritableRaster dstRaster; | |
| * for (int b = 0; b < srcRaster.getNumBands(); b++) { | |
| * dstRaster.setSample(x, y, b, srcRaster.getSample(x, y, b)); | |
| * } | |
| * }</pre> | |
| * Thus, when copying an integral type source to an integral type | |
| * destination, if the source sample size is greater than the destination | |
| * sample size for a particular band, the high order bits of the source | |
| * sample are truncated. If the source sample size is less than the | |
| * destination size for a particular band, the high order bits of the | |
| * destination are zero-extended or sign-extended depending on whether | |
| * srcRaster's SampleModel treats the sample as a signed or unsigned | |
| * quantity. | |
| * <p> | |
| * When copying a float or double source to an integral type destination, | |
| * each source sample is cast to the destination type. When copying an | |
| * integral type source to a float or double destination, the source | |
| * is first converted to a 32-bit int (if necessary), using the above | |
| * rules for integral types, and then the int is cast to float or | |
| * double. | |
| * | |
| * @param srcRaster The Raster from which to copy pixels. | |
| * | |
| * @throws NullPointerException if srcRaster is null. | |
| */ | |
| public void setRect(Raster srcRaster) { | |
| setRect(0,0,srcRaster); | |
| } | |
| /** | |
| * Copies pixels from Raster srcRaster to this WritableRaster. | |
| * For each (x, y) address in srcRaster, the corresponding pixel | |
| * is copied to address (x+dx, y+dy) in this WritableRaster, | |
| * unless (x+dx, y+dy) falls outside the bounds of this raster. | |
| * srcRaster must have the same number of bands as this WritableRaster. | |
| * The copy is a simple copy of source samples to the corresponding | |
| * destination samples. For details, see | |
| * {@link WritableRaster#setRect(Raster)}. | |
| * | |
| * @param dx The X translation factor from src space to dst space | |
| * of the copy. | |
| * @param dy The Y translation factor from src space to dst space | |
| * of the copy. | |
| * @param srcRaster The Raster from which to copy pixels. | |
| * | |
| * @throws NullPointerException if srcRaster is null. | |
| */ | |
| public void setRect(int dx, int dy, Raster srcRaster) { | |
| int srcOffX = srcRaster.getMinX(); | |
| int srcOffY = srcRaster.getMinY(); | |
| Rectangle bsrc = new Rectangle(dx+srcOffX, dy+srcOffY, srcRaster.getWidth(), srcRaster.getHeight()); | |
| Rectangle clip = bsrc.intersection(new Rectangle(minX, minY, width, height)); | |
| if (clip.isEmpty()) { | |
| return; | |
| } | |
| srcOffX += clip.x - bsrc.x; | |
| srcOffY += clip.y - bsrc.y; | |
| final int dstOffX = clip.x; | |
| final int dstOffY = clip.y; | |
| final int width = clip.width; | |
| final int height = clip.height; | |
| switch (srcRaster.getSampleModel().getDataType()) { | |
| case DataBuffer.TYPE_BYTE: | |
| case DataBuffer.TYPE_SHORT: | |
| case DataBuffer.TYPE_USHORT: | |
| case DataBuffer.TYPE_INT: | |
| int[] iData = null; | |
| for (int startY=0; startY < height; startY++) { | |
| // Grab one scanline at a time | |
| iData = | |
| srcRaster.getPixels(srcOffX, srcOffY+startY, width, 1, | |
| iData); | |
| setPixels(dstOffX, dstOffY+startY, width, 1, iData); | |
| } | |
| break; | |
| case DataBuffer.TYPE_FLOAT: | |
| float[] fData = null; | |
| for (int startY=0; startY < height; startY++) { | |
| fData = | |
| srcRaster.getPixels(srcOffX, srcOffY+startY, width, 1, | |
| fData); | |
| setPixels(dstOffX, dstOffY+startY, width, 1, fData); | |
| } | |
| break; | |
| case DataBuffer.TYPE_DOUBLE: | |
| double[] dData = null; | |
| for (int startY=0; startY < height; startY++) { | |
| // Grab one scanline at a time | |
| dData = | |
| srcRaster.getPixels(srcOffX, srcOffY+startY, width, 1, | |
| dData); | |
| setPixels(dstOffX, dstOffY+startY, width, 1, dData); | |
| } | |
| break; | |
| } | |
| } | |
| /** | |
| * Sets a pixel in the DataBuffer using an int array of samples for input. | |
| * An ArrayIndexOutOfBoundsException may be thrown if the coordinates are | |
| * not in bounds. | |
| * However, explicit bounds checking is not guaranteed. | |
| * @param x The X coordinate of the pixel location. | |
| * @param y The Y coordinate of the pixel location. | |
| * @param iArray The input samples in a int array. | |
| * | |
| * @throws NullPointerException if iArray is null. | |
| * @throws ArrayIndexOutOfBoundsException if the coordinates are not | |
| * in bounds, or if iArray is too small to hold the input. | |
| */ | |
| public void setPixel(int x, int y, int[] iArray) { | |
| sampleModel.setPixel(x-sampleModelTranslateX,y-sampleModelTranslateY, | |
| iArray,dataBuffer); | |
| } | |
| /** | |
| * Sets a pixel in the DataBuffer using a float array of samples for input. | |
| * An ArrayIndexOutOfBoundsException may be thrown if the coordinates are | |
| * not in bounds. | |
| * However, explicit bounds checking is not guaranteed. | |
| * @param x The X coordinate of the pixel location. | |
| * @param y The Y coordinate of the pixel location. | |
| * @param fArray The input samples in a float array. | |
| * | |
| * @throws NullPointerException if fArray is null. | |
| * @throws ArrayIndexOutOfBoundsException if the coordinates are not | |
| * in bounds, or if fArray is too small to hold the input. | |
| */ | |
| public void setPixel(int x, int y, float[] fArray) { | |
| sampleModel.setPixel(x-sampleModelTranslateX,y-sampleModelTranslateY, | |
| fArray,dataBuffer); | |
| } | |
| /** | |
| * Sets a pixel in the DataBuffer using a double array of samples for input. | |
| * An ArrayIndexOutOfBoundsException may be thrown if the coordinates are | |
| * not in bounds. | |
| * However, explicit bounds checking is not guaranteed. | |
| * @param x The X coordinate of the pixel location. | |
| * @param y The Y coordinate of the pixel location. | |
| * @param dArray The input samples in a double array. | |
| * | |
| * @throws NullPointerException if dArray is null. | |
| * @throws ArrayIndexOutOfBoundsException if the coordinates are not | |
| * in bounds, or if dArray is too small to hold the input. | |
| */ | |
| public void setPixel(int x, int y, double[] dArray) { | |
| sampleModel.setPixel(x-sampleModelTranslateX,y-sampleModelTranslateY, | |
| dArray,dataBuffer); | |
| } | |
| /** | |
| * Sets all samples for a rectangle of pixels from an int array containing | |
| * one sample per array element. | |
| * An ArrayIndexOutOfBoundsException may be thrown if the coordinates are | |
| * not in bounds. | |
| * However, explicit bounds checking is not guaranteed. | |
| * @param x The X coordinate of the upper left pixel location. | |
| * @param y The Y coordinate of the upper left pixel location. | |
| * @param w Width of the pixel rectangle. | |
| * @param h Height of the pixel rectangle. | |
| * @param iArray The input int pixel array. | |
| * | |
| * @throws NullPointerException if iArray is null. | |
| * @throws ArrayIndexOutOfBoundsException if the coordinates are not | |
| * in bounds, or if iArray is too small to hold the input. | |
| */ | |
| public void setPixels(int x, int y, int w, int h, int[] iArray) { | |
| sampleModel.setPixels(x-sampleModelTranslateX,y-sampleModelTranslateY, | |
| w,h,iArray,dataBuffer); | |
| } | |
| /** | |
| * Sets all samples for a rectangle of pixels from a float array containing | |
| * one sample per array element. | |
| * An ArrayIndexOutOfBoundsException may be thrown if the coordinates are | |
| * not in bounds. | |
| * However, explicit bounds checking is not guaranteed. | |
| * @param x The X coordinate of the upper left pixel location. | |
| * @param y The Y coordinate of the upper left pixel location. | |
| * @param w Width of the pixel rectangle. | |
| * @param h Height of the pixel rectangle. | |
| * @param fArray The input float pixel array. | |
| * | |
| * @throws NullPointerException if fArray is null. | |
| * @throws ArrayIndexOutOfBoundsException if the coordinates are not | |
| * in bounds, or if fArray is too small to hold the input. | |
| */ | |
| public void setPixels(int x, int y, int w, int h, float[] fArray) { | |
| sampleModel.setPixels(x-sampleModelTranslateX,y-sampleModelTranslateY, | |
| w,h,fArray,dataBuffer); | |
| } | |
| /** | |
| * Sets all samples for a rectangle of pixels from a double array containing | |
| * one sample per array element. | |
| * An ArrayIndexOutOfBoundsException may be thrown if the coordinates are | |
| * not in bounds. | |
| * However, explicit bounds checking is not guaranteed. | |
| * @param x The X coordinate of the upper left pixel location. | |
| * @param y The Y coordinate of the upper left pixel location. | |
| * @param w Width of the pixel rectangle. | |
| * @param h Height of the pixel rectangle. | |
| * @param dArray The input double pixel array. | |
| * | |
| * @throws NullPointerException if dArray is null. | |
| * @throws ArrayIndexOutOfBoundsException if the coordinates are not | |
| * in bounds, or if dArray is too small to hold the input. | |
| */ | |
| public void setPixels(int x, int y, int w, int h, double[] dArray) { | |
| sampleModel.setPixels(x-sampleModelTranslateX,y-sampleModelTranslateY, | |
| w,h,dArray,dataBuffer); | |
| } | |
| /** | |
| * Sets a sample in the specified band for the pixel located at (x,y) | |
| * in the DataBuffer using an int for input. | |
| * An ArrayIndexOutOfBoundsException may be thrown if the coordinates are | |
| * not in bounds. | |
| * However, explicit bounds checking is not guaranteed. | |
| * @param x The X coordinate of the pixel location. | |
| * @param y The Y coordinate of the pixel location. | |
| * @param b The band to set. | |
| * @param s The input sample. | |
| * | |
| * @throws ArrayIndexOutOfBoundsException if the coordinates or | |
| * the band index are not in bounds. | |
| */ | |
| public void setSample(int x, int y, int b, int s) { | |
| sampleModel.setSample(x-sampleModelTranslateX, | |
| y-sampleModelTranslateY, b, s, | |
| dataBuffer); | |
| } | |
| /** | |
| * Sets a sample in the specified band for the pixel located at (x,y) | |
| * in the DataBuffer using a float for input. | |
| * An ArrayIndexOutOfBoundsException may be thrown if the coordinates are | |
| * not in bounds. | |
| * However, explicit bounds checking is not guaranteed. | |
| * @param x The X coordinate of the pixel location. | |
| * @param y The Y coordinate of the pixel location. | |
| * @param b The band to set. | |
| * @param s The input sample as a float. | |
| * | |
| * @throws ArrayIndexOutOfBoundsException if the coordinates or | |
| * the band index are not in bounds. | |
| */ | |
| public void setSample(int x, int y, int b, float s){ | |
| sampleModel.setSample(x-sampleModelTranslateX,y-sampleModelTranslateY, | |
| b,s,dataBuffer); | |
| } | |
| /** | |
| * Sets a sample in the specified band for the pixel located at (x,y) | |
| * in the DataBuffer using a double for input. | |
| * An ArrayIndexOutOfBoundsException may be thrown if the coordinates are | |
| * not in bounds. | |
| * However, explicit bounds checking is not guaranteed. | |
| * @param x The X coordinate of the pixel location. | |
| * @param y The Y coordinate of the pixel location. | |
| * @param b The band to set. | |
| * @param s The input sample as a double. | |
| * | |
| * @throws ArrayIndexOutOfBoundsException if the coordinates or | |
| * the band index are not in bounds. | |
| */ | |
| public void setSample(int x, int y, int b, double s){ | |
| sampleModel.setSample(x-sampleModelTranslateX,y-sampleModelTranslateY, | |
| b,s,dataBuffer); | |
| } | |
| /** | |
| * Sets the samples in the specified band for the specified rectangle | |
| * of pixels from an int array containing one sample per array element. | |
| * An ArrayIndexOutOfBoundsException may be thrown if the coordinates are | |
| * not in bounds. | |
| * However, explicit bounds checking is not guaranteed. | |
| * @param x The X coordinate of the upper left pixel location. | |
| * @param y The Y coordinate of the upper left pixel location. | |
| * @param w Width of the pixel rectangle. | |
| * @param h Height of the pixel rectangle. | |
| * @param b The band to set. | |
| * @param iArray The input int sample array. | |
| * | |
| * @throws NullPointerException if iArray is null. | |
| * @throws ArrayIndexOutOfBoundsException if the coordinates or | |
| * the band index are not in bounds, or if iArray is too small to | |
| * hold the input. | |
| */ | |
| public void setSamples(int x, int y, int w, int h, int b, | |
| int[] iArray) { | |
| sampleModel.setSamples(x-sampleModelTranslateX,y-sampleModelTranslateY, | |
| w,h,b,iArray,dataBuffer); | |
| } | |
| /** | |
| * Sets the samples in the specified band for the specified rectangle | |
| * of pixels from a float array containing one sample per array element. | |
| * An ArrayIndexOutOfBoundsException may be thrown if the coordinates are | |
| * not in bounds. | |
| * However, explicit bounds checking is not guaranteed. | |
| * @param x The X coordinate of the upper left pixel location. | |
| * @param y The Y coordinate of the upper left pixel location. | |
| * @param w Width of the pixel rectangle. | |
| * @param h Height of the pixel rectangle. | |
| * @param b The band to set. | |
| * @param fArray The input float sample array. | |
| * | |
| * @throws NullPointerException if fArray is null. | |
| * @throws ArrayIndexOutOfBoundsException if the coordinates or | |
| * the band index are not in bounds, or if fArray is too small to | |
| * hold the input. | |
| */ | |
| public void setSamples(int x, int y, int w, int h, int b, | |
| float[] fArray) { | |
| sampleModel.setSamples(x-sampleModelTranslateX,y-sampleModelTranslateY, | |
| w,h,b,fArray,dataBuffer); | |
| } | |
| /** | |
| * Sets the samples in the specified band for the specified rectangle | |
| * of pixels from a double array containing one sample per array element. | |
| * An ArrayIndexOutOfBoundsException may be thrown if the coordinates are | |
| * not in bounds. | |
| * However, explicit bounds checking is not guaranteed. | |
| * @param x The X coordinate of the upper left pixel location. | |
| * @param y The Y coordinate of the upper left pixel location. | |
| * @param w Width of the pixel rectangle. | |
| * @param h Height of the pixel rectangle. | |
| * @param b The band to set. | |
| * @param dArray The input double sample array. | |
| * | |
| * @throws NullPointerException if dArray is null. | |
| * @throws ArrayIndexOutOfBoundsException if the coordinates or | |
| * the band index are not in bounds, or if dArray is too small to | |
| * hold the input. | |
| */ | |
| public void setSamples(int x, int y, int w, int h, int b, | |
| double[] dArray) { | |
| sampleModel.setSamples(x-sampleModelTranslateX,y-sampleModelTranslateY, | |
| w,h,b,dArray,dataBuffer); | |
| } | |
| } |